Lines Matching refs:prop
63 struct property *prop,
74 if (prop && prop->srcpos)
75 pos = prop->srcpos;
93 if (prop)
94 xasprintf_append(&str, "%s:%s: ", node->fullpath, prop->name);
105 if (!prop && pos) {
126 #define FAIL_PROP(c, dti, node, prop, ...) \
130 check_msg((c), dti, node, prop, __VA_ARGS__); \
201 struct property *prop;
204 prop = get_property(node, propname);
205 if (!prop)
208 if (!data_is_one_string(prop->val))
209 FAIL_PROP(c, dti, node, prop, "property is not a string");
220 struct property *prop;
224 prop = get_property(node, propname);
225 if (!prop)
228 str = prop->val.val;
229 rem = prop->val.len;
233 FAIL_PROP(c, dti, node, prop, "property is not a string list");
248 struct property *prop;
251 prop = get_property(node, propname);
252 if (!prop)
255 if (prop->val.len != sizeof(cell_t))
256 FAIL_PROP(c, dti, node, prop, "property is not a single cell");
284 struct property *prop, *prop2;
286 for_each_property(node, prop) {
287 for (prop2 = prop->next; prop2; prop2 = prop2->next) {
290 if (streq(prop->name, prop2->name))
291 FAIL_PROP(c, dti, node, prop, "Duplicate property name");
337 struct property *prop = get_property(node, "reg");
344 if (!prop) {
345 prop = get_property(node, "ranges");
346 if (prop && !prop->val.len)
347 prop = NULL;
350 if (prop) {
363 struct property *prop;
365 for_each_property(node, prop) {
366 int n = strspn(prop->name, c->data);
368 if (n < strlen(prop->name))
369 FAIL_PROP(c, dti, node, prop, "Bad character '%c' in property name",
370 prop->name[n]);
379 struct property *prop;
381 for_each_property(node, prop) {
382 const char *name = prop->name;
385 if (n == strlen(prop->name))
401 FAIL_PROP(c, dti, node, prop, "Character '%c' not recommended in property name",
408 #define DESCLABEL_ARGS(node,prop,mark) \
410 ((prop) ? "'" : ""), \
411 ((prop) ? (prop)->name : ""), \
412 ((prop) ? "' in " : ""), (node)->fullpath
416 struct property *prop, struct marker *mark)
434 if ((othernode != node) || (otherprop != prop) || (othermark != mark))
437 label, DESCLABEL_ARGS(node, prop, mark),
445 struct property *prop;
450 for_each_property(node, prop) {
451 struct marker *m = prop->val.markers;
453 for_each_label(prop->labels, l)
454 check_duplicate_label(c, dti, l->label, node, prop, NULL);
457 check_duplicate_label(c, dti, m->ref, node, prop, m);
466 struct property *prop;
470 prop = get_property(node, propname);
471 if (!prop)
474 if (prop->val.len != sizeof(cell_t)) {
475 FAIL_PROP(c, dti, node, prop, "bad length (%d) %s property",
476 prop->val.len, prop->name);
480 m = prop->val.markers;
488 prop->name);
498 phandle = propval_cell(prop);
501 FAIL_PROP(c, dti, node, prop, "bad value (0x%x) in %s property",
502 phandle, prop->name);
548 struct property **pp, *prop = NULL;
552 prop = *pp;
556 if (!prop)
559 if ((prop->val.len != node->basenamelen+1)
560 || (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) {
562 " of base node name)", prop->val.val);
566 *pp = prop->next;
567 free(prop->name);
568 data_free(prop->val);
569 free(prop);
583 struct property *prop;
585 for_each_property(node, prop) {
586 struct marker *m = prop->val.markers;
591 assert(m->offset + sizeof(cell_t) <= prop->val.len);
599 *((fdt32_t *)(prop->val.val + m->offset)) =
605 *((fdt32_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(phandle);
618 struct property *prop;
620 for_each_property(node, prop) {
621 struct marker *m = prop->val.markers;
626 assert(m->offset <= prop->val.len);
636 prop->val = data_insert_at_marker(prop->val, m, path,
672 struct property *prop;
674 for_each_property(node, prop) {
675 const char *s = strrchr(prop->name, '-');
679 c->data = prop->name;
688 struct property *prop;
693 for_each_property(node, prop) {
694 if (streq(prop->name, "phandle")
695 || streq(prop->name, "linux,phandle")) {
699 if (!prop->val.val || !get_node_by_path(dti->dt, prop->val.val)) {
700 FAIL_PROP(c, dti, node, prop, "aliases property is not a valid node (%s)",
701 prop->val.val);
704 if (strspn(prop->name, LOWERCASE DIGITS "-") != strlen(prop->name))
713 struct property *prop;
718 prop = get_property(node, "#address-cells");
719 if (prop)
720 node->addr_cells = propval_cell(prop);
722 prop = get_property(node, "#size-cells");
723 if (prop)
724 node->size_cells = propval_cell(prop);
737 struct property *prop;
740 prop = get_property(node, "reg");
741 if (!prop)
749 if (prop->val.len == 0)
750 FAIL_PROP(c, dti, node, prop, "property is empty");
756 if (!entrylen || (prop->val.len % entrylen) != 0)
757 FAIL_PROP(c, dti, node, prop, "property has invalid length (%d bytes) "
759 prop->val.len, addr_cells, size_cells);
766 struct property *prop;
770 prop = get_property(node, ranges);
771 if (!prop)
775 FAIL_PROP(c, dti, node, prop, "Root node has a \"%s\" property",
786 if (prop->val.len == 0) {
788 FAIL_PROP(c, dti, node, prop, "empty \"%s\" property but its "
793 FAIL_PROP(c, dti, node, prop, "empty \"%s\" property but its "
797 } else if ((prop->val.len % entrylen) != 0) {
798 FAIL_PROP(c, dti, node, prop, "\"%s\" property has invalid length (%d bytes) "
800 "#size-cells == %d)", ranges, prop->val.len,
813 struct property *prop;
816 prop = get_property(node, "device_type");
817 if (!prop || !streq(prop->val.val, "pci"))
826 prop = get_property(node, "ranges");
827 if (!prop)
835 prop = get_property(node, "bus-range");
836 if (!prop)
839 if (prop->val.len != (sizeof(cell_t) * 2)) {
840 FAIL_PROP(c, dti, node, prop, "value must be 2 cells");
843 cells = (cell_t *)prop->val.val;
845 FAIL_PROP(c, dti, node, prop, "1st cell must be less than or equal to 2nd cell");
847 FAIL_PROP(c, dti, node, prop, "maximum bus number must be less than 256");
854 struct property *prop;
861 prop = get_property(node, "reg");
862 if (!prop)
865 cells = (cell_t *)prop->val.val;
868 prop = get_property(node->parent, "bus-range");
869 if (!prop) {
872 cells = (cell_t *)prop->val.val;
877 FAIL_PROP(c, dti, node, prop, "PCI bus number %d out of range, expected (%d - %d)",
884 struct property *prop;
893 prop = get_property(node, "reg");
894 if (!prop)
897 cells = (cell_t *)prop->val.val;
899 FAIL_PROP(c, dti, node, prop, "PCI reg config space address cells 2 and 3 must be 0");
906 FAIL_PROP(c, dti, node, prop, "PCI reg address is not configuration space");
908 FAIL_PROP(c, dti, node, prop, "PCI reg config space address register number must be 0");
931 struct property *prop;
934 prop = get_property(node, "compatible");
935 if (!prop)
938 for (str = prop->val.val, end = str + prop->val.len; str < end;
956 struct property *prop;
966 prop = get_property(node, "reg");
967 if (prop)
968 cells = (cell_t *)prop->val.val;
970 prop = get_property(node, "ranges");
971 if (prop && prop->val.len)
973 cells = ((cell_t *)prop->val.val) + node_addr_cells(node);
1028 struct property *prop;
1038 prop = get_property(node, "reg");
1039 if (prop)
1040 cells = (cell_t *)prop->val.val;
1055 for (len = prop->val.len; len > 0; len -= 4) {
1061 FAIL_PROP(c, dti, node, prop, "I2C address must be less than 10-bits, got \"0x%x\"",
1064 FAIL_PROP(c, dti, node, prop, "I2C address must be less than 7-bits, got \"0x%x\". Set I2C_TEN_BIT_ADDRESS for 10 bit addresses or fix the property",
1088 struct property *prop;
1089 for_each_property(child, prop) {
1090 if (strprefixeq(prop->name, 4, "spi-")) {
1117 struct property *prop;
1129 prop = get_property(node, "reg");
1130 if (prop)
1131 cells = (cell_t *)prop->val.val;
1197 struct property *prop;
1208 prop = get_property(child, "reg");
1209 if (prop)
1220 struct property *prop;
1222 prop = get_property(node, "status");
1223 if (prop) {
1224 char *str = prop->val.val;
1290 struct property *prop;
1300 prop = get_property(chosen, "interrupt-controller");
1301 if (prop)
1302 FAIL_PROP(c, dti, node, prop,
1322 struct property *prop;
1327 prop = get_property(node, "bootargs");
1328 if (!prop)
1331 c->data = prop->name;
1339 struct property *prop;
1344 prop = get_property(node, "stdout-path");
1345 if (!prop) {
1346 prop = get_property(node, "linux,stdout-path");
1347 if (!prop)
1349 FAIL_PROP(c, dti, node, prop, "Use 'stdout-path' instead");
1352 c->data = prop->name;
1366 struct property *prop,
1372 if (prop->val.len % sizeof(cell_t)) {
1373 FAIL_PROP(c, dti, node, prop,
1375 prop->val.len, sizeof(cell_t));
1379 for (cell = 0; cell < prop->val.len / sizeof(cell_t); cell += cellsize + 1) {
1384 phandle = propval_cell_n(prop, cell);
1399 if (prop->val.markers) {
1400 struct marker *m = prop->val.markers;
1406 FAIL_PROP(c, dti, node, prop,
1413 FAIL_PROP(c, dti, node, prop,
1428 prop->name, cell);
1432 if (prop->val.len < ((cell + cellsize + 1) * sizeof(cell_t))) {
1433 FAIL_PROP(c, dti, node, prop,
1435 prop->val.len, cellsize);
1445 struct property *prop;
1447 prop = get_property(node, provider->prop_name);
1448 if (!prop)
1451 check_property_phandle_args(c, dti, node, prop, provider);
1474 static bool prop_is_gpio(struct property *prop)
1482 if (strstr(prop->name, "nr-gpio"))
1485 str = strrchr(prop->name, '-');
1489 str = prop->name;
1500 struct property *prop;
1506 for_each_property(node, prop) {
1509 if (!prop_is_gpio(prop))
1512 provider.prop_name = prop->name;
1515 check_property_phandle_args(c, dti, node, prop, &provider);
1525 struct property *prop;
1527 for_each_property(node, prop) {
1530 if (!prop_is_gpio(prop))
1533 str = strstr(prop->name, "gpio");
1537 FAIL_PROP(c, dti, node, prop,
1546 struct property *prop;
1548 prop = get_property(node, "interrupt-controller");
1549 if (prop)
1552 prop = get_property(node, "interrupt-map");
1553 if (prop)
1563 struct property *prop;
1568 prop = get_property(node, "#interrupt-cells");
1569 if (!prop)
1573 prop = get_property(node, "#address-cells");
1574 if (!prop)
1586 struct property *irq_prop, *prop = NULL;
1597 while (parent && !prop) {
1603 prop = get_property(parent, "interrupt-parent");
1604 if (prop) {
1605 phandle = propval_cell(prop);
1611 FAIL_PROP(c, dti, parent, prop, "Invalid phandle");
1617 FAIL_PROP(c, dti, parent, prop, "Bad phandle");
1635 prop = get_property(irq_node, "#interrupt-cells");
1636 if (!prop) {
1641 irq_cells = propval_cell(prop);
1643 FAIL_PROP(c, dti, node, prop,
1691 struct property *prop = get_property(child, "reg");
1694 if (prop && propval_cell(prop) != 0)
1711 struct property *prop;
1713 prop = get_property(node, "reg");
1714 if (!prop || !unitname)
1717 if (!(prop->val.val && prop->val.len == sizeof(cell_t))) {
1722 snprintf(unit_addr, sizeof(unit_addr), "%x", propval_cell(prop));
1755 struct property *prop;
1757 prop = get_property(endpoint, "remote-endpoint");
1758 if (!prop)
1761 phandle = propval_cell(prop);
1768 FAIL_PROP(c, dti, endpoint, prop, "graph phandle is not valid");