Lines Matching refs:prop
61 check_msg(struct check *c, struct dt_info *dti, struct node *node, struct property *prop, const char *fmt, ...)
72 if (prop && prop->srcpos) {
73 pos = prop->srcpos;
91 if (prop) {
92 xasprintf_append(&str, "%s:%s: ", node->fullpath, prop->name);
104 if (!prop && pos) {
125 #define FAIL_PROP(c, dti, node, prop, ...) \
129 check_msg((c), dti, node, prop, __VA_ARGS__); \
200 struct property *prop;
203 prop = get_property(node, propname);
204 if (!prop) {
208 if (!data_is_one_string(prop->val)) {
209 FAIL_PROP(c, dti, node, prop, "property is not a string");
218 struct property *prop;
222 prop = get_property(node, propname);
223 if (!prop) {
227 str = prop->val.val;
228 rem = prop->val.len;
232 FAIL_PROP(c, dti, node, prop, "property is not a string list");
244 struct property *prop;
247 prop = get_property(node, propname);
248 if (!prop) {
252 if (prop->val.len != sizeof(cell_t)) {
253 FAIL_PROP(c, dti, node, prop, "property is not a single cell");
279 struct property *prop, *prop2;
281 for_each_property(node, prop)
283 for (prop2 = prop->next; prop2; prop2 = prop2->next) {
287 if (streq(prop->name, prop2->name)) {
288 FAIL_PROP(c, dti, node, prop, "Duplicate property name");
330 struct property *prop = get_property(node, "reg");
337 if (!prop) {
338 prop = get_property(node, "ranges");
339 if (prop && !prop->val.len) {
340 prop = NULL;
344 if (prop) {
358 struct property *prop;
360 for_each_property(node, prop)
362 int n = strspn(prop->name, c->data);
363 if (n < strlen(prop->name)) {
364 FAIL_PROP(c, dti, node, prop, "Bad character '%c' in property name", prop->name[n]);
372 struct property *prop;
374 for_each_property(node, prop)
376 const char *name = prop->name;
378 if (n == strlen(prop->name)) {
396 FAIL_PROP(c, dti, node, prop, "Character '%c' not recommended in property name", name[n]);
403 #define DESCLABEL_ARGS(node, prop, mark) \
404 ((mark) ? "value of " : ""), ((prop) ? "'" : ""), ((prop) ? (prop)->name : ""), ((prop) ? "' in " : ""), \
408 struct property *prop, struct marker *mark)
427 if ((othernode != node) || (otherprop != prop) || (othermark != mark)) {
429 DESCLABEL_ARGS(node, prop, mark), DESCLABEL_ARGS(othernode, otherprop, othermark));
436 struct property *prop;
440 for_each_property(node, prop)
442 struct marker *m = prop->val.markers;
444 for_each_label(prop->labels, l) check_duplicate_label(c, dti, l->label, node, prop, NULL);
446 for_each_marker_of_type(m, LABEL) check_duplicate_label(c, dti, m->ref, node, prop, m);
454 struct property *prop;
458 prop = get_property(node, propname);
459 if (!prop) {
463 if (prop->val.len != sizeof(cell_t)) {
464 FAIL_PROP(c, dti, node, prop, "bad length (%d) %s property", prop->val.len, prop->name);
468 m = prop->val.markers;
476 FAIL(c, dti, node, "%s is a reference to another node", prop->name);
486 phandle = propval_cell(prop);
488 FAIL_PROP(c, dti, node, prop, "bad value (0x%x) in %s property", phandle, prop->name);
534 struct property **pp, *prop = NULL;
538 prop = *pp;
543 if (!prop) {
547 if ((prop->val.len != node->basenamelen + 1) || (memcmp(prop->val.val, node->name, node->basenamelen) != 0)) {
551 prop->val.val);
555 *pp = prop->next;
556 free(prop->name);
557 data_free(prop->val);
558 free(prop);
571 struct property *prop;
573 for_each_property(node, prop)
575 struct marker *m = prop->val.markers;
581 assert(m->offset + sizeof(cell_t) <= prop->val.len);
591 *((fdt32_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(0xffffffff);
597 *((fdt32_t *)(prop->val.val + m->offset)) = cpu_to_fdt32(phandle);
608 struct property *prop;
610 for_each_property(node, prop)
612 struct marker *m = prop->val.markers;
618 assert(m->offset <= prop->val.len);
627 prop->val = data_insert_at_marker(prop->val, m, path, strlen(path) + 1);
648 struct property *prop;
652 for_each_property(parent, prop) return;
677 struct property *prop;
679 for_each_property(node, prop)
681 const char *s = strrchr(prop->name, '-');
686 c->data = prop->name;
694 struct property *prop;
700 for_each_property(node, prop)
702 if (streq(prop->name, "phandle") || streq(prop->name, "linux,phandle")) {
706 if (!prop->val.val || !get_node_by_path(dti->dt, prop->val.val)) {
707 FAIL_PROP(c, dti, node, prop, "aliases property is not a valid node (%s)", prop->val.val);
710 if (strspn(prop->name, LOWERCASE DIGITS "-") != strlen(prop->name)) {
719 struct property *prop;
724 prop = get_property(node, "#address-cells");
725 if (prop) {
726 node->addr_cells = propval_cell(prop);
729 prop = get_property(node, "#size-cells");
730 if (prop) {
731 node->size_cells = propval_cell(prop);
768 struct property *prop;
771 prop = get_property(node, "reg");
772 if (!prop) {
781 if (prop->val.len == 0) {
782 FAIL_PROP(c, dti, node, prop, "property is empty");
789 if (!entrylen || (prop->val.len % entrylen) != 0) {
790 FAIL_PROP(c, dti, node, prop,
793 prop->val.len, addr_cells, size_cells);
800 struct property *prop;
804 prop = get_property(node, ranges);
805 if (!prop) {
810 FAIL_PROP(c, dti, node, prop, "Root node has a \"%s\" property", ranges);
820 if (prop->val.len == 0) {
822 FAIL_PROP(c, dti, node, prop,
828 FAIL_PROP(c, dti, node, prop,
833 } else if ((prop->val.len % entrylen) != 0) {
834 FAIL_PROP(c, dti, node, prop,
838 ranges, prop->val.len, p_addr_cells, c_addr_cells, c_size_cells);
850 struct property *prop;
853 prop = get_property(node, "device_type");
854 if (!prop || !streq(prop->val.val, "pci")) {
864 prop = get_property(node, "ranges");
865 if (!prop) {
876 prop = get_property(node, "bus-range");
877 if (!prop) {
881 if (prop->val.len != (sizeof(cell_t) * PCI_ADDRESS_CELLS_TWO)) {
882 FAIL_PROP(c, dti, node, prop, "value must be 2 cells");
885 cells = (cell_t *)prop->val.val;
887 FAIL_PROP(c, dti, node, prop, "1st cell must be less than or equal to 2nd cell");
890 FAIL_PROP(c, dti, node, prop, "maximum bus number must be less than 256");
897 struct property *prop;
905 prop = get_property(node, "reg");
906 if (!prop) {
910 cells = (cell_t *)prop->val.val;
913 prop = get_property(node->parent, "bus-range");
914 if (!prop) {
917 cells = (cell_t *)prop->val.val;
922 FAIL_PROP(c, dti, node, prop, "PCI bus number %d out of range, expected (%d - %d)", bus_num, min_bus, max_bus);
929 struct property *prop;
939 prop = get_property(node, "reg");
940 if (!prop) {
944 cells = (cell_t *)prop->val.val;
946 FAIL_PROP(c, dti, node, prop, "PCI reg config space address cells 2 and 3 must be 0");
954 FAIL_PROP(c, dti, node, prop, "PCI reg address is not configuration space");
957 FAIL_PROP(c, dti, node, prop, "PCI reg config space address register number must be 0");
982 struct property *prop;
985 prop = get_property(node, "compatible");
986 if (!prop) {
990 for (str = prop->val.val, end = str + prop->val.len; str < end; str += strnlen(str, end - str) + 1) {
1008 struct property *prop;
1019 prop = get_property(node, "reg");
1020 if (prop) {
1021 cells = (cell_t *)prop->val.val;
1023 prop = get_property(node, "ranges");
1024 if (prop && prop->val.len) {
1026 cells = ((cell_t *)prop->val.val) + node_addr_cells(node);
1089 struct property *prop;
1100 prop = get_property(node, "reg");
1101 if (prop) {
1102 cells = (cell_t *)prop->val.val;
1118 for (len = prop->val.len; len > 0; len -= CELLS_UINT_ADDRESS_SIZE) {
1124 FAIL_PROP(c, dti, node, prop, "I2C address must be less than 10-bits, got \"0x%x\"", reg);
1126 FAIL_PROP(c, dti, node, prop,
1155 struct property *prop;
1156 for_each_property(child, prop)
1158 if (strprefixeq(prop->name, CELLS_UINT_ADDRESS_SIZE, "spi-")) {
1190 struct property *prop;
1204 prop = get_property(node, "reg");
1205 if (prop) {
1206 cells = (cell_t *)prop->val.val;
1275 struct property *prop;
1289 prop = get_property(child, "reg");
1290 if (prop) {
1303 struct property *prop;
1305 prop = get_property(node, "status");
1306 if (prop) {
1307 char *str = prop->val.val;
1377 struct property *prop;
1388 prop = get_property(chosen, "interrupt-controller");
1389 if (prop) {
1390 FAIL_PROP(c, dti, node, prop, "/chosen has obsolete \"interrupt-controller\" property");
1409 struct property *prop;
1415 prop = get_property(node, "bootargs");
1416 if (!prop) {
1420 c->data = prop->name;
1427 struct property *prop;
1433 prop = get_property(node, "stdout-path");
1434 if (!prop) {
1435 prop = get_property(node, "linux,stdout-path");
1436 if (!prop) {
1439 FAIL_PROP(c, dti, node, prop, "Use 'stdout-path' instead");
1442 c->data = prop->name;
1453 static void check_property_phandle_args(struct check *c, struct dt_info *dti, struct node *node, struct property *prop,
1459 if (prop->val.len % sizeof(cell_t)) {
1460 FAIL_PROP(c, dti, node, prop, "property size (%d) is invalid, expected multiple of %zu", prop->val.len,
1465 for (cell = 0; cell < prop->val.len / sizeof(cell_t); cell += cellsize + 1) {
1470 phandle = propval_cell_n(prop, cell);
1486 if (prop->val.markers) {
1487 struct marker *m = prop->val.markers;
1495 FAIL_PROP(c, dti, node, prop, "cell %d is not a phandle reference", cell);
1501 FAIL_PROP(c, dti, node, prop, "Could not get phandle node for (cell %d)", cell);
1512 provider->cell_name, provider_node->fullpath, prop->name, cell);
1516 if (prop->val.len < ((cell + cellsize + 1) * sizeof(cell_t))) {
1517 FAIL_PROP(c, dti, node, prop, "property size (%d) too small for cell size %d", prop->val.len, cellsize);
1525 struct property *prop;
1527 prop = get_property(node, provider->prop_name);
1528 if (!prop) {
1532 check_property_phandle_args(c, dti, node, prop, provider);
1555 static bool prop_is_gpio(struct property *prop)
1563 if (strstr(prop->name, "nr-gpio")) {
1567 str = strrchr(prop->name, '-');
1571 str = prop->name;
1582 struct property *prop;
1589 for_each_property(node, prop)
1593 if (!prop_is_gpio(prop)) {
1597 provider.prop_name = prop->name;
1600 check_property_phandle_args(c, dti, node, prop, &provider);
1607 struct property *prop;
1609 for_each_property(node, prop)
1613 if (!prop_is_gpio(prop)) {
1617 str = strstr(prop->name, "gpio");
1622 FAIL_PROP(c, dti, node, prop, "'[*-]gpio' is deprecated, use '[*-]gpios' instead");
1629 struct property *prop;
1631 prop = get_property(node, "interrupt-controller");
1632 if (prop) {
1636 prop = get_property(node, "interrupt-map");
1637 if (prop) {
1646 struct property *prop;
1652 prop = get_property(node, "#interrupt-cells");
1653 if (!prop) {
1657 prop = get_property(node, "#address-cells");
1658 if (!prop) {
1668 struct property *irq_prop, *prop = NULL;
1681 while (parent && !prop) {
1687 prop = get_property(parent, "interrupt-parent");
1688 if (prop) {
1689 phandle = propval_cell(prop);
1696 FAIL_PROP(c, dti, parent, prop, "Invalid phandle");
1702 FAIL_PROP(c, dti, parent, prop, "Bad phandle");
1720 prop = get_property(irq_node, "#interrupt-cells");
1721 if (!prop) {
1726 irq_cells = propval_cell(prop);
1728 FAIL_PROP(c, dti, node, prop, "size is (%d), expected multiple of %d", irq_prop->val.len,
1775 struct property *prop = get_property(child, "reg");
1778 if (prop && propval_cell(prop) != 0) {
1796 struct property *prop;
1798 prop = get_property(node, "reg");
1799 if (!prop || !unitname) {
1803 if (!(prop->val.val && prop->val.len == sizeof(cell_t))) {
1808 (void)snprintf(unit_addr, sizeof(unit_addr), "%x", propval_cell(prop));
1841 struct property *prop;
1843 prop = get_property(endpoint, "remote-endpoint");
1844 if (!prop) {
1848 phandle = propval_cell(prop);
1856 FAIL_PROP(c, dti, endpoint, prop, "graph phandle is not valid");