arch/powerpc/boot/dtc-src/livetree.c

   1 /*
   2  * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
   3  *
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *  General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  18  *                                                                   USA
  19  */
  20
  21 #include "dtc.h"
  22
  23 /*
  24  * Tree building functions
  25  */
  26
  27 struct property *build_property(char *name, struct data val, char *label)
  28 {
  29         struct property *new = xmalloc(sizeof(*new));
  30
  31         new->name = name;
  32         new->val = val;
  33
  34         new->next = NULL;
  35
  36         new->label = label;
  37
  38         return new;
  39 }
  40
  41 struct property *chain_property(struct property *first, struct property *list)
  42 {
  43         assert(first->next == NULL);
  44
  45         first->next = list;
  46         return first;
  47 }
  48
  49 struct property *reverse_properties(struct property *first)
  50 {
  51         struct property *p = first;
  52         struct property *head = NULL;
  53         struct property *next;
  54
  55         while (p) {
  56                 next = p->next;
  57                 p->next = head;
  58                 head = p;
  59                 p = next;
  60         }
  61         return head;
  62 }
  63
  64 struct node *build_node(struct property *proplist, struct node *children)
  65 {
  66         struct node *new = xmalloc(sizeof(*new));
  67         struct node *child;
  68
  69         memset(new, 0, sizeof(*new));
  70
  71         new->proplist = reverse_properties(proplist);
  72         new->children = children;
  73
  74         for_each_child(new, child) {
  75                 child->parent = new;
  76         }
  77
  78         return new;
  79 }
  80
  81 struct node *name_node(struct node *node, char *name, char * label)
  82 {
  83         assert(node->name == NULL);
  84
  85         node->name = name;
  86
  87         node->label = label;
  88
  89         return node;
  90 }
  91
  92 struct node *chain_node(struct node *first, struct node *list)
  93 {
  94         assert(first->next_sibling == NULL);
  95
  96         first->next_sibling = list;
  97         return first;
  98 }
  99
 100 void add_property(struct node *node, struct property *prop)
 101 {
 102         struct property **p;
 103
 104         prop->next = NULL;
 105
 106         p = &node->proplist;
 107         while (*p)
 108                 p = &((*p)->next);
 109
 110         *p = prop;
 111 }
 112
 113 void add_child(struct node *parent, struct node *child)
 114 {
 115         struct node **p;
 116
 117         child->next_sibling = NULL;
 118         child->parent = parent;
 119
 120         p = &parent->children;
 121         while (*p)
 122                 p = &((*p)->next_sibling);
 123
 124         *p = child;
 125 }
 126
 127 struct reserve_info *build_reserve_entry(uint64_t address, uint64_t size,
 128                                          char *label)
 129 {
 130         struct reserve_info *new = xmalloc(sizeof(*new));
 131
 132         new->re.address = address;
 133         new->re.size = size;
 134
 135         new->next = NULL;
 136
 137         new->label = label;
 138
 139         return new;
 140 }
 141
 142 struct reserve_info *chain_reserve_entry(struct reserve_info *first,
 143                                         struct reserve_info *list)
 144 {
 145         assert(first->next == NULL);
 146
 147         first->next = list;
 148         return first;
 149 }
 150
 151 struct reserve_info *add_reserve_entry(struct reserve_info *list,
 152                                       struct reserve_info *new)
 153 {
 154         struct reserve_info *last;
 155
 156         new->next = NULL;
 157
 158         if (! list)
 159                 return new;
 160
 161         for (last = list; last->next; last = last->next)
 162                 ;
 163
 164         last->next = new;
 165
 166         return list;
 167 }
 168
 169 struct boot_info *build_boot_info(struct reserve_info *reservelist,
 170                                   struct node *tree, uint32_t boot_cpuid_phys)
 171 {
 172         struct boot_info *bi;
 173
 174         bi = xmalloc(sizeof(*bi));
 175         bi->reservelist = reservelist;
 176         bi->dt = tree;
 177         bi->boot_cpuid_phys = boot_cpuid_phys;
 178
 179         return bi;
 180 }
 181
 182 /*
 183  * Tree accessor functions
 184  */
 185
 186 const char *get_unitname(struct node *node)
 187 {
 188         if (node->name[node->basenamelen] == '\0')
 189                 return "";
 190         else
 191                 return node->name + node->basenamelen + 1;
 192 }
 193
 194 struct property *get_property(struct node *node, const char *propname)
 195 {
 196         struct property *prop;
 197
 198         for_each_property(node, prop)
 199                 if (streq(prop->name, propname))
 200                         return prop;
 201
 202         return NULL;
 203 }
 204
 205 cell_t propval_cell(struct property *prop)
 206 {
 207         assert(prop->val.len == sizeof(cell_t));
 208         return fdt32_to_cpu(*((cell_t *)prop->val.val));
 209 }
 210
 211 struct node *get_subnode(struct node *node, const char *nodename)
 212 {
 213         struct node *child;
 214
 215         for_each_child(node, child)
 216                 if (streq(child->name, nodename))
 217                         return child;
 218
 219         return NULL;
 220 }
 221
 222 struct node *get_node_by_path(struct node *tree, const char *path)
 223 {
 224         const char *p;
 225         struct node *child;
 226
 227         if (!path || ! (*path))
 228                 return tree;
 229
 230         while (path[0] == '/')
 231                 path++;
 232
 233         p = strchr(path, '/');
 234
 235         for_each_child(tree, child) {
 236                 if (p && strneq(path, child->name, p-path))
 237                         return get_node_by_path(child, p+1);
 238                 else if (!p && streq(path, child->name))
 239                         return child;
 240         }
 241
 242         return NULL;
 243 }
 244
 245 struct node *get_node_by_label(struct node *tree, const char *label)
 246 {
 247         struct node *child, *node;
 248
 249         assert(label && (strlen(label) > 0));
 250
 251         if (tree->label && streq(tree->label, label))
 252                 return tree;
 253
 254         for_each_child(tree, child) {
 255                 node = get_node_by_label(child, label);
 256                 if (node)
 257                         return node;
 258         }
 259
 260         return NULL;
 261 }
 262
 263 struct node *get_node_by_phandle(struct node *tree, cell_t phandle)
 264 {
 265         struct node *child, *node;
 266
 267         assert((phandle != 0) && (phandle != -1));
 268
 269         if (tree->phandle == phandle)
 270                 return tree;
 271
 272         for_each_child(tree, child) {
 273                 node = get_node_by_phandle(child, phandle);
 274                 if (node)
 275                         return node;
 276         }
 277
 278         return NULL;
 279 }
 280
 281 struct node *get_node_by_ref(struct node *tree, const char *ref)
 282 {
 283         if (ref[0] == '/')
 284                 return get_node_by_path(tree, ref);
 285         else
 286                 return get_node_by_label(tree, ref);
 287 }
 288
 289 cell_t get_node_phandle(struct node *root, struct node *node)
 290 {
 291         static cell_t phandle = 1; /* FIXME: ick, static local */
 292
 293         if ((node->phandle != 0) && (node->phandle != -1))
 294                 return node->phandle;
 295
 296         assert(! get_property(node, "linux,phandle"));
 297
 298         while (get_node_by_phandle(root, phandle))
 299                 phandle++;
 300
 301         node->phandle = phandle;
 302         add_property(node,
 303                      build_property("linux,phandle",
 304                                     data_append_cell(empty_data, phandle),
 305                                     NULL));
 306
 307         return node->phandle;
 308 }