kernel/scripts/dtc/checks.c

   1 /*
   2  * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2007.
   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 #ifdef TRACE_CHECKS
  24 #define TRACE(c, ...) \
  25         do { \
  26                 fprintf(stderr, "=== %s: ", (c)->name); \
  27                 fprintf(stderr, __VA_ARGS__); \
  28                 fprintf(stderr, "\n"); \
  29         } while (0)
  30 #else
  31 #define TRACE(c, fmt, ...)      do { } while (0)
  32 #endif
  33
  34 enum checkstatus {
  35         UNCHECKED = 0,
  36         PREREQ,
  37         PASSED,
  38         FAILED,
  39 };
  40
  41 struct check;
  42
  43 typedef void (*tree_check_fn)(struct check *c, struct node *dt);
  44 typedef void (*node_check_fn)(struct check *c, struct node *dt, struct node *node);
  45 typedef void (*prop_check_fn)(struct check *c, struct node *dt,
  46                               struct node *node, struct property *prop);
  47
  48 struct check {
  49         const char *name;
  50         tree_check_fn tree_fn;
  51         node_check_fn node_fn;
  52         prop_check_fn prop_fn;
  53         void *data;
  54         bool warn, error;
  55         enum checkstatus status;
  56         bool inprogress;
  57         int num_prereqs;
  58         struct check **prereq;
  59 };
  60
  61 #define CHECK_ENTRY(nm, tfn, nfn, pfn, d, w, e, ...)           \
  62         static struct check *nm##_prereqs[] = { __VA_ARGS__ }; \
  63         static struct check nm = { \
  64                 .name = #nm, \
  65                 .tree_fn = (tfn), \
  66                 .node_fn = (nfn), \
  67                 .prop_fn = (pfn), \
  68                 .data = (d), \
  69                 .warn = (w), \
  70                 .error = (e), \
  71                 .status = UNCHECKED, \
  72                 .num_prereqs = ARRAY_SIZE(nm##_prereqs), \
  73                 .prereq = nm##_prereqs, \
  74         };
  75 #define WARNING(nm, tfn, nfn, pfn, d, ...) \
  76         CHECK_ENTRY(nm, tfn, nfn, pfn, d, true, false, __VA_ARGS__)
  77 #define ERROR(nm, tfn, nfn, pfn, d, ...) \
  78         CHECK_ENTRY(nm, tfn, nfn, pfn, d, false, true, __VA_ARGS__)
  79 #define CHECK(nm, tfn, nfn, pfn, d, ...) \
  80         CHECK_ENTRY(nm, tfn, nfn, pfn, d, false, false, __VA_ARGS__)
  81
  82 #define TREE_WARNING(nm, d, ...) \
  83         WARNING(nm, check_##nm, NULL, NULL, d, __VA_ARGS__)
  84 #define TREE_ERROR(nm, d, ...) \
  85         ERROR(nm, check_##nm, NULL, NULL, d, __VA_ARGS__)
  86 #define TREE_CHECK(nm, d, ...) \
  87         CHECK(nm, check_##nm, NULL, NULL, d, __VA_ARGS__)
  88 #define NODE_WARNING(nm, d, ...) \
  89         WARNING(nm, NULL, check_##nm, NULL, d,  __VA_ARGS__)
  90 #define NODE_ERROR(nm, d, ...) \
  91         ERROR(nm, NULL, check_##nm, NULL, d, __VA_ARGS__)
  92 #define NODE_CHECK(nm, d, ...) \
  93         CHECK(nm, NULL, check_##nm, NULL, d, __VA_ARGS__)
  94 #define PROP_WARNING(nm, d, ...) \
  95         WARNING(nm, NULL, NULL, check_##nm, d, __VA_ARGS__)
  96 #define PROP_ERROR(nm, d, ...) \
  97         ERROR(nm, NULL, NULL, check_##nm, d, __VA_ARGS__)
  98 #define PROP_CHECK(nm, d, ...) \
  99         CHECK(nm, NULL, NULL, check_##nm, d, __VA_ARGS__)
 100
 101 #ifdef __GNUC__
 102 static inline void check_msg(struct check *c, const char *fmt, ...) __attribute__((format (printf, 2, 3)));
 103 #endif
 104 static inline void check_msg(struct check *c, const char *fmt, ...)
 105 {
 106         va_list ap;
 107         va_start(ap, fmt);
 108
 109         if ((c->warn && (quiet < 1))
 110             || (c->error && (quiet < 2))) {
 111                 fprintf(stderr, "%s (%s): ",
 112                         (c->error) ? "ERROR" : "Warning", c->name);
 113                 vfprintf(stderr, fmt, ap);
 114                 fprintf(stderr, "\n");
 115         }
 116         va_end(ap);
 117 }
 118
 119 #define FAIL(c, ...) \
 120         do { \
 121                 TRACE((c), "\t\tFAILED at %s:%d", __FILE__, __LINE__); \
 122                 (c)->status = FAILED; \
 123                 check_msg((c), __VA_ARGS__); \
 124         } while (0)
 125
 126 static void check_nodes_props(struct check *c, struct node *dt, struct node *node)
 127 {
 128         struct node *child;
 129         struct property *prop;
 130
 131         TRACE(c, "%s", node->fullpath);
 132         if (c->node_fn)
 133                 c->node_fn(c, dt, node);
 134
 135         if (c->prop_fn)
 136                 for_each_property(node, prop) {
 137                         TRACE(c, "%s\t'%s'", node->fullpath, prop->name);
 138                         c->prop_fn(c, dt, node, prop);
 139                 }
 140
 141         for_each_child(node, child)
 142                 check_nodes_props(c, dt, child);
 143 }
 144
 145 static bool run_check(struct check *c, struct node *dt)
 146 {
 147         bool error = false;
 148         int i;
 149
 150         assert(!c->inprogress);
 151
 152         if (c->status != UNCHECKED)
 153                 goto out;
 154
 155         c->inprogress = true;
 156
 157         for (i = 0; i < c->num_prereqs; i++) {
 158                 struct check *prq = c->prereq[i];
 159                 error = error || run_check(prq, dt);
 160                 if (prq->status != PASSED) {
 161                         c->status = PREREQ;
 162                         check_msg(c, "Failed prerequisite '%s'",
 163                                   c->prereq[i]->name);
 164                 }
 165         }
 166
 167         if (c->status != UNCHECKED)
 168                 goto out;
 169
 170         if (c->node_fn || c->prop_fn)
 171                 check_nodes_props(c, dt, dt);
 172
 173         if (c->tree_fn)
 174                 c->tree_fn(c, dt);
 175         if (c->status == UNCHECKED)
 176                 c->status = PASSED;
 177
 178         TRACE(c, "\tCompleted, status %d", c->status);
 179
 180 out:
 181         c->inprogress = false;
 182         if ((c->status != PASSED) && (c->error))
 183                 error = true;
 184         return error;
 185 }
 186
 187 /*
 188  * Utility check functions
 189  */
 190
 191 /* A check which always fails, for testing purposes only */
 192 static inline void check_always_fail(struct check *c, struct node *dt)
 193 {
 194         FAIL(c, "always_fail check");
 195 }
 196 TREE_CHECK(always_fail, NULL);
 197
 198 static void check_is_string(struct check *c, struct node *root,
 199                             struct node *node)
 200 {
 201         struct property *prop;
 202         char *propname = c->data;
 203
 204         prop = get_property(node, propname);
 205         if (!prop)
 206                 return; /* Not present, assumed ok */
 207
 208         if (!data_is_one_string(prop->val))
 209                 FAIL(c, "\"%s\" property in %s is not a string",
 210                      propname, node->fullpath);
 211 }
 212 #define WARNING_IF_NOT_STRING(nm, propname) \
 213         WARNING(nm, NULL, check_is_string, NULL, (propname))
 214 #define ERROR_IF_NOT_STRING(nm, propname) \
 215         ERROR(nm, NULL, check_is_string, NULL, (propname))
 216
 217 static void check_is_cell(struct check *c, struct node *root,
 218                           struct node *node)
 219 {
 220         struct property *prop;
 221         char *propname = c->data;
 222
 223         prop = get_property(node, propname);
 224         if (!prop)
 225                 return; /* Not present, assumed ok */
 226
 227         if (prop->val.len != sizeof(cell_t))
 228                 FAIL(c, "\"%s\" property in %s is not a single cell",
 229                      propname, node->fullpath);
 230 }
 231 #define WARNING_IF_NOT_CELL(nm, propname) \
 232         WARNING(nm, NULL, check_is_cell, NULL, (propname))
 233 #define ERROR_IF_NOT_CELL(nm, propname) \
 234         ERROR(nm, NULL, check_is_cell, NULL, (propname))
 235
 236 /*
 237  * Structural check functions
 238  */
 239
 240 static void check_duplicate_node_names(struct check *c, struct node *dt,
 241                                        struct node *node)
 242 {
 243         struct node *child, *child2;
 244
 245         for_each_child(node, child)
 246                 for (child2 = child->next_sibling;
 247                      child2;
 248                      child2 = child2->next_sibling)
 249                         if (streq(child->name, child2->name))
 250                                 FAIL(c, "Duplicate node name %s",
 251                                      child->fullpath);
 252 }
 253 NODE_ERROR(duplicate_node_names, NULL);
 254
 255 static void check_duplicate_property_names(struct check *c, struct node *dt,
 256                                            struct node *node)
 257 {
 258         struct property *prop, *prop2;
 259
 260         for_each_property(node, prop) {
 261                 for (prop2 = prop->next; prop2; prop2 = prop2->next) {
 262                         if (prop2->deleted)
 263                                 continue;
 264                         if (streq(prop->name, prop2->name))
 265                                 FAIL(c, "Duplicate property name %s in %s",
 266                                      prop->name, node->fullpath);
 267                 }
 268         }
 269 }
 270 NODE_ERROR(duplicate_property_names, NULL);
 271
 272 #define LOWERCASE       "abcdefghijklmnopqrstuvwxyz"
 273 #define UPPERCASE       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 274 #define DIGITS          "0123456789"
 275 #define PROPNODECHARS   LOWERCASE UPPERCASE DIGITS ",._+*#?-"
 276
 277 static void check_node_name_chars(struct check *c, struct node *dt,
 278                                   struct node *node)
 279 {
 280         int n = strspn(node->name, c->data);
 281
 282         if (n < strlen(node->name))
 283                 FAIL(c, "Bad character '%c' in node %s",
 284                      node->name[n], node->fullpath);
 285 }
 286 NODE_ERROR(node_name_chars, PROPNODECHARS "@");
 287
 288 static void check_node_name_format(struct check *c, struct node *dt,
 289                                    struct node *node)
 290 {
 291         if (strchr(get_unitname(node), '@'))
 292                 FAIL(c, "Node %s has multiple '@' characters in name",
 293                      node->fullpath);
 294 }
 295 NODE_ERROR(node_name_format, NULL, &node_name_chars);
 296
 297 static void check_property_name_chars(struct check *c, struct node *dt,
 298                                       struct node *node, struct property *prop)
 299 {
 300         int n = strspn(prop->name, c->data);
 301
 302         if (n < strlen(prop->name))
 303                 FAIL(c, "Bad character '%c' in property name \"%s\", node %s",
 304                      prop->name[n], prop->name, node->fullpath);
 305 }
 306 PROP_ERROR(property_name_chars, PROPNODECHARS);
 307
 308 #define DESCLABEL_FMT   "%s%s%s%s%s"
 309 #define DESCLABEL_ARGS(node,prop,mark)          \
 310         ((mark) ? "value of " : ""),            \
 311         ((prop) ? "'" : ""), \
 312         ((prop) ? (prop)->name : ""), \
 313         ((prop) ? "' in " : ""), (node)->fullpath
 314
 315 static void check_duplicate_label(struct check *c, struct node *dt,
 316                                   const char *label, struct node *node,
 317                                   struct property *prop, struct marker *mark)
 318 {
 319         struct node *othernode = NULL;
 320         struct property *otherprop = NULL;
 321         struct marker *othermark = NULL;
 322
 323         othernode = get_node_by_label(dt, label);
 324
 325         if (!othernode)
 326                 otherprop = get_property_by_label(dt, label, &othernode);
 327         if (!othernode)
 328                 othermark = get_marker_label(dt, label, &othernode,
 329                                                &otherprop);
 330
 331         if (!othernode)
 332                 return;
 333
 334         if ((othernode != node) || (otherprop != prop) || (othermark != mark))
 335                 FAIL(c, "Duplicate label '%s' on " DESCLABEL_FMT
 336                      " and " DESCLABEL_FMT,
 337                      label, DESCLABEL_ARGS(node, prop, mark),
 338                      DESCLABEL_ARGS(othernode, otherprop, othermark));
 339 }
 340
 341 static void check_duplicate_label_node(struct check *c, struct node *dt,
 342                                        struct node *node)
 343 {
 344         struct label *l;
 345
 346         for_each_label(node->labels, l)
 347                 check_duplicate_label(c, dt, l->label, node, NULL, NULL);
 348 }
 349 static void check_duplicate_label_prop(struct check *c, struct node *dt,
 350                                        struct node *node, struct property *prop)
 351 {
 352         struct marker *m = prop->val.markers;
 353         struct label *l;
 354
 355         for_each_label(prop->labels, l)
 356                 check_duplicate_label(c, dt, l->label, node, prop, NULL);
 357
 358         for_each_marker_of_type(m, LABEL)
 359                 check_duplicate_label(c, dt, m->ref, node, prop, m);
 360 }
 361 ERROR(duplicate_label, NULL, check_duplicate_label_node,
 362       check_duplicate_label_prop, NULL);
 363
 364 static void check_explicit_phandles(struct check *c, struct node *root,
 365                                     struct node *node, struct property *prop)
 366 {
 367         struct marker *m;
 368         struct node *other;
 369         cell_t phandle;
 370
 371         if (!streq(prop->name, "phandle")
 372             && !streq(prop->name, "linux,phandle"))
 373                 return;
 374
 375         if (prop->val.len != sizeof(cell_t)) {
 376                 FAIL(c, "%s has bad length (%d) %s property",
 377                      node->fullpath, prop->val.len, prop->name);
 378                 return;
 379         }
 380
 381         m = prop->val.markers;
 382         for_each_marker_of_type(m, REF_PHANDLE) {
 383                 assert(m->offset == 0);
 384                 if (node != get_node_by_ref(root, m->ref))
 385                         /* "Set this node's phandle equal to some
 386                          * other node's phandle".  That's nonsensical
 387                          * by construction. */ {
 388                         FAIL(c, "%s in %s is a reference to another node",
 389                              prop->name, node->fullpath);
 390                         return;
 391                 }
 392                 /* But setting this node's phandle equal to its own
 393                  * phandle is allowed - that means allocate a unique
 394                  * phandle for this node, even if it's not otherwise
 395                  * referenced.  The value will be filled in later, so
 396                  * no further checking for now. */
 397                 return;
 398         }
 399
 400         phandle = propval_cell(prop);
 401
 402         if ((phandle == 0) || (phandle == -1)) {
 403                 FAIL(c, "%s has bad value (0x%x) in %s property",
 404                      node->fullpath, phandle, prop->name);
 405                 return;
 406         }
 407
 408         if (node->phandle && (node->phandle != phandle))
 409                 FAIL(c, "%s has %s property which replaces existing phandle information",
 410                      node->fullpath, prop->name);
 411
 412         other = get_node_by_phandle(root, phandle);
 413         if (other && (other != node)) {
 414                 FAIL(c, "%s has duplicated phandle 0x%x (seen before at %s)",
 415                      node->fullpath, phandle, other->fullpath);
 416                 return;
 417         }
 418
 419         node->phandle = phandle;
 420 }
 421 PROP_ERROR(explicit_phandles, NULL);
 422
 423 static void check_name_properties(struct check *c, struct node *root,
 424                                   struct node *node)
 425 {
 426         struct property **pp, *prop = NULL;
 427
 428         for (pp = &node->proplist; *pp; pp = &((*pp)->next))
 429                 if (streq((*pp)->name, "name")) {
 430                         prop = *pp;
 431                         break;
 432                 }
 433
 434         if (!prop)
 435                 return; /* No name property, that's fine */
 436
 437         if ((prop->val.len != node->basenamelen+1)
 438             || (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) {
 439                 FAIL(c, "\"name\" property in %s is incorrect (\"%s\" instead"
 440                      " of base node name)", node->fullpath, prop->val.val);
 441         } else {
 442                 /* The name property is correct, and therefore redundant.
 443                  * Delete it */
 444                 *pp = prop->next;
 445                 free(prop->name);
 446                 data_free(prop->val);
 447                 free(prop);
 448         }
 449 }
 450 ERROR_IF_NOT_STRING(name_is_string, "name");
 451 NODE_ERROR(name_properties, NULL, &name_is_string);
 452
 453 /*
 454  * Reference fixup functions
 455  */
 456
 457 static void fixup_phandle_references(struct check *c, struct node *dt,
 458                                      struct node *node, struct property *prop)
 459 {
 460         struct marker *m = prop->val.markers;
 461         struct node *refnode;
 462         cell_t phandle;
 463
 464         for_each_marker_of_type(m, REF_PHANDLE) {
 465                 assert(m->offset + sizeof(cell_t) <= prop->val.len);
 466
 467                 refnode = get_node_by_ref(dt, m->ref);
 468                 if (! refnode) {
 469                         FAIL(c, "Reference to non-existent node or label \"%s\"\n",
 470                              m->ref);
 471                         continue;
 472                 }
 473
 474                 phandle = get_node_phandle(dt, refnode);
 475                 *((cell_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(phandle);
 476         }
 477 }
 478 ERROR(phandle_references, NULL, NULL, fixup_phandle_references, NULL,
 479       &duplicate_node_names, &explicit_phandles);
 480
 481 static void fixup_path_references(struct check *c, struct node *dt,
 482                                   struct node *node, struct property *prop)
 483 {
 484         struct marker *m = prop->val.markers;
 485         struct node *refnode;
 486         char *path;
 487
 488         for_each_marker_of_type(m, REF_PATH) {
 489                 assert(m->offset <= prop->val.len);
 490
 491                 refnode = get_node_by_ref(dt, m->ref);
 492                 if (!refnode) {
 493                         FAIL(c, "Reference to non-existent node or label \"%s\"\n",
 494                              m->ref);
 495                         continue;
 496                 }
 497
 498                 path = refnode->fullpath;
 499                 prop->val = data_insert_at_marker(prop->val, m, path,
 500                                                   strlen(path) + 1);
 501         }
 502 }
 503 ERROR(path_references, NULL, NULL, fixup_path_references, NULL,
 504       &duplicate_node_names);
 505
 506 /*
 507  * Semantic checks
 508  */
 509 WARNING_IF_NOT_CELL(address_cells_is_cell, "#address-cells");
 510 WARNING_IF_NOT_CELL(size_cells_is_cell, "#size-cells");
 511 WARNING_IF_NOT_CELL(interrupt_cells_is_cell, "#interrupt-cells");
 512
 513 WARNING_IF_NOT_STRING(device_type_is_string, "device_type");
 514 WARNING_IF_NOT_STRING(model_is_string, "model");
 515 WARNING_IF_NOT_STRING(status_is_string, "status");
 516
 517 static void fixup_addr_size_cells(struct check *c, struct node *dt,
 518                                   struct node *node)
 519 {
 520         struct property *prop;
 521
 522         node->addr_cells = -1;
 523         node->size_cells = -1;
 524
 525         prop = get_property(node, "#address-cells");
 526         if (prop)
 527                 node->addr_cells = propval_cell(prop);
 528
 529         prop = get_property(node, "#size-cells");
 530         if (prop)
 531                 node->size_cells = propval_cell(prop);
 532 }
 533 WARNING(addr_size_cells, NULL, fixup_addr_size_cells, NULL, NULL,
 534         &address_cells_is_cell, &size_cells_is_cell);
 535
 536 #define node_addr_cells(n) \
 537         (((n)->addr_cells == -1) ? 2 : (n)->addr_cells)
 538 #define node_size_cells(n) \
 539         (((n)->size_cells == -1) ? 1 : (n)->size_cells)
 540
 541 static void check_reg_format(struct check *c, struct node *dt,
 542                              struct node *node)
 543 {
 544         struct property *prop;
 545         int addr_cells, size_cells, entrylen;
 546
 547         prop = get_property(node, "reg");
 548         if (!prop)
 549                 return; /* No "reg", that's fine */
 550
 551         if (!node->parent) {
 552                 FAIL(c, "Root node has a \"reg\" property");
 553                 return;
 554         }
 555
 556         if (prop->val.len == 0)
 557                 FAIL(c, "\"reg\" property in %s is empty", node->fullpath);
 558
 559         addr_cells = node_addr_cells(node->parent);
 560         size_cells = node_size_cells(node->parent);
 561         entrylen = (addr_cells + size_cells) * sizeof(cell_t);
 562
 563         if ((prop->val.len % entrylen) != 0)
 564                 FAIL(c, "\"reg\" property in %s has invalid length (%d bytes) "
 565                      "(#address-cells == %d, #size-cells == %d)",
 566                      node->fullpath, prop->val.len, addr_cells, size_cells);
 567 }
 568 NODE_WARNING(reg_format, NULL, &addr_size_cells);
 569
 570 static void check_ranges_format(struct check *c, struct node *dt,
 571                                 struct node *node)
 572 {
 573         struct property *prop;
 574         int c_addr_cells, p_addr_cells, c_size_cells, p_size_cells, entrylen;
 575
 576         prop = get_property(node, "ranges");
 577         if (!prop)
 578                 return;
 579
 580         if (!node->parent) {
 581                 FAIL(c, "Root node has a \"ranges\" property");
 582                 return;
 583         }
 584
 585         p_addr_cells = node_addr_cells(node->parent);
 586         p_size_cells = node_size_cells(node->parent);
 587         c_addr_cells = node_addr_cells(node);
 588         c_size_cells = node_size_cells(node);
 589         entrylen = (p_addr_cells + c_addr_cells + c_size_cells) * sizeof(cell_t);
 590
 591         if (prop->val.len == 0) {
 592                 if (p_addr_cells != c_addr_cells)
 593                         FAIL(c, "%s has empty \"ranges\" property but its "
 594                              "#address-cells (%d) differs from %s (%d)",
 595                              node->fullpath, c_addr_cells, node->parent->fullpath,
 596                              p_addr_cells);
 597                 if (p_size_cells != c_size_cells)
 598                         FAIL(c, "%s has empty \"ranges\" property but its "
 599                              "#size-cells (%d) differs from %s (%d)",
 600                              node->fullpath, c_size_cells, node->parent->fullpath,
 601                              p_size_cells);
 602         } else if ((prop->val.len % entrylen) != 0) {
 603                 FAIL(c, "\"ranges\" property in %s has invalid length (%d bytes) "
 604                      "(parent #address-cells == %d, child #address-cells == %d, "
 605                      "#size-cells == %d)", node->fullpath, prop->val.len,
 606                      p_addr_cells, c_addr_cells, c_size_cells);
 607         }
 608 }
 609 NODE_WARNING(ranges_format, NULL, &addr_size_cells);
 610
 611 /*
 612  * Style checks
 613  */
 614 static void check_avoid_default_addr_size(struct check *c, struct node *dt,
 615                                           struct node *node)
 616 {
 617         struct property *reg, *ranges;
 618
 619         if (!node->parent)
 620                 return; /* Ignore root node */
 621
 622         reg = get_property(node, "reg");
 623         ranges = get_property(node, "ranges");
 624
 625         if (!reg && !ranges)
 626                 return;
 627
 628         if (node->parent->addr_cells == -1)
 629                 FAIL(c, "Relying on default #address-cells value for %s",
 630                      node->fullpath);
 631
 632         if (node->parent->size_cells == -1)
 633                 FAIL(c, "Relying on default #size-cells value for %s",
 634                      node->fullpath);
 635 }
 636 NODE_WARNING(avoid_default_addr_size, NULL, &addr_size_cells);
 637
 638 static void check_obsolete_chosen_interrupt_controller(struct check *c,
 639                                                        struct node *dt)
 640 {
 641         struct node *chosen;
 642         struct property *prop;
 643
 644         chosen = get_node_by_path(dt, "/chosen");
 645         if (!chosen)
 646                 return;
 647
 648         prop = get_property(chosen, "interrupt-controller");
 649         if (prop)
 650                 FAIL(c, "/chosen has obsolete \"interrupt-controller\" "
 651                      "property");
 652 }
 653 TREE_WARNING(obsolete_chosen_interrupt_controller, NULL);
 654
 655 static struct check *check_table[] = {
 656         &duplicate_node_names, &duplicate_property_names,
 657         &node_name_chars, &node_name_format, &property_name_chars,
 658         &name_is_string, &name_properties,
 659
 660         &duplicate_label,
 661
 662         &explicit_phandles,
 663         &phandle_references, &path_references,
 664
 665         &address_cells_is_cell, &size_cells_is_cell, &interrupt_cells_is_cell,
 666         &device_type_is_string, &model_is_string, &status_is_string,
 667
 668         &addr_size_cells, &reg_format, &ranges_format,
 669
 670         &avoid_default_addr_size,
 671         &obsolete_chosen_interrupt_controller,
 672
 673         &always_fail,
 674 };
 675
 676 static void enable_warning_error(struct check *c, bool warn, bool error)
 677 {
 678         int i;
 679
 680         /* Raising level, also raise it for prereqs */
 681         if ((warn && !c->warn) || (error && !c->error))
 682                 for (i = 0; i < c->num_prereqs; i++)
 683                         enable_warning_error(c->prereq[i], warn, error);
 684
 685         c->warn = c->warn || warn;
 686         c->error = c->error || error;
 687 }
 688
 689 static void disable_warning_error(struct check *c, bool warn, bool error)
 690 {
 691         int i;
 692
 693         /* Lowering level, also lower it for things this is the prereq
 694          * for */
 695         if ((warn && c->warn) || (error && c->error)) {
 696                 for (i = 0; i < ARRAY_SIZE(check_table); i++) {
 697                         struct check *cc = check_table[i];
 698                         int j;
 699
 700                         for (j = 0; j < cc->num_prereqs; j++)
 701                                 if (cc->prereq[j] == c)
 702                                         disable_warning_error(cc, warn, error);
 703                 }
 704         }
 705
 706         c->warn = c->warn && !warn;
 707         c->error = c->error && !error;
 708 }
 709
 710 void parse_checks_option(bool warn, bool error, const char *arg)
 711 {
 712         int i;
 713         const char *name = arg;
 714         bool enable = true;
 715
 716         if ((strncmp(arg, "no-", 3) == 0)
 717             || (strncmp(arg, "no_", 3) == 0)) {
 718                 name = arg + 3;
 719                 enable = false;
 720         }
 721
 722         for (i = 0; i < ARRAY_SIZE(check_table); i++) {
 723                 struct check *c = check_table[i];
 724
 725                 if (streq(c->name, name)) {
 726                         if (enable)
 727                                 enable_warning_error(c, warn, error);
 728                         else
 729                                 disable_warning_error(c, warn, error);
 730                         return;
 731                 }
 732         }
 733
 734         die("Unrecognized check name \"%s\"\n", name);
 735 }
 736
 737 void process_checks(bool force, struct boot_info *bi)
 738 {
 739         struct node *dt = bi->dt;
 740         int i;
 741         int error = 0;
 742
 743         for (i = 0; i < ARRAY_SIZE(check_table); i++) {
 744                 struct check *c = check_table[i];
 745
 746                 if (c->warn || c->error)
 747                         error = error || run_check(c, dt);
 748         }
 749
 750         if (error) {
 751                 if (!force) {
 752                         fprintf(stderr, "ERROR: Input tree has errors, aborting "
 753                                 "(use -f to force output)\n");
 754                         exit(2);
 755                 } else if (quiet < 3) {
 756                         fprintf(stderr, "Warning: Input tree has errors, "
 757                                 "output forced\n");
 758                 }
 759         }
 760 }