diff options
Diffstat (limited to 'util/sconfig')
| -rw-r--r-- | util/sconfig/main.c | 398 | ||||
| -rw-r--r-- | util/sconfig/sconfig.h | 6 |
2 files changed, 394 insertions, 10 deletions
diff --git a/util/sconfig/main.c b/util/sconfig/main.c index 06e991e9fd..365edc41a6 100644 --- a/util/sconfig/main.c +++ b/util/sconfig/main.c @@ -20,7 +20,11 @@ extern int linenum; -/* Maintains list of all the unique chip structures for the board. */ +/* + * Maintains list of all the unique chip structures for the board. + * This is shared across base and override device trees since we need to + * generate headers for all chips added by both the trees. + */ static struct chip chip_header; /* @@ -131,6 +135,7 @@ static struct chip mainboard_chip = { static struct chip_instance mainboard_instance = { .id = 0, .chip = &mainboard_chip, + .ref_count = 2, }; /* This is the parent of all devices added by parsing the devicetree file. */ @@ -340,6 +345,54 @@ struct chip_instance *new_chip_instance(char *path) return instance; } +static void delete_chip_instance(struct chip_instance *ins) +{ + + if (ins->ref_count == 0) { + printf("ERROR: ref count for chip instance is zero!!\n"); + exit(1); + } + + if (--ins->ref_count) + return; + + struct chip *c = ins->chip; + + /* Get pointer to first instance of the chip. */ + struct chip_instance *i = c->instance; + + /* + * If chip instance to be deleted is the first instance, then update + * instance pointer of the chip as well. + */ + if (i == ins) { + c->instance = ins->next; + free(ins); + return; + } + + /* + * Loop through the instances list of the chip to find and remove the + * given instance. + */ + while (1) { + if (i == NULL) { + printf("ERROR: chip instance not found!\n"); + exit(1); + } + + if (i->next != ins) { + i = i->next; + continue; + } + + i->next = ins->next; + break; + } + + free(ins); +} + /* * Allocate a new bus for the provided device. * - If this is the first bus being allocated under this device, then its id @@ -408,6 +461,24 @@ static struct device *get_dev(struct bus *parent, int path_a, int path_b, return NULL; } +/* + * Add given node as child of the provided parent. If this is the first child of + * the parent, update parent->children pointer as well. + */ +static void set_new_child(struct bus *parent, struct device *child) +{ + struct device *c = parent->children; + if (c) { + while (c->sibling) + c = c->sibling; + c->sibling = child; + } else + parent->children = child; + + child->sibling = NULL; + child->parent = parent; +} + struct device *new_device(struct bus *parent, struct chip_instance *chip_instance, const int bustype, const char *devnum, @@ -444,14 +515,9 @@ struct device *new_device(struct bus *parent, new_d->enabled = enabled; new_d->chip_instance = chip_instance; + chip_instance->ref_count++; - struct device *c = parent->children; - if (c) { - while (c->sibling) - c = c->sibling; - c->sibling = new_d; - } else - parent->children = new_d; + set_new_child(parent, new_d); switch (bustype) { case PCI: @@ -506,9 +572,8 @@ struct device *new_device(struct bus *parent, return new_d; } -void add_resource(struct bus *bus, int type, int index, int base) +static void new_resource(struct device *dev, int type, int index, int base) { - struct device *dev = bus->dev; struct resource *r = S_ALLOC(sizeof(struct resource)); r->type = type; @@ -524,6 +589,11 @@ void add_resource(struct bus *bus, int type, int index, int base) } } +void add_resource(struct bus *bus, int type, int index, int base) +{ + new_resource(bus->dev, type, index, base); +} + void add_register(struct chip_instance *chip_instance, char *name, char *val) { struct reg *r = S_ALLOC(sizeof(struct reg)); @@ -917,6 +987,312 @@ static void parse_devicetree(const char *file, struct bus *parent) fclose(filec); } +/* + * Match device nodes from base and override tree to see if they are the same + * node. + */ +static int device_match(struct device *a, struct device *b) +{ + return ((a->path_a == b->path_a) && + (a->path_b == b->path_b) && + (a->bustype == b->bustype) && + (a->chip_instance->chip == + b->chip_instance->chip)); +} + +/* + * Walk through the override subtree in breadth-first manner starting at node to + * see if chip_instance pointer of the node is same as chip_instance pointer of + * override parent that is passed into the function. If yes, then update the + * chip_instance pointer of the node to chip_instance pointer of the base + * parent. + */ +static void update_chip_pointers(struct device *node, + struct chip_instance *base_parent_ci, + struct chip_instance *override_parent_ci) +{ + struct queue_entry *q_head = NULL; + + enqueue_tail(&q_head, node); + + while ((node = dequeue_head(&q_head))) { + if (node->chip_instance != override_parent_ci) + continue; + node->chip_instance = base_parent_ci; + add_children_to_queue(&q_head, node); + } +} + +/* + * Add resource to device. If resource is already present, then update its base + * and index. If not, then add a new resource to the device. + */ +static void update_resource(struct device *dev, struct resource *res) +{ + struct resource *base_res = dev->res; + + while (base_res) { + if (base_res->type == res->type) { + base_res->index = res->index; + base_res->base = res->base; + return; + } + base_res = base_res->next; + } + + new_resource(dev, res->type, res->index, res->base); +} + +/* + * Add register to chip instance. If register is already present, then update + * its value. If not, then add a new register to the chip instance. + */ +static void update_register(struct chip_instance *c, struct reg *reg) +{ + struct reg *base_reg = c->reg; + + while (base_reg) { + if (!strcmp(base_reg->key, reg->key)) { + base_reg->value = reg->value; + return; + } + base_reg = base_reg->next; + } + + add_register(c, reg->key, reg->value); +} + +static void override_devicetree(struct bus *base_parent, + struct bus *override_parent); + +/* + * Update the base device properties using the properties of override device. In + * addition to that, call override_devicetree for all the buses under the + * override device. + * + * Override Rules: + * +--------------------+--------------------------------------------+ + * | | | + * |struct device member| Rule | + * | | | + * +-----------------------------------------------------------------+ + * | | | + * | id | Unchanged. This is used to generate device | + * | | structure name in static.c. So, no need to | + * | | override. | + * | | | + * +-----------------------------------------------------------------+ + * | | | + * | enabled | Copy enabled state from override device. | + * | | This allows variants to override device | + * | | state. | + * | | | + * +-----------------------------------------------------------------+ + * | | | + * | subsystem_vendor | Copy from override device only if any one | + * | subsystem_device | of the ids is non-zero. | + * | | | + * +-----------------------------------------------------------------+ + * | | | + * | inherit_subsystem | Copy from override device only if it is | + * | | non-zero. This allows variant to only | + * | | enable inherit flag for a device. | + * | | | + * +-----------------------------------------------------------------+ + * | | | + * | path | Unchanged since these are same for both | + * | path_a | base and override device (Used for | + * | path_b | matching devices). | + * | | | + * +-----------------------------------------------------------------+ + * | | | + * | bustype | Unchanged since this is same for both base | + * | | and override device (User for matching | + * | | devices). | + * | | | + * +-----------------------------------------------------------------+ + * | | | + * | pci_irq_info | Unchanged. | + * | | | + * +-----------------------------------------------------------------+ + * | | | + * | parent | Unchanged. This is meaningful only within | + * | sibling | the parse tree, hence not being copied. | + * | | | + * +-----------------------------------------------------------------+ + * | | | + * | res | Each resource that is present in override | + * | | device is copied over to base device: | + * | | 1. If resource of same type is present in | + * | | base device, then index and base of the | + * | | resource is copied. | + * | | 2. If not, then a new resource is allocated| + * | | under the base device using type, index | + * | | and base from override res. | + * | | | + * +-----------------------------------------------------------------+ + * | | | + * | chip_instance | Each register of chip_instance is copied | + * | | over from override device to base device: | + * | | 1. If register with same key is present in | + * | | base device, then value of the register | + * | | is copied. | + * | | 2. If not, then a new register is allocated| + * | | under the base chip_instance using key | + * | | and value from override register. | + * | | | + * +-----------------------------------------------------------------+ + * | | | + * | bus | Recursively call override_devicetree on | + * | last_bus | each bus of override device. It is assumed | + * | | that bus with id X under base device | + * | | to bus with id X under override device. If | + * | | override device has more buses than base | + * | | device, then new buses are allocated under | + * | | base device. | + * | | | + * +-----------------------------------------------------------------+ + */ +static void update_device(struct device *base_dev, struct device *override_dev) +{ + /* + * Copy the enabled state of override device to base device. This allows + * override tree to enable or disable a particular device. + */ + base_dev->enabled = override_dev->enabled; + + /* + * Copy subsystem vendor and device ids from override device to base + * device only if the ids are non-zero in override device. Else, honor + * the values in base device. + */ + if (override_dev->subsystem_vendor || + override_dev->subsystem_device) { + base_dev->subsystem_vendor = override_dev->subsystem_vendor; + base_dev->subsystem_device = override_dev->subsystem_device; + } + + /* + * Copy value of inherity_subsystem from override device to base device + * only if it is non-zero in override device. This allows override + * tree to only enable inhert flag for a device. + */ + if (override_dev->inherit_subsystem) + base_dev->inherit_subsystem = override_dev->inherit_subsystem; + + /* + * Copy resources of override device to base device. + * 1. If resource is already present in base device, then index and base + * of the resource will be copied over. + * 2. If resource is not already present in base device, a new resource + * will be allocated. + */ + struct resource *res = override_dev->res; + while (res) { + update_resource(base_dev, res); + res = res->next; + } + + /* + * Copy registers of override chip instance to base chip instance. + * 1. If register key is already present in base chip instance, then + * value for the register is copied over. + * 2. If register key is not already present in base chip instance, then + * a new register will be allocated. + */ + struct reg *reg = override_dev->chip_instance->reg; + while (reg) { + update_register(base_dev->chip_instance, reg); + reg = reg->next; + } + + /* + * Now that the device properties are all copied over, look at each bus + * of the override device and run override_devicetree in a recursive + * manner. The assumption here is that first bus of override device + * corresponds to first bus of base device and so on. If base device has + * lesser buses than override tree, then new buses are allocated for it. + */ + struct bus *override_bus = override_dev->bus; + struct bus *base_bus = base_dev->bus; + + while (override_bus) { + + /* + * If we have more buses in override tree device, then allocate + * a new bus for the base tree device as well. + */ + if (!base_bus) { + alloc_bus(base_dev); + base_bus = base_dev->last_bus; + } + + override_devicetree(base_dev->bus, override_dev->bus); + + override_bus = override_bus->next_bus; + base_bus = base_bus->next_bus; + } + + delete_chip_instance(override_dev->chip_instance); + override_dev->chip_instance = NULL; +} + +/* + * Perform copy of device and properties from override parent to base parent. + * This function walks through the override tree in a depth-first manner + * performing following actions: + * 1. If matching device is found in base tree, then copy the properties of + * override device to base tree device. Call override_devicetree recursively on + * the bus of override device. + * 2. If matching device is not found in base tree, then set override tree + * device as new child of base_parent and update the chip pointers in override + * device subtree to ensure the nodes do not point to override tree chip + * instance. + */ +static void override_devicetree(struct bus *base_parent, + struct bus *override_parent) +{ + struct device *base_child; + struct device *override_child = override_parent->children; + struct device *next_child; + + while (override_child) { + + /* Look for a matching device in base tree. */ + for (base_child = base_parent->children; + base_child; base_child = base_child->sibling) { + if (device_match(base_child, override_child)) + break; + } + + next_child = override_child->sibling; + + /* + * If matching device is found, copy properties of + * override_child to base_child. + */ + if (base_child) + update_device(base_child, override_child); + else { + /* + * If matching device is not found, set override_child + * as a new child of base_parent. + */ + set_new_child(base_parent, override_child); + /* + * Ensure all nodes in override tree pointing to + * override parent chip_instance now point to base + * parent chip_instance. + */ + update_chip_pointers(override_child, + base_parent->dev->chip_instance, + override_parent->dev->chip_instance); + } + + override_child = next_child; + } +} + int main(int argc, char **argv) { if ((argc < MANDATORY_ARG_COUNT) || (argc > TOTAL_ARG_COUNT)) @@ -931,6 +1307,8 @@ int main(int argc, char **argv) if (argc == TOTAL_ARG_COUNT) { override_devtree = argv[OVERRIDE_DEVICEFILE_ARG]; parse_devicetree(override_devtree, &override_root_bus); + + override_devicetree(&base_root_bus, &override_root_bus); } FILE *autogen = fopen(outputc, "w"); diff --git a/util/sconfig/sconfig.h b/util/sconfig/sconfig.h index 63b65fd372..d350f52569 100644 --- a/util/sconfig/sconfig.h +++ b/util/sconfig/sconfig.h @@ -58,6 +58,12 @@ struct chip_instance { /* Pointer to next instance of the same chip. */ struct chip_instance *next; + + /* + * Reference count - Indicates how many devices hold pointer to this + * chip instance. + */ + int ref_count; }; struct chip { |