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__); \
209 struct property *prop;
212 prop = get_property(node, propname);
213 if (!prop)
216 if (!data_is_one_string(prop->val))
217 FAIL_PROP(c, dti, node, prop, "property is not a string");
228 struct property *prop;
232 prop = get_property(node, propname);
233 if (!prop)
236 str = prop->val.val;
237 rem = prop->val.len;
241 FAIL_PROP(c, dti, node, prop, "property is not a string list");
256 struct property *prop;
259 prop = get_property(node, propname);
260 if (!prop)
263 if (prop->val.len != sizeof(cell_t))
264 FAIL_PROP(c, dti, node, prop, "property is not a single cell");
292 struct property *prop, *prop2;
294 for_each_property(node, prop) {
295 for (prop2 = prop->next; prop2; prop2 = prop2->next) {
298 if (streq(prop->name, prop2->name))
299 FAIL_PROP(c, dti, node, prop, "Duplicate property name");
360 struct property *prop = get_property(node, "reg");
367 if (!prop) {
368 prop = get_property(node, "ranges");
369 if (prop && !prop->val.len)
370 prop = NULL;
373 if (prop) {
386 struct property *prop;
388 for_each_property(node, prop) {
389 size_t n = strspn(prop->name, c->data);
391 if (n < strlen(prop->name))
392 FAIL_PROP(c, dti, node, prop, "Bad character '%c' in property name",
393 prop->name[n]);
402 struct property *prop;
404 for_each_property(node, prop) {
405 const char *name = prop->name;
408 if (n == strlen(prop->name))
424 FAIL_PROP(c, dti, node, prop, "Character '%c' not recommended in property name",
431 #define DESCLABEL_ARGS(node,prop,mark) \
433 ((prop) ? "'" : ""), \
434 ((prop) ? (prop)->name : ""), \
435 ((prop) ? "' in " : ""), (node)->fullpath
439 struct property *prop, struct marker *mark)
457 if ((othernode != node) || (otherprop != prop) || (othermark != mark))
460 label, DESCLABEL_ARGS(node, prop, mark),
468 struct property *prop;
473 for_each_property(node, prop) {
474 struct marker *m = prop->val.markers;
476 for_each_label(prop->labels, l)
477 check_duplicate_label(c, dti, l->label, node, prop, NULL);
480 check_duplicate_label(c, dti, m->ref, node, prop, m);
489 struct property *prop;
493 prop = get_property(node, propname);
494 if (!prop)
497 if (prop->val.len != sizeof(cell_t)) {
498 FAIL_PROP(c, dti, node, prop, "bad length (%d) %s property",
499 prop->val.len, prop->name);
503 m = prop->val.markers;
511 prop->name);
521 phandle = propval_cell(prop);
524 FAIL_PROP(c, dti, node, prop, "bad value (0x%x) in %s property",
525 phandle, prop->name);
571 struct property **pp, *prop = NULL;
575 prop = *pp;
579 if (!prop)
582 if ((prop->val.len != node->basenamelen + 1U)
583 || (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) {
585 " of base node name)", prop->val.val);
589 *pp = prop->next;
590 free(prop->name);
591 data_free(prop->val);
592 free(prop);
606 struct property *prop;
608 for_each_property(node, prop) {
609 struct marker *m = prop->val.markers;
614 assert(m->offset + sizeof(cell_t) <= prop->val.len);
622 *((fdt32_t *)(prop->val.val + m->offset)) =
628 *((fdt32_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(phandle);
641 struct property *prop;
643 for_each_property(node, prop) {
644 struct marker *m = prop->val.markers;
649 assert(m->offset <= prop->val.len);
659 prop->val = data_insert_at_marker(prop->val, m, path,
694 struct property *prop;
696 for_each_property(node, prop) {
697 if (!strends(prop->name, "-names"))
700 c->data = prop->name;
709 struct property *prop;
714 for_each_property(node, prop) {
715 if (streq(prop->name, "phandle")
716 || streq(prop->name, "linux,phandle")) {
720 if (!prop->val.val || !get_node_by_path(dti->dt, prop->val.val)) {
721 FAIL_PROP(c, dti, node, prop, "aliases property is not a valid node (%s)",
722 prop->val.val);
725 if (strspn(prop->name, LOWERCASE DIGITS "-") != strlen(prop->name))
734 struct property *prop;
739 prop = get_property(node, "#address-cells");
740 if (prop)
741 node->addr_cells = propval_cell(prop);
743 prop = get_property(node, "#size-cells");
744 if (prop)
745 node->size_cells = propval_cell(prop);
758 struct property *prop;
761 prop = get_property(node, "reg");
762 if (!prop)
770 if (prop->val.len == 0)
771 FAIL_PROP(c, dti, node, prop, "property is empty");
777 if (!is_multiple_of(prop->val.len, entrylen))
778 FAIL_PROP(c, dti, node, prop, "property has invalid length (%d bytes) "
780 prop->val.len, addr_cells, size_cells);
787 struct property *prop;
791 prop = get_property(node, ranges);
792 if (!prop)
796 FAIL_PROP(c, dti, node, prop, "Root node has a \"%s\" property",
807 if (prop->val.len == 0) {
809 FAIL_PROP(c, dti, node, prop, "empty \"%s\" property but its "
814 FAIL_PROP(c, dti, node, prop, "empty \"%s\" property but its "
818 } else if (!is_multiple_of(prop->val.len, entrylen)) {
819 FAIL_PROP(c, dti, node, prop, "\"%s\" property has invalid length (%d bytes) "
821 "#size-cells == %d)", ranges, prop->val.len,
834 struct property *prop;
837 prop = get_property(node, "device_type");
838 if (!prop || !streq(prop->val.val, "pci"))
847 prop = get_property(node, "ranges");
848 if (!prop)
856 prop = get_property(node, "bus-range");
857 if (!prop)
860 if (prop->val.len != (sizeof(cell_t) * 2)) {
861 FAIL_PROP(c, dti, node, prop, "value must be 2 cells");
864 cells = (cell_t *)prop->val.val;
866 FAIL_PROP(c, dti, node, prop, "1st cell must be less than or equal to 2nd cell");
868 FAIL_PROP(c, dti, node, prop, "maximum bus number must be less than 256");
875 struct property *prop;
882 prop = get_property(node, "reg");
883 if (!prop)
886 cells = (cell_t *)prop->val.val;
889 prop = get_property(node->parent, "bus-range");
890 if (!prop) {
893 cells = (cell_t *)prop->val.val;
898 FAIL_PROP(c, dti, node, prop, "PCI bus number %d out of range, expected (%d - %d)",
905 struct property *prop;
914 prop = get_property(node, "reg");
915 if (!prop)
918 cells = (cell_t *)prop->val.val;
920 FAIL_PROP(c, dti, node, prop, "PCI reg config space address cells 2 and 3 must be 0");
927 FAIL_PROP(c, dti, node, prop, "PCI reg address is not configuration space");
929 FAIL_PROP(c, dti, node, prop, "PCI reg config space address register number must be 0");
952 struct property *prop;
955 prop = get_property(node, "compatible");
956 if (!prop)
959 for (str = prop->val.val, end = str + prop->val.len; str < end;
977 struct property *prop;
987 prop = get_property(node, "reg");
988 if (prop)
989 cells = (cell_t *)prop->val.val;
991 prop = get_property(node, "ranges");
992 if (prop && prop->val.len)
994 cells = ((cell_t *)prop->val.val) + node_addr_cells(node);
1049 struct property *prop;
1059 prop = get_property(node, "reg");
1060 if (prop)
1061 cells = (cell_t *)prop->val.val;
1076 for (len = prop->val.len; len > 0; len -= 4) {
1082 FAIL_PROP(c, dti, node, prop, "I2C address must be less than 10-bits, got \"0x%x\"",
1085 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",
1109 struct property *prop;
1110 for_each_property(child, prop) {
1111 if (strprefixeq(prop->name, 4, "spi-")) {
1138 struct property *prop;
1150 prop = get_property(node, "reg");
1151 if (prop)
1152 cells = (cell_t *)prop->val.val;
1218 struct property *prop;
1229 prop = get_property(child, "reg");
1230 if (prop)
1241 struct property *prop;
1243 prop = get_property(node, "status");
1244 if (prop) {
1245 char *str = prop->val.val;
1311 struct property *prop;
1321 prop = get_property(chosen, "interrupt-controller");
1322 if (prop)
1323 FAIL_PROP(c, dti, node, prop,
1343 struct property *prop;
1348 prop = get_property(node, "bootargs");
1349 if (!prop)
1352 c->data = prop->name;
1360 struct property *prop;
1365 prop = get_property(node, "stdout-path");
1366 if (!prop) {
1367 prop = get_property(node, "linux,stdout-path");
1368 if (!prop)
1370 FAIL_PROP(c, dti, node, prop, "Use 'stdout-path' instead");
1373 c->data = prop->name;
1387 struct property *prop,
1393 if (!is_multiple_of(prop->val.len, sizeof(cell_t))) {
1394 FAIL_PROP(c, dti, node, prop,
1396 prop->val.len, sizeof(cell_t));
1400 for (cell = 0; cell < prop->val.len / sizeof(cell_t); cell += cellsize + 1) {
1406 phandle = propval_cell_n(prop, cell);
1421 if (prop->val.markers) {
1422 struct marker *m = prop->val.markers;
1428 FAIL_PROP(c, dti, node, prop,
1435 FAIL_PROP(c, dti, node, prop,
1450 prop->name, cell);
1455 if ((expected <= cell) || prop->val.len < expected) {
1456 FAIL_PROP(c, dti, node, prop,
1458 prop->val.len, cellsize);
1469 struct property *prop;
1471 prop = get_property(node, provider->prop_name);
1472 if (!prop)
1475 check_property_phandle_args(c, dti, node, prop, provider);
1499 static bool prop_is_gpio(struct property *prop)
1505 if (strends(prop->name, ",nr-gpios"))
1508 return strends(prop->name, "-gpios") ||
1509 streq(prop->name, "gpios") ||
1510 strends(prop->name, "-gpio") ||
1511 streq(prop->name, "gpio");
1518 struct property *prop;
1524 for_each_property(node, prop) {
1527 if (!prop_is_gpio(prop))
1530 provider.prop_name = prop->name;
1533 check_property_phandle_args(c, dti, node, prop, &provider);
1543 struct property *prop;
1545 for_each_property(node, prop) {
1546 if (!prop_is_gpio(prop))
1549 if (!strends(prop->name, "gpio"))
1552 FAIL_PROP(c, dti, node, prop,
1561 struct property *prop;
1563 prop = get_property(node, "interrupt-controller");
1564 if (prop)
1567 prop = get_property(node, "interrupt-map");
1568 if (prop)
1578 struct property *prop;
1581 prop = get_property(node, "#interrupt-cells");
1582 if (irq_provider && !prop) {
1588 if (!irq_provider && prop) {
1601 struct property *prop, *irq_map_prop;
1616 prop = get_property(node, "interrupt-map-mask");
1617 if (prop && (prop->val.len != (cellsize * sizeof(cell_t))))
1618 FAIL_PROP(c, dti, node, prop,
1620 prop->val.len, cellsize * sizeof(cell_t));
1686 struct property *irq_prop, *prop = NULL;
1697 while (parent && !prop) {
1703 prop = get_property(parent, "interrupt-parent");
1704 if (prop) {
1705 phandle = propval_cell(prop);
1711 FAIL_PROP(c, dti, parent, prop, "Invalid phandle");
1717 FAIL_PROP(c, dti, parent, prop, "Bad phandle");
1735 prop = get_property(irq_node, "#interrupt-cells");
1736 if (!prop) {
1741 irq_cells = propval_cell(prop);
1743 FAIL_PROP(c, dti, node, prop,
1791 struct property *prop = get_property(child, "reg");
1794 if (prop && propval_cell(prop) != 0)
1811 struct property *prop;
1813 prop = get_property(node, "reg");
1814 if (!prop || !unitname)
1817 if (!(prop->val.val && prop->val.len == sizeof(cell_t))) {
1822 snprintf(unit_addr, sizeof(unit_addr), "%x", propval_cell(prop));
1855 struct property *prop;
1857 prop = get_property(endpoint, "remote-endpoint");
1858 if (!prop)
1861 phandle = propval_cell(prop);
1868 FAIL_PROP(c, dti, endpoint, prop, "graph phandle is not valid");