coreboot-gerrit April 2018

coreboot-gerrit@coreboot.org

1 participants
2168 discussions

Change in coreboot[master]: Revert "mb/google/reef: Override USB2 phy settings"
by build bot (Jenkins) (Code Review) 12 Apr '18

12 Apr '18

build bot (Jenkins) has posted comments on this change. ( https://review.coreboot.org/25630 ) Change subject: Revert "mb/google/reef: Override USB2 phy settings" ...................................................................... Patch Set 3: Build Successful https://qa.coreboot.org/job/coreboot-gerrit/70049/ : SUCCESS -- To view, visit https://review.coreboot.org/25630 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: coreboot Gerrit-Branch: master Gerrit-MessageType: comment Gerrit-Change-Id: I6de44d5240393409d9ec5835a9de0c23453300f7 Gerrit-Change-Number: 25630 Gerrit-PatchSet: 3 Gerrit-Owner: Tim Chen <tim-chen(a)quanta.corp-partner.google.com> Gerrit-Reviewer: Aaron Durbin <adurbin(a)chromium.org> Gerrit-Reviewer: Furquan Shaikh <furquan(a)google.com> Gerrit-Reviewer: Martin Roth <martinroth(a)google.com> Gerrit-Reviewer: Paul Menzel <paulepanter(a)users.sourceforge.net> Gerrit-Reviewer: Tim Chen <Tim-Chen(a)quantatw.com> Gerrit-Reviewer: Tim Chen <tim-chen(a)quanta.corp-partner.google.com> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-Comment-Date: Thu, 12 Apr 2018 11:34:08 +0000 Gerrit-HasComments: No Gerrit-HasLabels: No

1 0

Change in coreboot[master]: Revert "mb/google/coral: add usb2 phy setting override for some varia...
by build bot (Jenkins) (Code Review) 12 Apr '18

12 Apr '18

build bot (Jenkins) has posted comments on this change. ( https://review.coreboot.org/25629 ) Change subject: Revert "mb/google/coral: add usb2 phy setting override for some variants" ...................................................................... Patch Set 3: Build Successful https://qa.coreboot.org/job/coreboot-gerrit/70050/ : SUCCESS -- To view, visit https://review.coreboot.org/25629 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: coreboot Gerrit-Branch: master Gerrit-MessageType: comment Gerrit-Change-Id: Ie987061e27996b0acc8345bf9aadb42d2c940808 Gerrit-Change-Number: 25629 Gerrit-PatchSet: 3 Gerrit-Owner: Tim Chen <tim-chen(a)quanta.corp-partner.google.com> Gerrit-Reviewer: Aaron Durbin <adurbin(a)chromium.org> Gerrit-Reviewer: Martin Roth <martinroth(a)google.com> Gerrit-Reviewer: Pan Sheng-Liang <sl.pan.quantw(a)gmail.com> Gerrit-Reviewer: Patrick Georgi <pgeorgi(a)google.com> Gerrit-Reviewer: Paul Menzel <paulepanter(a)users.sourceforge.net> Gerrit-Reviewer: Ren Kuo <ren.kuo(a)quantatw.com> Gerrit-Reviewer: Tim Chen <Tim-Chen(a)quantatw.com> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-Comment-Date: Thu, 12 Apr 2018 11:32:48 +0000 Gerrit-HasComments: No Gerrit-HasLabels: No

1 0

Change in coreboot[master]: lib/bootmem: Introduce custom bootmem tags
by build bot (Jenkins) (Code Review) 12 Apr '18

12 Apr '18

build bot (Jenkins) has posted comments on this change. ( https://review.coreboot.org/25633 ) Change subject: lib/bootmem: Introduce custom bootmem tags ...................................................................... Patch Set 1: Verified+1 Build Successful https://qa.coreboot.org/job/coreboot-checkpatch/24315/ : SUCCESS https://qa.coreboot.org/job/coreboot-gerrit/70048/ : SUCCESS -- To view, visit https://review.coreboot.org/25633 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: coreboot Gerrit-Branch: master Gerrit-MessageType: comment Gerrit-Change-Id: I7be8fa792fc7933ca218ecd43d250d3a9c55caa6 Gerrit-Change-Number: 25633 Gerrit-PatchSet: 1 Gerrit-Owner: Patrick Rudolph <patrick.rudolph(a)9elements.com> Gerrit-Reviewer: Aaron Durbin <adurbin(a)chromium.org> Gerrit-Reviewer: David Hendricks <david.hendricks(a)gmail.com> Gerrit-Reviewer: Julius Werner <jwerner(a)chromium.org> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-Comment-Date: Thu, 12 Apr 2018 11:28:56 +0000 Gerrit-HasComments: No Gerrit-HasLabels: Yes

1 0

Change in coreboot[master]: lib: Raw import FDT devicetree from depthcharge
by build bot (Jenkins) (Code Review) 12 Apr '18

12 Apr '18

build bot (Jenkins) has posted comments on this change. ( https://review.coreboot.org/25632 ) Change subject: lib: Raw import FDT devicetree from depthcharge ...................................................................... Patch Set 1: Verified+1 Build Successful https://qa.coreboot.org/job/coreboot-checkpatch/24314/ : SUCCESS https://qa.coreboot.org/job/coreboot-gerrit/70047/ : SUCCESS -- To view, visit https://review.coreboot.org/25632 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: coreboot Gerrit-Branch: master Gerrit-MessageType: comment Gerrit-Change-Id: Ida75d4786eae38d84bfc71bf53573dafca8eda40 Gerrit-Change-Number: 25632 Gerrit-PatchSet: 1 Gerrit-Owner: Patrick Rudolph <patrick.rudolph(a)9elements.com> Gerrit-Reviewer: David Hendricks <david.hendricks(a)gmail.com> Gerrit-Reviewer: Julius Werner <jwerner(a)chromium.org> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-Comment-Date: Thu, 12 Apr 2018 11:26:40 +0000 Gerrit-HasComments: No Gerrit-HasLabels: Yes

1 0

Change in coreboot[master]: src/lib: Add uImage support
by build bot (Jenkins) (Code Review) 12 Apr '18

12 Apr '18

build bot (Jenkins) has posted comments on this change. ( https://review.coreboot.org/25019 ) Change subject: src/lib: Add uImage support ...................................................................... Patch Set 19: Verified+1 Build Successful https://qa.coreboot.org/job/coreboot-checkpatch/24313/ : SUCCESS https://qa.coreboot.org/job/coreboot-gerrit/70046/ : SUCCESS -- To view, visit https://review.coreboot.org/25019 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: coreboot Gerrit-Branch: master Gerrit-MessageType: comment Gerrit-Change-Id: I0f27b92a5e074966f893399eb401eb97d784850d Gerrit-Change-Number: 25019 Gerrit-PatchSet: 19 Gerrit-Owner: Patrick Rudolph <patrick.rudolph(a)9elements.com> Gerrit-Reviewer: David Hendricks <david.hendricks(a)gmail.com> Gerrit-Reviewer: Julius Werner <jwerner(a)chromium.org> Gerrit-Reviewer: Patrick Rudolph <patrick.rudolph(a)9elements.com> Gerrit-Reviewer: Paul Menzel <paulepanter(a)users.sourceforge.net> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-Comment-Date: Thu, 12 Apr 2018 11:24:52 +0000 Gerrit-HasComments: No Gerrit-HasLabels: Yes

1 0

Change in coreboot[master]: lib/bootmem: Add method to walk memory tables
by build bot (Jenkins) (Code Review) 12 Apr '18

12 Apr '18

build bot (Jenkins) has posted comments on this change. ( https://review.coreboot.org/25583 ) Change subject: lib/bootmem: Add method to walk memory tables ...................................................................... Patch Set 4: Verified+1 Build Successful https://qa.coreboot.org/job/coreboot-checkpatch/24311/ : SUCCESS https://qa.coreboot.org/job/coreboot-gerrit/70044/ : SUCCESS -- To view, visit https://review.coreboot.org/25583 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: coreboot Gerrit-Branch: master Gerrit-MessageType: comment Gerrit-Change-Id: I0004e5ad5fe2289827f370f0d0f9979d3cbd3926 Gerrit-Change-Number: 25583 Gerrit-PatchSet: 4 Gerrit-Owner: Patrick Rudolph <patrick.rudolph(a)9elements.com> Gerrit-Reviewer: Patrick Rudolph <patrick.rudolph(a)9elements.com> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-CC: Aaron Durbin <adurbin(a)chromium.org> Gerrit-Comment-Date: Thu, 12 Apr 2018 11:19:14 +0000 Gerrit-HasComments: No Gerrit-HasLabels: Yes

1 0

Change in coreboot[master]: lib/bootmem: Add more bootmem tags
by build bot (Jenkins) (Code Review) 12 Apr '18

12 Apr '18

build bot (Jenkins) has posted comments on this change. ( https://review.coreboot.org/25383 ) Change subject: lib/bootmem: Add more bootmem tags ...................................................................... Patch Set 12: Verified+1 Build Successful https://qa.coreboot.org/job/coreboot-checkpatch/24312/ : SUCCESS https://qa.coreboot.org/job/coreboot-gerrit/70045/ : SUCCESS -- To view, visit https://review.coreboot.org/25383 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: coreboot Gerrit-Branch: master Gerrit-MessageType: comment Gerrit-Change-Id: I0c983ce43616147c519a43edee3b61d54eadbb9a Gerrit-Change-Number: 25383 Gerrit-PatchSet: 12 Gerrit-Owner: Patrick Rudolph <patrick.rudolph(a)9elements.com> Gerrit-Reviewer: Aaron Durbin <adurbin(a)chromium.org> Gerrit-Reviewer: Patrick Rudolph <patrick.rudolph(a)9elements.com> Gerrit-Reviewer: Paul Menzel <paulepanter(a)users.sourceforge.net> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-CC: Julius Werner <jwerner(a)chromium.org> Gerrit-CC: Patrick Rudolph <siro(a)das-labor.org> Gerrit-Comment-Date: Thu, 12 Apr 2018 11:17:35 +0000 Gerrit-HasComments: No Gerrit-HasLabels: Yes

1 0

Change in coreboot[master]: lib/devicetree: Integrate flattened devicetree support
by build bot (Jenkins) (Code Review) 12 Apr '18

12 Apr '18

build bot (Jenkins) has posted comments on this change. ( https://review.coreboot.org/25523 ) Change subject: lib/devicetree: Integrate flattened devicetree support ...................................................................... Patch Set 6: Verified+1 Build Successful https://qa.coreboot.org/job/coreboot-checkpatch/24310/ : SUCCESS https://qa.coreboot.org/job/coreboot-gerrit/70043/ : SUCCESS -- To view, visit https://review.coreboot.org/25523 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: coreboot Gerrit-Branch: master Gerrit-MessageType: comment Gerrit-Change-Id: I6e6cd9f78fb402bd54d684097326d26eb78d552a Gerrit-Change-Number: 25523 Gerrit-PatchSet: 6 Gerrit-Owner: Patrick Rudolph <patrick.rudolph(a)9elements.com> Gerrit-Reviewer: David Hendricks <david.hendricks(a)gmail.com> Gerrit-Reviewer: Jonathan Neuschäfer <j.neuschaefer(a)gmx.net> Gerrit-Reviewer: Julius Werner <jwerner(a)chromium.org> Gerrit-Reviewer: Patrick Rudolph <patrick.rudolph(a)9elements.com> Gerrit-Reviewer: Paul Menzel <paulepanter(a)users.sourceforge.net> Gerrit-Reviewer: build bot (Jenkins) <no-reply(a)coreboot.org> Gerrit-Comment-Date: Thu, 12 Apr 2018 11:16:47 +0000 Gerrit-HasComments: No Gerrit-HasLabels: Yes

1 0

Change in coreboot[master]: lib/bootmem: Introduce custom bootmem tags
by Patrick Rudolph (Code Review) 12 Apr '18

12 Apr '18

Patrick Rudolph has uploaded this change for review. ( https://review.coreboot.org/25633 Change subject: lib/bootmem: Introduce custom bootmem tags ...................................................................... lib/bootmem: Introduce custom bootmem tags Introduce bootmem custom memory tags and use them instead of reusing LB_MEM tags. Tested with uImage payload on Cavium SoC. Change-Id: I7be8fa792fc7933ca218ecd43d250d3a9c55caa6 Signed-off-by: Patrick Rudolph <patrick.rudolph(a)9elements.com> --- M src/arch/x86/tables.c M src/include/bootmem.h M src/lib/bootmem.c M src/lib/imd_cbmem.c M src/lib/selfboot.c 5 files changed, 66 insertions(+), 21 deletions(-) git pull ssh://review.coreboot.org:29418/coreboot refs/changes/33/25633/1 diff --git a/src/arch/x86/tables.c b/src/arch/x86/tables.c index 057f665..0a9a3d5 100644 --- a/src/arch/x86/tables.c +++ b/src/arch/x86/tables.c @@ -266,5 +266,5 @@ /* Memory from 0 through the forwarding_table is reserved. */ const uintptr_t base = 0; - bootmem_add_range(base, forwarding_table - base, LB_MEM_TABLE); + bootmem_add_range(base, forwarding_table - base, BM_MEM_TABLE); } diff --git a/src/include/bootmem.h b/src/include/bootmem.h index 10c8d51..bfe31f2 100644 --- a/src/include/bootmem.h +++ b/src/include/bootmem.h @@ -20,6 +20,22 @@ #include <stdint.h> #include <boot/coreboot_tables.h> +/** + * Bootmem types match to LB_MEM tags. + * Start at 17 to make sure that the caller doesn't provide LB_MEM tags. + */ +enum bootmem_type { + BM_MEM_FIRST = 17, /* First entry in this list */ + BM_MEM_RAM, /* Memory anyone can use */ + BM_MEM_RESERVED, /* Don't use this memory region */ + BM_MEM_ACPI, /* ACPI Tables */ + BM_MEM_NVS, /* ACPI NVS Memory */ + BM_MEM_UNUSABLE, /* Unusable address space */ + BM_MEM_VENDOR_RSVD, /* Vendor Reserved */ + BM_MEM_TABLE, /* Ram configuration tables are kept in */ + BM_MEM_LAST, /* Last entry in this list */ +}; + /* * Initialize the memory address space prior to payload loading. The bootmem * serves as the source for the lb_mem table. @@ -30,7 +46,8 @@ void bootmem_arch_add_ranges(void); /* Add a range of a given type to the bootmem address space. */ -void bootmem_add_range(uint64_t start, uint64_t size, uint32_t type); +void bootmem_add_range(uint64_t start, uint64_t size, + const enum bootmem_type tag); /* Write memory coreboot table. */ void bootmem_write_memory_table(struct lb_memory *mem); diff --git a/src/lib/bootmem.c b/src/lib/bootmem.c index ea02a16..9d30b25 100644 --- a/src/lib/bootmem.c +++ b/src/lib/bootmem.c @@ -20,9 +20,34 @@ #include <cbmem.h> #include <device/resource.h> #include <stdlib.h> +#include <assert.h> static struct memranges bootmem; +/* Convert bootmem tag to LB_MEM tag */ +static uint32_t bootmem_to_lb_tag(const enum bootmem_type tag) +{ + switch (tag) { + case BM_MEM_RAM: + return LB_MEM_RAM; + case BM_MEM_RESERVED: + return LB_MEM_RESERVED; + case BM_MEM_ACPI: + return LB_MEM_ACPI; + case BM_MEM_NVS: + return LB_MEM_NVS; + case BM_MEM_UNUSABLE: + return LB_MEM_UNUSABLE; + case BM_MEM_VENDOR_RSVD: + return LB_MEM_VENDOR_RSVD; + case BM_MEM_TABLE: + return LB_MEM_TABLE; + default: + printk(BIOS_ERR, "ERROR: Unsupported tag %u\n", tag); + return LB_MEM_RESERVED; + } +} + void bootmem_init(void) { const unsigned long cacheable = IORESOURCE_CACHEABLE; @@ -34,8 +59,8 @@ * that each overlapping range will take over the next. Therefore, * add cacheable resources as RAM then add the reserved resources. */ - memranges_init(bm, cacheable, cacheable, LB_MEM_RAM); - memranges_add_resources(bm, reserved, reserved, LB_MEM_RESERVED); + memranges_init(bm, cacheable, cacheable, BM_MEM_RAM); + memranges_add_resources(bm, reserved, reserved, BM_MEM_RESERVED); /* Add memory used by CBMEM. */ cbmem_add_bootmem(); @@ -43,9 +68,12 @@ bootmem_arch_add_ranges(); } -void bootmem_add_range(uint64_t start, uint64_t size, uint32_t type) +void bootmem_add_range(uint64_t start, uint64_t size, + const enum bootmem_type tag) { - memranges_insert(&bootmem, start, size, type); + assert (tag > BM_MEM_FIRST && tag < BM_MEM_LAST); + + memranges_insert(&bootmem, start, size, tag); } void bootmem_write_memory_table(struct lb_memory *mem) @@ -60,7 +88,7 @@ memranges_each_entry(r, &bootmem) { lb_r->start = pack_lb64(range_entry_base(r)); lb_r->size = pack_lb64(range_entry_size(r)); - lb_r->type = range_entry_tag(r); + lb_r->type = bootmem_to_lb_tag(range_entry_tag(r)); lb_r++; mem->size += sizeof(struct lb_memory_range); @@ -68,21 +96,21 @@ } struct range_strings { - unsigned long tag; + enum bootmem_type tag; const char *str; }; static const struct range_strings type_strings[] = { - { LB_MEM_RAM, "RAM" }, - { LB_MEM_RESERVED, "RESERVED" }, - { LB_MEM_ACPI, "ACPI" }, - { LB_MEM_NVS, "NVS" }, - { LB_MEM_UNUSABLE, "UNUSABLE" }, - { LB_MEM_VENDOR_RSVD, "VENDOR RESERVED" }, - { LB_MEM_TABLE, "CONFIGURATION TABLES" }, + { BM_MEM_RAM, "RAM" }, + { BM_MEM_RESERVED, "RESERVED" }, + { BM_MEM_ACPI, "ACPI" }, + { BM_MEM_NVS, "NVS" }, + { BM_MEM_UNUSABLE, "UNUSABLE" }, + { BM_MEM_VENDOR_RSVD, "VENDOR RESERVED" }, + { BM_MEM_TABLE, "CONFIGURATION TABLES" }, }; -static const char *bootmem_range_string(unsigned long tag) +static const char *bootmem_range_string(const enum bootmem_type tag) { int i; @@ -119,7 +147,7 @@ break; if (start >= range_entry_base(r) && end <= range_entry_end(r)) { - if (range_entry_tag(r) == LB_MEM_RAM) + if (range_entry_tag(r) == BM_MEM_RAM) return 1; } } @@ -142,7 +170,7 @@ if (range_entry_size(r) < size) continue; - if (range_entry_tag(r) != LB_MEM_RAM) + if (range_entry_tag(r) != BM_MEM_RAM) continue; if (range_entry_base(r) >= max_addr) @@ -169,7 +197,7 @@ begin = end - size; /* Mark buffer as unusuable for future buffer use. */ - bootmem_add_range(begin, size, LB_MEM_UNUSABLE); + bootmem_add_range(begin, size, BM_MEM_UNUSABLE); return (void *)(uintptr_t)begin; } diff --git a/src/lib/imd_cbmem.c b/src/lib/imd_cbmem.c index 5713c2c..23dd74b 100644 --- a/src/lib/imd_cbmem.c +++ b/src/lib/imd_cbmem.c @@ -299,7 +299,7 @@ size_t size = 0; imd_region_used(cbmem_get_imd(), &baseptr, &size); - bootmem_add_range((uintptr_t)baseptr, size, LB_MEM_TABLE); + bootmem_add_range((uintptr_t)baseptr, size, BM_MEM_TABLE); } #if ENV_RAMSTAGE || (IS_ENABLED(CONFIG_EARLY_CBMEM_LIST) \ diff --git a/src/lib/selfboot.c b/src/lib/selfboot.c index 160e8f5..20886b4 100644 --- a/src/lib/selfboot.c +++ b/src/lib/selfboot.c @@ -381,7 +381,7 @@ */ if (check_regions) { bootmem_add_range(ptr->s_dstaddr, ptr->s_memsz, - LB_MEM_UNUSABLE); + BM_MEM_UNUSABLE); } if (!overlaps_coreboot(ptr)) -- To view, visit https://review.coreboot.org/25633 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: coreboot Gerrit-Branch: master Gerrit-MessageType: newchange Gerrit-Change-Id: I7be8fa792fc7933ca218ecd43d250d3a9c55caa6 Gerrit-Change-Number: 25633 Gerrit-PatchSet: 1 Gerrit-Owner: Patrick Rudolph <patrick.rudolph(a)9elements.com>

1 0

Change in coreboot[master]: lib: Raw import FDT devicetree from depthcharge
by Patrick Rudolph (Code Review) 12 Apr '18

12 Apr '18

Patrick Rudolph has uploaded this change for review. ( https://review.coreboot.org/25632 Change subject: lib: Raw import FDT devicetree from depthcharge ...................................................................... lib: Raw import FDT devicetree from depthcharge Import from https://chromium.googlesource.com/chromiumos/platform/depthcharge Coding style and coreboot integration will be done in a separate commit. Change-Id: Ida75d4786eae38d84bfc71bf53573dafca8eda40 Signed-off-by: Patrick Rudolph <patrick.rudolph(a)9elements.com> --- A src/include/device_tree.h A src/include/list.h A src/lib/device_tree.c A src/lib/list.c 4 files changed, 1,244 insertions(+), 0 deletions(-) git pull ssh://review.coreboot.org:29418/coreboot refs/changes/32/25632/1 diff --git a/src/include/device_tree.h b/src/include/device_tree.h new file mode 100644 index 0000000..7a2cfb2 --- /dev/null +++ b/src/include/device_tree.h @@ -0,0 +1,219 @@ +/* + * Copyright 2013 Google Inc. + * + * See file CREDITS for list of people who contributed to this + * project. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but without any warranty; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#ifndef __BASE_DEVICE_TREE_H__ +#define __BASE_DEVICE_TREE_H__ + +#include <stdint.h> + +#include "base/list.h" + +/* + * Flattened device tree structures/constants. + */ + +typedef struct FdtHeader { + uint32_t magic; + uint32_t totalsize; + uint32_t structure_offset; + uint32_t strings_offset; + uint32_t reserve_map_offset; + + uint32_t version; + uint32_t last_compatible_version; + + uint32_t boot_cpuid_phys; + + uint32_t strings_size; + uint32_t structure_size; +} FdtHeader; + +static const uint32_t FdtMagic = 0xd00dfeed; + +static const uint32_t TokenBeginNode = 1; +static const uint32_t TokenEndNode = 2; +static const uint32_t TokenProperty = 3; +static const uint32_t TokenEnd = 9; + +typedef struct FdtProperty +{ + const char *name; + void *data; + uint32_t size; +} FdtProperty; + + + +/* + * Unflattened device tree structures. + */ + +typedef struct DeviceTreeProperty +{ + FdtProperty prop; + + ListNode list_node; +} DeviceTreeProperty; + +typedef struct DeviceTreeNode +{ + const char *name; + // List of DeviceTreeProperty-s. + ListNode properties; + // List of DeviceTreeNodes. + ListNode children; + + ListNode list_node; +} DeviceTreeNode; + +typedef struct DeviceTreeReserveMapEntry +{ + uint64_t start; + uint64_t size; + + ListNode list_node; +} DeviceTreeReserveMapEntry; + +typedef struct DeviceTree +{ + void *header; + uint32_t header_size; + + ListNode reserve_map; + + DeviceTreeNode *root; +} DeviceTree; + + + +/* + * Flattened device tree functions. These generally return the number of bytes + * which were consumed reading the requested value. + */ + +// Read the property, if any, at offset offset. +int fdt_next_property(void *blob, uint32_t offset, FdtProperty *prop); +// Read the name of the node, if any, at offset offset. +int fdt_node_name(void *blob, uint32_t offset, const char **name); + +void fdt_print_node(void *blob, uint32_t offset); +int fdt_skip_node(void *blob, uint32_t offset); + +// Read a flattened device tree into a heirarchical structure which refers to +// the contents of the flattened tree in place. Modifying the flat tree +// invalidates the unflattened one. +DeviceTree *fdt_unflatten(void *blob); + + + +/* + * Unflattened device tree functions. + */ + +// Figure out how big a device tree would be if it were flattened. +uint32_t dt_flat_size(DeviceTree *tree); +// Flatten a device tree into the buffer pointed to by dest. +void dt_flatten(DeviceTree *tree, void *dest); +void dt_print_node(DeviceTreeNode *node); +// Read #address-cells and #size-cells properties from a node. +void dt_read_cell_props(DeviceTreeNode *node, u32 *addrcp, u32 *sizecp); +// Look up or create a node relative to a parent node, through its path +// represented as an array of strings. +DeviceTreeNode *dt_find_node(DeviceTreeNode *parent, const char **path, + u32 *addrcp, u32 *sizecp, int create); +// Look up or create a node relative to a parent node, through its path +// represented as a string of '/' separated node names. +DeviceTreeNode *dt_find_node_by_path(DeviceTreeNode *parent, const char *path, + u32 *addrcp, u32 *sizecp, int create); +// Look up a node relative to a parent node, through its compatible string. +DeviceTreeNode *dt_find_compat(DeviceTreeNode *parent, const char *compatible); +// Look up the next child of a parent node, through its compatible string. It +// uses child pointer as the marker to find next. +DeviceTreeNode *dt_find_next_compat_child(DeviceTreeNode *parent, + DeviceTreeNode *child, + const char *compat); +// Look up a node relative to a parent node, through its property value. +DeviceTreeNode *dt_find_prop_value(DeviceTreeNode *parent, const char *name, + void *data, size_t size); +// Write src into *dest as a 'length'-byte big-endian integer. +void dt_write_int(u8 *dest, u64 src, size_t length); +// Add different kinds of properties to a node, or update existing ones. +void dt_add_bin_prop(DeviceTreeNode *node, char *name, void *data, size_t size); +void dt_add_string_prop(DeviceTreeNode *node, char *name, char *str); +void dt_add_u32_prop(DeviceTreeNode *node, char *name, u32 val); +void dt_add_reg_prop(DeviceTreeNode *node, u64 *addrs, u64 *sizes, + int count, u32 addr_cells, u32 size_cells); +int dt_set_bin_prop_by_path(DeviceTree *tree, const char *path, + void *data, size_t size, int create); + +void dt_find_bin_prop(DeviceTreeNode *node, const char *name, void **data, + size_t *size); +const char *dt_find_string_prop(DeviceTreeNode *node, const char *name); + +/* + * Fixups to apply to a kernel's device tree before booting it. + */ + +typedef struct DeviceTreeFixup +{ + // The function which does the fixing. + int (*fixup)(struct DeviceTreeFixup *fixup, DeviceTree *tree); + + ListNode list_node; +} DeviceTreeFixup; + +extern ListNode device_tree_fixups; + +int dt_apply_fixups(DeviceTree *tree); + +/* + * Structure defining mapping between arbitrary objects and the device tree + * path to the property corresponding to the object. + */ +typedef struct { + int force_create; /* If false - do not create a new node. */ + const char *dt_path; + const char *key; +} DtPathMap; + +/* + * Copy mac addresses from sysinfo table into the device tree. The mapping + * between the dt_maps entries and sysinfo mac address table elements is + * implicit, i.e. the device tree node found in the maps entry, gets assinged + * the mac address found in the sysinfo table, in the same order. + */ +int dt_set_mac_addresses(DeviceTree *tree, const DtPathMap *dt_maps); + +/* + * Copy WIFI calibration data from sysinfo table into the device tree. Each + * WIFI calibration blob stored the sysinfo table contains key and data. The + * key is used for mapping into the device tree path. The data becomes the + * contents of the device tree property at that path. + */ +int dt_set_wifi_calibration(DeviceTree *tree, const DtPathMap *maps); + +/* + * Retrieve Country Code data from VPD and add it into the device tree. + */ +int dt_set_wifi_country_code(DeviceTree *tree, const DtPathMap *maps); + +/* + * Init/retrieve the /reserved-memory/ node. + */ +DeviceTreeNode *dt_init_reserved_memory_node(DeviceTree *tree); + +#endif /* __BASE_DEVICE_TREE_H__ */ diff --git a/src/include/list.h b/src/include/list.h new file mode 100644 index 0000000..084c8f0 --- /dev/null +++ b/src/include/list.h @@ -0,0 +1,44 @@ +/* + * Copyright 2012 Google Inc. + * + * See file CREDITS for list of people who contributed to this + * project. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but without any warranty; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#ifndef __BASE_LIST_H__ +#define __BASE_LIST_H__ + +#include <stddef.h> +#include <stdint.h> + +#include "base/container_of.h" + +typedef struct ListNode { + struct ListNode *next; + struct ListNode *prev; +} ListNode; + +// Remove ListNode node from the doubly linked list it's a part of. +void list_remove(ListNode *node); +// Insert ListNode node after ListNode after in a doubly linked list. +void list_insert_after(ListNode *node, ListNode *after); +// Insert ListNode node before ListNode before in a doubly linked list. +void list_insert_before(ListNode *node, ListNode *before); + +#define list_for_each(ptr, head, member) \ + for ((ptr) = container_of((head).next, typeof(*(ptr)), member); \ + &((ptr)->member); \ + (ptr) = container_of((ptr)->member.next, \ + typeof(*(ptr)), member)) + +#endif /* __BASE_LIST_H__ */ diff --git a/src/lib/device_tree.c b/src/lib/device_tree.c new file mode 100644 index 0000000..5f77870 --- /dev/null +++ b/src/lib/device_tree.c @@ -0,0 +1,937 @@ +/* + * Copyright 2013 Google Inc. + * + * See file CREDITS for list of people who contributed to this + * project. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but without any warranty; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include <assert.h> +#include <endian.h> +#include <libpayload.h> +#include <stdint.h> + +#include "base/device_tree.h" + +/* + * Functions for picking apart flattened trees. + */ + +static uint32_t size32(uint32_t val) +{ + return (val + sizeof(uint32_t) - 1) / sizeof(uint32_t); +} + +int fdt_next_property(void *blob, uint32_t offset, FdtProperty *prop) +{ + FdtHeader *header = (FdtHeader *)blob; + uint32_t *ptr = (uint32_t *)(((uint8_t *)blob) + offset); + + int index = 0; + if (betohl(ptr[index++]) != TokenProperty) + return 0; + + uint32_t size = betohl(ptr[index++]); + uint32_t name_offset = betohl(ptr[index++]); + name_offset += betohl(header->strings_offset); + + if (prop) { + prop->name = (char *)((uint8_t *)blob + name_offset); + prop->data = &ptr[index]; + prop->size = size; + } + + index += size32(size); + + return index * 4; +} + +int fdt_node_name(void *blob, uint32_t offset, const char **name) +{ + uint8_t *ptr = ((uint8_t *)blob) + offset; + + if (betohl(*(uint32_t *)ptr) != TokenBeginNode) + return 0; + + ptr += 4; + if (name) + *name = (char *)ptr; + return size32(strlen((char *)ptr) + 1) * sizeof(uint32_t) + 4; +} + + + +/* + * Functions for printing flattened trees. + */ + +static void print_indent(int depth) +{ + while (depth--) + printf(" "); +} + +static void print_property(FdtProperty *prop, int depth) +{ + print_indent(depth); + printf("prop \"%s\" (%d bytes).\n", prop->name, prop->size); + print_indent(depth + 1); + for (int i = 0; i < MIN(25, prop->size); i++) { + printf("%02x ", ((uint8_t *)prop->data)[i]); + } + if (prop->size > 25) + printf("..."); + printf("\n"); +} + +static int print_flat_node(void *blob, uint32_t start_offset, int depth) +{ + int offset = start_offset; + const char *name; + int size; + + size = fdt_node_name(blob, offset, &name); + if (!size) + return 0; + offset += size; + + print_indent(depth); + printf("name = %s\n", name); + + FdtProperty prop; + while ((size = fdt_next_property(blob, offset, &prop))) { + print_property(&prop, depth + 1); + + offset += size; + } + + while ((size = print_flat_node(blob, offset, depth + 1))) + offset += size; + + return offset - start_offset + sizeof(uint32_t); +} + +void fdt_print_node(void *blob, uint32_t offset) +{ + print_flat_node(blob, offset, 0); +} + + + +/* + * A utility function to skip past nodes in flattened trees. + */ + +int fdt_skip_node(void *blob, uint32_t start_offset) +{ + int offset = start_offset; + int size; + + const char *name; + size = fdt_node_name(blob, offset, &name); + if (!size) + return 0; + offset += size; + + while ((size = fdt_next_property(blob, offset, NULL))) + offset += size; + + while ((size = fdt_skip_node(blob, offset))) + offset += size; + + return offset - start_offset + sizeof(uint32_t); +} + + + +/* + * Functions to turn a flattened tree into an unflattened one. + */ + +static DeviceTreeNode node_cache[1000]; +static int node_counter = 0; +static DeviceTreeProperty prop_cache[5000]; +static int prop_counter = 0; + +/* + * Libpayload's malloc() has linear allocation complexity and goes completely + * mental after a few thousand small requests. This little hack will absorb + * the worst of it to avoid increasing boot time for no reason. + */ +static DeviceTreeNode *alloc_node(void) +{ + if (node_counter >= ARRAY_SIZE(node_cache)) + return xzalloc(sizeof(DeviceTreeNode)); + return &node_cache[node_counter++]; +} +static DeviceTreeProperty *alloc_prop(void) +{ + if (prop_counter >= ARRAY_SIZE(prop_cache)) + return xzalloc(sizeof(DeviceTreeProperty)); + return &prop_cache[prop_counter++]; +} + +static int fdt_unflatten_node(void *blob, uint32_t start_offset, + DeviceTreeNode **new_node) +{ + ListNode *last; + int offset = start_offset; + const char *name; + int size; + + size = fdt_node_name(blob, offset, &name); + if (!size) + return 0; + offset += size; + + DeviceTreeNode *node = alloc_node(); + *new_node = node; + node->name = name; + + FdtProperty fprop; + last = &node->properties; + while ((size = fdt_next_property(blob, offset, &fprop))) { + DeviceTreeProperty *prop = alloc_prop(); + prop->prop = fprop; + + list_insert_after(&prop->list_node, last); + last = &prop->list_node; + + offset += size; + } + + DeviceTreeNode *child; + last = &node->children; + while ((size = fdt_unflatten_node(blob, offset, &child))) { + list_insert_after(&child->list_node, last); + last = &child->list_node; + + offset += size; + } + + return offset - start_offset + sizeof(uint32_t); +} + +static int fdt_unflatten_map_entry(void *blob, uint32_t offset, + DeviceTreeReserveMapEntry **new_entry) +{ + uint64_t *ptr = (uint64_t *)(((uint8_t *)blob) + offset); + uint64_t start = betohll(ptr[0]); + uint64_t size = betohll(ptr[1]); + + if (!size) + return 0; + + DeviceTreeReserveMapEntry *entry = xzalloc(sizeof(*entry)); + *new_entry = entry; + entry->start = start; + entry->size = size; + + return sizeof(uint64_t) * 2; +} + +DeviceTree *fdt_unflatten(void *blob) +{ + DeviceTree *tree = xzalloc(sizeof(*tree)); + FdtHeader *header = (FdtHeader *)blob; + tree->header = header; + + uint32_t struct_offset = betohl(header->structure_offset); + uint32_t strings_offset = betohl(header->strings_offset); + uint32_t reserve_offset = betohl(header->reserve_map_offset); + uint32_t min_offset = 0; + min_offset = MIN(struct_offset, strings_offset); + min_offset = MIN(min_offset, reserve_offset); + // Assume everything up to the first non-header component is part of + // the header and needs to be preserved. This will protect us against + // new elements being added in the future. + tree->header_size = min_offset; + + DeviceTreeReserveMapEntry *entry; + uint32_t offset = reserve_offset; + int size; + ListNode *last = &tree->reserve_map; + while ((size = fdt_unflatten_map_entry(blob, offset, &entry))) { + list_insert_after(&entry->list_node, last); + last = &entry->list_node; + + offset += size; + } + + fdt_unflatten_node(blob, struct_offset, &tree->root); + + return tree; +} + + + +/* + * Functions to find the size of device tree would take if it was flattened. + */ + +static void dt_flat_prop_size(DeviceTreeProperty *prop, uint32_t *struct_size, + uint32_t *strings_size) +{ + // Starting token. + *struct_size += sizeof(uint32_t); + // Size. + *struct_size += sizeof(uint32_t); + // Name offset. + *struct_size += sizeof(uint32_t); + // Property value. + *struct_size += size32(prop->prop.size) * sizeof(uint32_t); + + // Property name. + *strings_size += strlen(prop->prop.name) + 1; +} + +static void dt_flat_node_size(DeviceTreeNode *node, uint32_t *struct_size, + uint32_t *strings_size) +{ + // Starting token. + *struct_size += sizeof(uint32_t); + // Node name. + *struct_size += size32(strlen(node->name) + 1) * sizeof(uint32_t); + + DeviceTreeProperty *prop; + list_for_each(prop, node->properties, list_node) + dt_flat_prop_size(prop, struct_size, strings_size); + + DeviceTreeNode *child; + list_for_each(child, node->children, list_node) + dt_flat_node_size(child, struct_size, strings_size); + + // End token. + *struct_size += sizeof(uint32_t); +} + +uint32_t dt_flat_size(DeviceTree *tree) +{ + uint32_t size = tree->header_size; + DeviceTreeReserveMapEntry *entry; + list_for_each(entry, tree->reserve_map, list_node) + size += sizeof(uint64_t) * 2; + size += sizeof(uint64_t) * 2; + + uint32_t struct_size = 0; + uint32_t strings_size = 0; + dt_flat_node_size(tree->root, &struct_size, &strings_size); + + size += struct_size; + // End token. + size += sizeof(uint32_t); + + size += strings_size; + + return size; +} + + + +/* + * Functions to flatten a device tree. + */ + +static void dt_flatten_map_entry(DeviceTreeReserveMapEntry *entry, + void **map_start) +{ + ((uint64_t *)*map_start)[0] = htobell(entry->start); + ((uint64_t *)*map_start)[1] = htobell(entry->size); + *map_start = ((uint8_t *)*map_start) + sizeof(uint64_t) * 2; +} + +static void dt_flatten_prop(DeviceTreeProperty *prop, void **struct_start, + void *strings_base, void **strings_start) +{ + uint8_t *dstruct = (uint8_t *)*struct_start; + uint8_t *dstrings = (uint8_t *)*strings_start; + + *((uint32_t *)dstruct) = htobel(TokenProperty); + dstruct += sizeof(uint32_t); + + *((uint32_t *)dstruct) = htobel(prop->prop.size); + dstruct += sizeof(uint32_t); + + uint32_t name_offset = (uintptr_t)dstrings - (uintptr_t)strings_base; + *((uint32_t *)dstruct) = htobel(name_offset); + dstruct += sizeof(uint32_t); + + strcpy((char *)dstrings, prop->prop.name); + dstrings += strlen(prop->prop.name) + 1; + + memcpy(dstruct, prop->prop.data, prop->prop.size); + dstruct += size32(prop->prop.size) * 4; + + *struct_start = dstruct; + *strings_start = dstrings; +} + +static void dt_flatten_node(DeviceTreeNode *node, void **struct_start, + void *strings_base, void **strings_start) +{ + uint8_t *dstruct = (uint8_t *)*struct_start; + uint8_t *dstrings = (uint8_t *)*strings_start; + + *((uint32_t *)dstruct) = htobel(TokenBeginNode); + dstruct += sizeof(uint32_t); + + strcpy((char *)dstruct, node->name); + dstruct += size32(strlen(node->name) + 1) * 4; + + DeviceTreeProperty *prop; + list_for_each(prop, node->properties, list_node) + dt_flatten_prop(prop, (void **)&dstruct, strings_base, + (void **)&dstrings); + + DeviceTreeNode *child; + list_for_each(child, node->children, list_node) + dt_flatten_node(child, (void **)&dstruct, strings_base, + (void **)&dstrings); + + *((uint32_t *)dstruct) = htobel(TokenEndNode); + dstruct += sizeof(uint32_t); + + *struct_start = dstruct; + *strings_start = dstrings; +} + +void dt_flatten(DeviceTree *tree, void *start_dest) +{ + uint8_t *dest = (uint8_t *)start_dest; + + memcpy(dest, tree->header, tree->header_size); + FdtHeader *header = (FdtHeader *)dest; + dest += tree->header_size; + + DeviceTreeReserveMapEntry *entry; + list_for_each(entry, tree->reserve_map, list_node) + dt_flatten_map_entry(entry, (void **)&dest); + ((uint64_t *)dest)[0] = ((uint64_t *)dest)[1] = 0; + dest += sizeof(uint64_t) * 2; + + uint32_t struct_size = 0; + uint32_t strings_size = 0; + dt_flat_node_size(tree->root, &struct_size, &strings_size); + + uint8_t *struct_start = dest; + header->structure_offset = htobel(dest - (uint8_t *)start_dest); + header->structure_size = htobel(struct_size); + dest += struct_size; + + *((uint32_t *)dest) = htobel(TokenEnd); + dest += sizeof(uint32_t); + + uint8_t *strings_start = dest; + header->strings_offset = htobel(dest - (uint8_t *)start_dest); + header->strings_size = htobel(strings_size); + dest += strings_size; + + dt_flatten_node(tree->root, (void **)&struct_start, strings_start, + (void **)&strings_start); + + header->totalsize = htobel(dest - (uint8_t *)start_dest); +} + + + +/* + * Functions for printing a non-flattened device tree. + */ + +static void print_node(DeviceTreeNode *node, int depth) +{ + print_indent(depth); + printf("name = %s\n", node->name); + + DeviceTreeProperty *prop; + list_for_each(prop, node->properties, list_node) + print_property(&prop->prop, depth + 1); + + DeviceTreeNode *child; + list_for_each(child, node->children, list_node) + print_node(child, depth + 1); +} + +void dt_print_node(DeviceTreeNode *node) +{ + print_node(node, 0); +} + + + +/* + * Functions for reading and manipulating an unflattened device tree. + */ + +/* + * Read #address-cells and #size-cells properties from a node. + * + * @param node The device tree node to read from. + * @param addrcp Pointer to store #address-cells in, skipped if NULL. + * @param sizecp Pointer to store #size-cells in, skipped if NULL. + */ +void dt_read_cell_props(DeviceTreeNode *node, u32 *addrcp, u32 *sizecp) +{ + DeviceTreeProperty *prop; + list_for_each(prop, node->properties, list_node) { + if (addrcp && !strcmp("#address-cells", prop->prop.name)) + *addrcp = betohl(*(u32 *)prop->prop.data); + if (sizecp && !strcmp("#size-cells", prop->prop.name)) + *sizecp = betohl(*(u32 *)prop->prop.data); + } +} + +/* + * Find a node from a device tree path, relative to a parent node. + * + * @param parent The node from which to start the relative path lookup. + * @param path An array of path component strings that will be looked + * up in order to find the node. Must be terminated with + * a NULL pointer. Example: {'firmware', 'coreboot', NULL} + * @param addrcp Pointer that will be updated with any #address-cells + * value found in the path. May be NULL to ignore. + * @param sizecp Pointer that will be updated with any #size-cells + * value found in the path. May be NULL to ignore. + * @param create 1: Create node(s) if not found. 0: Return NULL instead. + * @return The found/created node, or NULL. + */ +DeviceTreeNode *dt_find_node(DeviceTreeNode *parent, const char **path, + u32 *addrcp, u32 *sizecp, int create) +{ + DeviceTreeNode *node, *found = NULL; + + // Update #address-cells and #size-cells for this level. + dt_read_cell_props(parent, addrcp, sizecp); + + if (!*path) + return parent; + + // Find the next node in the path, if it exists. + list_for_each(node, parent->children, list_node) { + if (!strcmp(node->name, *path)) { + found = node; + break; + } + } + + // Otherwise create it or return NULL. + if (!found) { + if (!create) + return NULL; + + found = alloc_node(); + found->name = strdup(*path); + if (!found->name) + return NULL; + + list_insert_after(&found->list_node, &parent->children); + } + + return dt_find_node(found, path + 1, addrcp, sizecp, create); +} + +/* + * Find a node from a string device tree path, relative to a parent node. + * + * @param parent The node from which to start the relative path lookup. + * @param path A string representing a path in the device tree, with + * nodes separated by '/'. Example: "soc/firmware/coreboot" + * @param addrcp Pointer that will be updated with any #address-cells + * value found in the path. May be NULL to ignore. + * @param sizecp Pointer that will be updated with any #size-cells + * value found in the path. May be NULL to ignore. + * @param create 1: Create node(s) if not found. 0: Return NULL instead. + * @return The found/created node, or NULL. + * + * It is the caller responsibility to provide the correct path string, namely + * not starting or ending with a '/', and not having "//" anywhere in it. + */ +DeviceTreeNode *dt_find_node_by_path(DeviceTreeNode *parent, const char *path, + u32 *addrcp, u32 *sizecp, int create) +{ + char *dup_path = strdup(path); + /* Hopefully enough depth for any node. */ + const char *path_array[15]; + int i; + char *next_slash; + DeviceTreeNode *node = NULL; + + if (!dup_path) + return NULL; + + next_slash = dup_path; + path_array[0] = dup_path; + for (i = 1; i < (ARRAY_SIZE(path_array) - 1); i++) { + + next_slash = strchr(next_slash, '/'); + if (!next_slash) + break; + + *next_slash++ = '\0'; + path_array[i] = next_slash; + } + + if (!next_slash) { + path_array[i] = NULL; + node = dt_find_node(parent, path_array, + addrcp, sizecp, create); + } + + free(dup_path); + return node; +} + +/* + * Check if given node is compatible. + * + * @param node The node which is to be checked for compatible property. + * @param compat The compatible string to match. + * @return 1 = compatible, 0 = not compatible. + */ +static int dt_check_compat_match(DeviceTreeNode *node, const char *compat) +{ + DeviceTreeProperty *prop; + + list_for_each(prop, node->properties, list_node) { + if (!strcmp("compatible", prop->prop.name)) { + size_t bytes = prop->prop.size; + const char *str = prop->prop.data; + while (bytes > 0) { + if (!strncmp(compat, str, bytes)) + return 1; + size_t len = strnlen(str, bytes) + 1; + if (bytes <= len) + break; + str += len; + bytes -= len; + } + break; + } + } + + return 0; +} + +/* + * Find a node from a compatible string, in the subtree of a parent node. + * + * @param parent The parent node under which to look. + * @param compat The compatible string to find. + * @return The found node, or NULL. + */ +DeviceTreeNode *dt_find_compat(DeviceTreeNode *parent, const char *compat) +{ + // Check if the parent node itself is compatible. + if (dt_check_compat_match(parent, compat)) + return parent; + + DeviceTreeNode *child; + list_for_each(child, parent->children, list_node) { + DeviceTreeNode *found = dt_find_compat(child, compat); + if (found) + return found; + } + + return NULL; +} + +/* + * Find the next compatible child of a given parent. All children upto the + * child passed in by caller are ignored. If child is NULL, it considers all the + * children to find the first child which is compatible. + * + * @param parent The parent node under which to look. + * @param child The child node to start search from (exclusive). If NULL + * consider all children. + * @param compat The compatible string to find. + * @return The found node, or NULL. + */ +DeviceTreeNode *dt_find_next_compat_child(DeviceTreeNode *parent, + DeviceTreeNode *child, + const char *compat) +{ + DeviceTreeNode *next; + int ignore = 0; + + if (child) + ignore = 1; + + list_for_each(next, parent->children, list_node) { + if (ignore) { + if (child == next) + ignore = 0; + continue; + } + + if (dt_check_compat_match(next, compat)) + return next; + } + + return NULL; +} + +/* + * Find a node with matching property value, in the subtree of a parent node. + * + * @param parent The parent node under which to look. + * @param name The property name to look for. + * @param data The property value to look for. + * @param size The property size. + */ +DeviceTreeNode *dt_find_prop_value(DeviceTreeNode *parent, const char *name, + void *data, size_t size) +{ + DeviceTreeProperty *prop; + + /* Check if parent itself has the required property value. */ + list_for_each(prop, parent->properties, list_node) { + if (!strcmp(name, prop->prop.name)) { + size_t bytes = prop->prop.size; + void *prop_data = prop->prop.data; + if (size != bytes) + break; + if (!memcmp(data, prop_data, size)) + return parent; + break; + } + } + + DeviceTreeNode *child; + list_for_each(child, parent->children, list_node) { + DeviceTreeNode *found = dt_find_prop_value(child, name, data, + size); + if (found) + return found; + } + return NULL; +} + +/* + * Write an arbitrary sized big-endian integer into a pointer. + * + * @param dest Pointer to the DT property data buffer to write. + * @param src The integer to write (in CPU endianess). + * @param length the length of the destination integer in bytes. + */ +void dt_write_int(u8 *dest, u64 src, size_t length) +{ + while (length--) { + dest[length] = (u8)src; + src >>= 8; + } +} + +/* + * Add an arbitrary property to a node, or update it if it already exists. + * + * @param node The device tree node to add to. + * @param name The name of the new property. + * @param data The raw data blob to be stored in the property. + * @param size The size of data in bytes. + */ +void dt_add_bin_prop(DeviceTreeNode *node, char *name, void *data, size_t size) +{ + DeviceTreeProperty *prop; + + list_for_each(prop, node->properties, list_node) { + if (!strcmp(prop->prop.name, name)) { + prop->prop.data = data; + prop->prop.size = size; + return; + } + } + + prop = alloc_prop(); + list_insert_after(&prop->list_node, &node->properties); + prop->prop.name = name; + prop->prop.data = data; + prop->prop.size = size; +} + +/* + * Find given string property in a node and return its content. + * + * @param node The device tree node to search. + * @param name The name of the property. + * @return The found string, or NULL. + */ +const char *dt_find_string_prop(DeviceTreeNode *node, const char *name) +{ + void *content; + size_t size; + + dt_find_bin_prop(node, name, &content, &size); + + return content; +} + +/* + * Find given property in a node. + * + * @param node The device tree node to search. + * @param name The name of the property. + * @param data Pointer to return raw data blob in the property. + * @param size Pointer to return the size of data in bytes. + */ +void dt_find_bin_prop(DeviceTreeNode *node, const char *name, void **data, + size_t *size) +{ + DeviceTreeProperty *prop; + + *data = NULL; + *size = 0; + + list_for_each(prop, node->properties, list_node) { + if (!strcmp(prop->prop.name, name)) { + *data = prop->prop.data; + *size = prop->prop.size; + return; + } + } +} + +/* + * Add a string property to a node, or update it if it already exists. + * + * @param node The device tree node to add to. + * @param name The name of the new property. + * @param str The zero-terminated string to be stored in the property. + */ +void dt_add_string_prop(DeviceTreeNode *node, char *name, char *str) +{ + dt_add_bin_prop(node, name, str, strlen(str) + 1); +} + +/* + * Add a 32-bit integer property to a node, or update it if it already exists. + * + * @param node The device tree node to add to. + * @param name The name of the new property. + * @param val The integer to be stored in the property. + */ +void dt_add_u32_prop(DeviceTreeNode *node, char *name, u32 val) +{ + u32 *val_ptr = xmalloc(sizeof(val)); + *val_ptr = htobel(val); + dt_add_bin_prop(node, name, val_ptr, sizeof(*val_ptr)); +} + +/* + * Add a 'reg' address list property to a node, or update it if it exists. + * + * @param node The device tree node to add to. + * @param addrs Array of address values to be stored in the property. + * @param sizes Array of corresponding size values to 'addrs'. + * @param count Number of values in 'addrs' and 'sizes' (must be equal). + * @param addr_cells Value of #address-cells property valid for this node. + * @param size_cells Value of #size-cells property valid for this node. + */ +void dt_add_reg_prop(DeviceTreeNode *node, u64 *addrs, u64 *sizes, + int count, u32 addr_cells, u32 size_cells) +{ + int i; + size_t length = (addr_cells + size_cells) * sizeof(u32) * count; + u8 *data = xmalloc(length); + u8 *cur = data; + + for (i = 0; i < count; i++) { + dt_write_int(cur, addrs[i], addr_cells * sizeof(u32)); + cur += addr_cells * sizeof(u32); + dt_write_int(cur, sizes[i], size_cells * sizeof(u32)); + cur += size_cells * sizeof(u32); + } + + dt_add_bin_prop(node, "reg", data, length); +} + +/* + * Fixups to apply to a kernel's device tree before booting it. + */ + +ListNode device_tree_fixups; + +int dt_apply_fixups(DeviceTree *tree) +{ + DeviceTreeFixup *fixup; + list_for_each(fixup, device_tree_fixups, list_node) { + assert(fixup->fixup); + if (fixup->fixup(fixup, tree)) + return 1; + } + return 0; +} + +int dt_set_bin_prop_by_path(DeviceTree *tree, const char *path, + void *data, size_t data_size, int create) +{ + char *path_copy, *prop_name; + DeviceTreeNode *dt_node; + + path_copy = strdup(path); + + if (!path_copy) { + printf("Failed to allocate a copy of path %s\n", path); + return 1; + } + + prop_name = strrchr(path_copy, '/'); + if (!prop_name) { + printf("Path %s does not include '/'\n", path); + free(path_copy); + return 1; + } + + *prop_name++ = '\0'; /* Separate path from the property name. */ + + dt_node = dt_find_node_by_path(tree->root, path_copy, NULL, + NULL, create); + + if (!dt_node) { + printf("Failed to %s %s in the device tree\n", + create ? "create" : "find", path_copy); + free(path_copy); + return 1; + } + + dt_add_bin_prop(dt_node, prop_name, data, data_size); + + return 0; +} + +/* + * Prepare the /reserved-memory/ node. + * + * Technically, this can be called more than one time, to init and/or retrieve + * the node. But dt_add_u32_prop() may leak a bit of memory if you do. + * + * @tree: Device tree to add/retrieve from. + * @return: The /reserved-memory/ node (or NULL, if error). + */ +DeviceTreeNode *dt_init_reserved_memory_node(DeviceTree *tree) +{ + DeviceTreeNode *reserved; + u32 addr = 0, size = 0; + + reserved = dt_find_node_by_path(tree->root, "reserved-memory", &addr, + &size, 1); + if (!reserved) + return NULL; + + // Binding doc says this should have the same #{address,size}-cells as + // the root. + dt_add_u32_prop(reserved, "#address-cells", addr); + dt_add_u32_prop(reserved, "#size-cells", size); + // Binding doc says this should be empty (i.e., 1:1 mapping from root). + dt_add_bin_prop(reserved, "ranges", NULL, 0); + + return reserved; +} diff --git a/src/lib/list.c b/src/lib/list.c new file mode 100644 index 0000000..ea7eff4 --- /dev/null +++ b/src/lib/list.c @@ -0,0 +1,44 @@ +/* + * Copyright 2012 Google Inc. + * + * See file CREDITS for list of people who contributed to this + * project. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but without any warranty; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include "base/list.h" + +void list_remove(ListNode *node) +{ + if (node->prev) + node->prev->next = node->next; + if (node->next) + node->next->prev = node->prev; +} + +void list_insert_after(ListNode *node, ListNode *after) +{ + node->next = after->next; + node->prev = after; + after->next = node; + if (node->next) + node->next->prev = node; +} + +void list_insert_before(ListNode *node, ListNode *before) +{ + node->prev = before->prev; + node->next = before; + before->prev = node; + if (node->prev) + node->prev->next = node; +} -- To view, visit https://review.coreboot.org/25632 To unsubscribe, or for help writing mail filters, visit https://review.coreboot.org/settings Gerrit-Project: coreboot Gerrit-Branch: master Gerrit-MessageType: newchange Gerrit-Change-Id: Ida75d4786eae38d84bfc71bf53573dafca8eda40 Gerrit-Change-Number: 25632 Gerrit-PatchSet: 1 Gerrit-Owner: Patrick Rudolph <patrick.rudolph(a)9elements.com>

1 0

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

coreboot-gerrit April 2018