1# Copyright (c) 2018-2019 Linaro 2# Copyright (c) 2019 Nordic Semiconductor ASA 3# 4# SPDX-License-Identifier: Apache-2.0 5 6import inspect 7import os 8import pickle 9import sys 10from pathlib import Path 11 12ZEPHYR_BASE = str(Path(__file__).resolve().parents[2]) 13sys.path.insert(0, os.path.join(ZEPHYR_BASE, "scripts", "dts", 14 "python-devicetree", "src")) 15 16# Types we support 17# 'string', 'int', 'hex', 'bool' 18 19doc_mode = os.environ.get('KCONFIG_DOC_MODE') == "1" 20 21if not doc_mode: 22 EDT_PICKLE = os.environ.get("EDT_PICKLE") 23 24 # The "if" handles a missing dts. 25 if EDT_PICKLE is not None and os.path.isfile(EDT_PICKLE): 26 with open(EDT_PICKLE, 'rb') as f: 27 edt = pickle.load(f) 28 edtlib = inspect.getmodule(edt) 29 else: 30 edt = None 31 32 33def _warn(kconf, msg): 34 print("{}:{}: WARNING: {}".format(kconf.filename, kconf.linenr, msg)) 35 36 37def _dt_units_to_scale(unit): 38 if not unit: 39 return 0 40 if unit in {'k', 'K'}: 41 return 10 42 if unit in {'m', 'M'}: 43 return 20 44 if unit in {'g', 'G'}: 45 return 30 46 if unit in {'kb', 'Kb'}: 47 return 13 48 if unit in {'mb', 'Mb'}: 49 return 23 50 if unit in {'gb', 'Gb'}: 51 return 33 52 53 54def dt_chosen_label(kconf, _, chosen): 55 """ 56 This function takes a 'chosen' property and treats that property as a path 57 to an EDT node. If it finds an EDT node, it will look to see if that node 58 has a "label" property and return the value of that "label". If not, we 59 return the node's name in the devicetree. 60 """ 61 if doc_mode or edt is None: 62 return "" 63 64 node = edt.chosen_node(chosen) 65 if not node: 66 return "" 67 68 if "label" not in node.props: 69 return node.name 70 71 return node.props["label"].val 72 73 74def dt_chosen_enabled(kconf, _, chosen): 75 """ 76 This function returns "y" if /chosen contains a property named 'chosen' 77 that points to an enabled node, and "n" otherwise 78 """ 79 if doc_mode or edt is None: 80 return "n" 81 82 node = edt.chosen_node(chosen) 83 return "y" if node and node.status == "okay" else "n" 84 85 86def dt_chosen_path(kconf, _, chosen): 87 """ 88 This function takes a /chosen node property and returns the path 89 to the node in the property value, or the empty string. 90 """ 91 if doc_mode or edt is None: 92 return "n" 93 94 node = edt.chosen_node(chosen) 95 96 return node.path if node else "" 97 98def dt_chosen_has_compat(kconf, _, chosen, compat): 99 """ 100 This function takes a /chosen node property and returns 'y' if the 101 chosen node has the provided compatible string 'compat' 102 """ 103 if doc_mode or edt is None: 104 return "n" 105 106 node = edt.chosen_node(chosen) 107 108 if node is None: 109 return "n" 110 111 if compat in node.compats: 112 return "y" 113 114 return "n" 115 116def dt_node_enabled(kconf, name, node): 117 """ 118 This function is used to test if a node is enabled (has status 119 'okay') or not. 120 121 The 'node' argument is a string which is either a path or an 122 alias, or both, depending on 'name'. 123 124 If 'name' is 'dt_path_enabled', 'node' is an alias or a path. If 125 'name' is 'dt_alias_enabled, 'node' is an alias. 126 """ 127 128 if doc_mode or edt is None: 129 return "n" 130 131 if name == "dt_alias_enabled": 132 if node.startswith("/"): 133 # EDT.get_node() works with either aliases or paths. If we 134 # are specifically being asked about an alias, reject paths. 135 return "n" 136 else: 137 # Make sure this is being called appropriately. 138 assert name == "dt_path_enabled" 139 140 try: 141 node = edt.get_node(node) 142 except edtlib.EDTError: 143 return "n" 144 145 return "y" if node and node.status == "okay" else "n" 146 147 148def dt_nodelabel_enabled(kconf, _, label): 149 """ 150 This function is like dt_node_enabled(), but the 'label' argument 151 should be a node label, like "foo" is here: 152 153 foo: some-node { ... }; 154 """ 155 if doc_mode or edt is None: 156 return "n" 157 158 node = edt.label2node.get(label) 159 160 return "y" if node and node.status == "okay" else "n" 161 162 163def _node_reg_addr(node, index, unit): 164 if not node: 165 return 0 166 167 if not node.regs: 168 return 0 169 170 if int(index) >= len(node.regs): 171 return 0 172 173 if node.regs[int(index)].addr is None: 174 return 0 175 176 return node.regs[int(index)].addr >> _dt_units_to_scale(unit) 177 178 179def _node_reg_size(node, index, unit): 180 if not node: 181 return 0 182 183 if not node.regs: 184 return 0 185 186 if int(index) >= len(node.regs): 187 return 0 188 189 if node.regs[int(index)].size is None: 190 return 0 191 192 return node.regs[int(index)].size >> _dt_units_to_scale(unit) 193 194 195def _node_int_prop(node, prop, unit=None): 196 """ 197 This function takes a 'node' and will look to see if that 'node' has a 198 property called 'prop' and if that 'prop' is an integer type will return 199 the value of the property 'prop' as either a string int or string hex 200 value, if not we return 0. 201 202 The function will divide the value based on 'unit': 203 None No division 204 'k' or 'K' divide by 1024 (1 << 10) 205 'm' or 'M' divide by 1,048,576 (1 << 20) 206 'g' or 'G' divide by 1,073,741,824 (1 << 30) 207 'kb' or 'Kb' divide by 8192 (1 << 13) 208 'mb' or 'Mb' divide by 8,388,608 (1 << 23) 209 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33) 210 """ 211 if not node: 212 return 0 213 214 if prop not in node.props: 215 return 0 216 217 if node.props[prop].type != "int": 218 return 0 219 220 return node.props[prop].val >> _dt_units_to_scale(unit) 221 222 223def _node_array_prop(node, prop, index=0, unit=None): 224 """ 225 This function takes a 'node' and will look to see if that 'node' has a 226 property called 'prop' and if that 'prop' is an array type will return 227 the value of the property 'prop' at the given 'index' as either a string int 228 or string hex value. If the property 'prop' is not found or the given 'index' 229 is out of range it will return 0. 230 231 The function will divide the value based on 'unit': 232 None No division 233 'k' or 'K' divide by 1024 (1 << 10) 234 'm' or 'M' divide by 1,048,576 (1 << 20) 235 'g' or 'G' divide by 1,073,741,824 (1 << 30) 236 """ 237 if not node: 238 return 0 239 240 if prop not in node.props: 241 return 0 242 if node.props[prop].type != "array": 243 return 0 244 if int(index) >= len(node.props[prop].val): 245 return 0 246 return node.props[prop].val[int(index)] >> _dt_units_to_scale(unit) 247 248 249def _dt_chosen_reg_addr(kconf, chosen, index=0, unit=None): 250 """ 251 This function takes a 'chosen' property and treats that property as a path 252 to an EDT node. If it finds an EDT node, it will look to see if that 253 node has a register at the given 'index' and return the address value of 254 that reg, if not we return 0. 255 256 The function will divide the value based on 'unit': 257 None No division 258 'k' or 'K' divide by 1024 (1 << 10) 259 'm' or 'M' divide by 1,048,576 (1 << 20) 260 'g' or 'G' divide by 1,073,741,824 (1 << 30) 261 'kb' or 'Kb' divide by 8192 (1 << 13) 262 'mb' or 'Mb' divide by 8,388,608 (1 << 23) 263 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33) 264 """ 265 if doc_mode or edt is None: 266 return 0 267 268 node = edt.chosen_node(chosen) 269 270 return _node_reg_addr(node, index, unit) 271 272 273def _dt_chosen_reg_size(kconf, chosen, index=0, unit=None): 274 """ 275 This function takes a 'chosen' property and treats that property as a path 276 to an EDT node. If it finds an EDT node, it will look to see if that node 277 has a register at the given 'index' and return the size value of that reg, 278 if not we return 0. 279 280 The function will divide the value based on 'unit': 281 None No division 282 'k' or 'K' divide by 1024 (1 << 10) 283 'm' or 'M' divide by 1,048,576 (1 << 20) 284 'g' or 'G' divide by 1,073,741,824 (1 << 30) 285 'kb' or 'Kb' divide by 8192 (1 << 13) 286 'mb' or 'Mb' divide by 8,388,608 (1 << 23) 287 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33) 288 """ 289 if doc_mode or edt is None: 290 return 0 291 292 node = edt.chosen_node(chosen) 293 294 return _node_reg_size(node, index, unit) 295 296 297def dt_chosen_reg(kconf, name, chosen, index=0, unit=None): 298 """ 299 This function just routes to the proper function and converts 300 the result to either a string int or string hex value. 301 """ 302 if name == "dt_chosen_reg_size_int": 303 return str(_dt_chosen_reg_size(kconf, chosen, index, unit)) 304 if name == "dt_chosen_reg_size_hex": 305 return hex(_dt_chosen_reg_size(kconf, chosen, index, unit)) 306 if name == "dt_chosen_reg_addr_int": 307 return str(_dt_chosen_reg_addr(kconf, chosen, index, unit)) 308 if name == "dt_chosen_reg_addr_hex": 309 return hex(_dt_chosen_reg_addr(kconf, chosen, index, unit)) 310 311 312def _dt_node_reg_addr(kconf, path, index=0, unit=None): 313 """ 314 This function takes a 'path' and looks for an EDT node at that path. If it 315 finds an EDT node, it will look to see if that node has a register at the 316 given 'index' and return the address value of that reg, if not we return 0. 317 318 The function will divide the value based on 'unit': 319 None No division 320 'k' or 'K' divide by 1024 (1 << 10) 321 'm' or 'M' divide by 1,048,576 (1 << 20) 322 'g' or 'G' divide by 1,073,741,824 (1 << 30) 323 'kb' or 'Kb' divide by 8192 (1 << 13) 324 'mb' or 'Mb' divide by 8,388,608 (1 << 23) 325 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33) 326 """ 327 if doc_mode or edt is None: 328 return 0 329 330 try: 331 node = edt.get_node(path) 332 except edtlib.EDTError: 333 return 0 334 335 return _node_reg_addr(node, index, unit) 336 337 338def _dt_node_reg_size(kconf, path, index=0, unit=None): 339 """ 340 This function takes a 'path' and looks for an EDT node at that path. If it 341 finds an EDT node, it will look to see if that node has a register at the 342 given 'index' and return the size value of that reg, if not we return 0. 343 344 The function will divide the value based on 'unit': 345 None No division 346 'k' or 'K' divide by 1024 (1 << 10) 347 'm' or 'M' divide by 1,048,576 (1 << 20) 348 'g' or 'G' divide by 1,073,741,824 (1 << 30) 349 'kb' or 'Kb' divide by 8192 (1 << 13) 350 'mb' or 'Mb' divide by 8,388,608 (1 << 23) 351 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33) 352 """ 353 if doc_mode or edt is None: 354 return 0 355 356 try: 357 node = edt.get_node(path) 358 except edtlib.EDTError: 359 return 0 360 361 return _node_reg_size(node, index, unit) 362 363 364def dt_node_reg(kconf, name, path, index=0, unit=None): 365 """ 366 This function just routes to the proper function and converts 367 the result to either a string int or string hex value. 368 """ 369 if name == "dt_node_reg_size_int": 370 return str(_dt_node_reg_size(kconf, path, index, unit)) 371 if name == "dt_node_reg_size_hex": 372 return hex(_dt_node_reg_size(kconf, path, index, unit)) 373 if name == "dt_node_reg_addr_int": 374 return str(_dt_node_reg_addr(kconf, path, index, unit)) 375 if name == "dt_node_reg_addr_hex": 376 return hex(_dt_node_reg_addr(kconf, path, index, unit)) 377 378def _dt_node_bool_prop_generic(node_search_function, search_arg, prop): 379 """ 380 This function takes the 'node_search_function' and uses it to search for 381 a node with 'search_arg' and if node exists, checks if 'prop' exists 382 inside the node and is a boolean, if it is true, returns "y". 383 Otherwise, it returns "n". 384 """ 385 try: 386 node = node_search_function(search_arg) 387 except edtlib.EDTError: 388 return "n" 389 390 if node is None: 391 return "n" 392 393 if prop not in node.props: 394 return "n" 395 396 if node.props[prop].type != "boolean": 397 return "n" 398 399 if node.props[prop].val: 400 return "y" 401 402 return "n" 403 404def dt_node_bool_prop(kconf, _, path, prop): 405 """ 406 This function takes a 'path' and looks for an EDT node at that path. If it 407 finds an EDT node, it will look to see if that node has a boolean property 408 by the name of 'prop'. If the 'prop' exists it will return "y" otherwise 409 we return "n". 410 """ 411 if doc_mode or edt is None: 412 return "n" 413 414 return _dt_node_bool_prop_generic(edt.get_node, path, prop) 415 416def dt_nodelabel_bool_prop(kconf, _, label, prop): 417 """ 418 This function takes a 'label' and looks for an EDT node with that label. 419 If it finds an EDT node, it will look to see if that node has a boolean 420 property by the name of 'prop'. If the 'prop' exists it will return "y" 421 otherwise we return "n". 422 """ 423 if doc_mode or edt is None: 424 return "n" 425 426 return _dt_node_bool_prop_generic(edt.label2node.get, label, prop) 427 428def dt_chosen_bool_prop(kconf, _, chosen, prop): 429 """ 430 This function takes a /chosen node property named 'chosen', and 431 looks for the chosen node. If that node exists and has a boolean 432 property 'prop', it returns "y". Otherwise, it returns "n". 433 """ 434 if doc_mode or edt is None: 435 return "n" 436 437 return _dt_node_bool_prop_generic(edt.chosen_node, chosen, prop) 438 439def _dt_node_has_prop_generic(node_search_function, search_arg, prop): 440 """ 441 This function takes the 'node_search_function' and uses it to search for 442 a node with 'search_arg' and if node exists, then checks if 'prop' 443 exists inside the node and returns "y". Otherwise, it returns "n". 444 """ 445 try: 446 node = node_search_function(search_arg) 447 except edtlib.EDTError: 448 return "n" 449 450 if node is None: 451 return "n" 452 453 if prop in node.props: 454 return "y" 455 456 return "n" 457 458def dt_node_has_prop(kconf, _, path, prop): 459 """ 460 This function takes a 'path' and looks for an EDT node at that path. If it 461 finds an EDT node, it will look to see if that node has a property 462 by the name of 'prop'. If the 'prop' exists it will return "y" otherwise 463 it returns "n". 464 """ 465 if doc_mode or edt is None: 466 return "n" 467 468 return _dt_node_has_prop_generic(edt.get_node, path, prop) 469 470def dt_nodelabel_has_prop(kconf, _, label, prop): 471 """ 472 This function takes a 'label' and looks for an EDT node with that label. 473 If it finds an EDT node, it will look to see if that node has a property 474 by the name of 'prop'. If the 'prop' exists it will return "y" otherwise 475 it returns "n". 476 """ 477 if doc_mode or edt is None: 478 return "n" 479 480 return _dt_node_has_prop_generic(edt.label2node.get, label, prop) 481 482def dt_node_int_prop(kconf, name, path, prop, unit=None): 483 """ 484 This function takes a 'path' and property name ('prop') looks for an EDT 485 node at that path. If it finds an EDT node, it will look to see if that 486 node has a property called 'prop' and if that 'prop' is an integer type 487 will return the value of the property 'prop' as either a string int or 488 string hex value, if not we return 0. 489 490 The function will divide the value based on 'unit': 491 None No division 492 'k' or 'K' divide by 1024 (1 << 10) 493 'm' or 'M' divide by 1,048,576 (1 << 20) 494 'g' or 'G' divide by 1,073,741,824 (1 << 30) 495 'kb' or 'Kb' divide by 8192 (1 << 13) 496 'mb' or 'Mb' divide by 8,388,608 (1 << 23) 497 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33) 498 """ 499 if doc_mode or edt is None: 500 return "0" 501 502 try: 503 node = edt.get_node(path) 504 except edtlib.EDTError: 505 return "0" 506 507 if name == "dt_node_int_prop_int": 508 return str(_node_int_prop(node, prop, unit)) 509 if name == "dt_node_int_prop_hex": 510 return hex(_node_int_prop(node, prop, unit)) 511 512 513def dt_node_array_prop(kconf, name, path, prop, index, unit=None): 514 """ 515 This function takes a 'path', property name ('prop') and index ('index') 516 and looks for an EDT node at that path. If it finds an EDT node, it will 517 look to see if that node has a property called 'prop' and if that 'prop' 518 is an array type will return the value of the property 'prop' at the given 519 'index' as either a string int or string hex value. If not found we return 0. 520 521 The function will divide the value based on 'unit': 522 None No division 523 'k' or 'K' divide by 1024 (1 << 10) 524 'm' or 'M' divide by 1,048,576 (1 << 20) 525 'g' or 'G' divide by 1,073,741,824 (1 << 30) 526 """ 527 if doc_mode or edt is None: 528 return "0" 529 530 try: 531 node = edt.get_node(path) 532 except edtlib.EDTError: 533 return "0" 534 if name == "dt_node_array_prop_int": 535 return str(_node_array_prop(node, prop, index, unit)) 536 if name == "dt_node_array_prop_hex": 537 return hex(_node_array_prop(node, prop, index, unit)) 538 539 540def dt_node_str_prop_equals(kconf, _, path, prop, val): 541 """ 542 This function takes a 'path' and property name ('prop') looks for an EDT 543 node at that path. If it finds an EDT node, it will look to see if that 544 node has a property 'prop' of type string. If that 'prop' is equal to 'val' 545 it will return "y" otherwise return "n". 546 """ 547 548 if doc_mode or edt is None: 549 return "n" 550 551 try: 552 node = edt.get_node(path) 553 except edtlib.EDTError: 554 return "n" 555 556 if prop not in node.props: 557 return "n" 558 559 if node.props[prop].type != "string": 560 return "n" 561 562 if node.props[prop].val == val: 563 return "y" 564 565 return "n" 566 567 568def dt_has_compat(kconf, _, compat): 569 """ 570 This function takes a 'compat' and returns "y" if any compatible node 571 can be found in the EDT, otherwise it returns "n". 572 """ 573 if doc_mode or edt is None: 574 return "n" 575 576 return "y" if compat in edt.compat2nodes else "n" 577 578 579def dt_compat_enabled(kconf, _, compat): 580 """ 581 This function takes a 'compat' and returns "y" if we find a status "okay" 582 compatible node in the EDT otherwise we return "n" 583 """ 584 if doc_mode or edt is None: 585 return "n" 586 587 return "y" if compat in edt.compat2okay else "n" 588 589 590def dt_compat_on_bus(kconf, _, compat, bus): 591 """ 592 This function takes a 'compat' and returns "y" if we find an "enabled" 593 compatible node in the EDT which is on bus 'bus'. It returns "n" otherwise. 594 """ 595 if doc_mode or edt is None: 596 return "n" 597 598 if compat in edt.compat2okay: 599 for node in edt.compat2okay[compat]: 600 if node.on_buses is not None and bus in node.on_buses: 601 return "y" 602 603 return "n" 604 605 606def dt_nodelabel_has_compat(kconf, _, label, compat): 607 """ 608 This function takes a 'label' and looks for an EDT node with that label. 609 If it finds such node, it returns "y" if this node is compatible with 610 the provided 'compat'. Otherwise, it return "n" . 611 """ 612 if doc_mode or edt is None: 613 return "n" 614 615 node = edt.label2node.get(label) 616 617 if node and compat in node.compats: 618 return "y" 619 620 return "n" 621 622def dt_node_has_compat(kconf, _, path, compat): 623 """ 624 This function takes a 'path' and looks for an EDT node at that path. If it 625 finds an EDT node, it returns "y" if this node is compatible with 626 the provided 'compat'. Otherwise, it return "n" . 627 """ 628 629 if doc_mode or edt is None: 630 return "n" 631 632 try: 633 node = edt.get_node(path) 634 except edtlib.EDTError: 635 return "n" 636 637 if node and compat in node.compats: 638 return "y" 639 640 return "n" 641 642def dt_nodelabel_enabled_with_compat(kconf, _, label, compat): 643 """ 644 This function takes a 'label' and returns "y" if an "enabled" node with 645 such label can be found in the EDT and that node is compatible with the 646 provided 'compat', otherwise it returns "n". 647 """ 648 if doc_mode or edt is None: 649 return "n" 650 651 if compat in edt.compat2okay: 652 for node in edt.compat2okay[compat]: 653 if label in node.labels: 654 return "y" 655 656 return "n" 657 658 659def dt_nodelabel_array_prop_has_val(kconf, _, label, prop, val): 660 """ 661 This function looks for a node with node label 'label'. 662 If the node exists, it checks if the node node has a property 663 'prop' with type "array". If so, and the property contains 664 an element equal to the integer 'val', it returns "y". 665 Otherwise, it returns "n". 666 """ 667 if doc_mode or edt is None: 668 return "n" 669 670 node = edt.label2node.get(label) 671 672 if not node or (prop not in node.props) or (node.props[prop].type != "array"): 673 return "n" 674 else: 675 return "y" if int(val, base=0) in node.props[prop].val else "n" 676 677 678def dt_nodelabel_path(kconf, _, label): 679 """ 680 This function takes a node label (not a label property) and 681 returns the path to the node which has that label, or an empty 682 string if there is no such node. 683 """ 684 if doc_mode or edt is None: 685 return "" 686 687 node = edt.label2node.get(label) 688 689 return node.path if node else "" 690 691def dt_node_parent(kconf, _, path): 692 """ 693 This function takes a 'path' and looks for an EDT node at that path. If it 694 finds an EDT node, it will look for the parent of that node. If the parent 695 exists, it will return the path to that parent. Otherwise, an empty string 696 will be returned. 697 """ 698 if doc_mode or edt is None: 699 return "" 700 701 try: 702 node = edt.get_node(path) 703 except edtlib.EDTError: 704 return "" 705 706 if node is None: 707 return "" 708 709 return node.parent.path if node.parent else "" 710 711def dt_gpio_hogs_enabled(kconf, _): 712 """ 713 Return "y" if any GPIO hog node is enabled. Otherwise, return "n". 714 """ 715 if doc_mode or edt is None: 716 return "n" 717 718 for node in edt.nodes: 719 if node.gpio_hogs and node.status == "okay": 720 return "y" 721 722 return "n" 723 724def shields_list_contains(kconf, _, shield): 725 """ 726 Return "n" if cmake environment variable 'SHIELD_AS_LIST' doesn't exist. 727 Return "y" if 'shield' is present list obtained after 'SHIELD_AS_LIST' 728 has been split using ";" as a separator and "n" otherwise. 729 """ 730 try: 731 list = os.environ['SHIELD_AS_LIST'] 732 except KeyError: 733 return "n" 734 735 return "y" if shield in list.split(";") else "n" 736 737 738# Keys in this dict are the function names as they appear 739# in Kconfig files. The values are tuples in this form: 740# 741# (python_function, minimum_number_of_args, maximum_number_of_args) 742# 743# Each python function is given a kconf object and its name in the 744# Kconfig file, followed by arguments from the Kconfig file. 745# 746# See the kconfiglib documentation for more details. 747functions = { 748 "dt_has_compat": (dt_has_compat, 1, 1), 749 "dt_compat_enabled": (dt_compat_enabled, 1, 1), 750 "dt_compat_on_bus": (dt_compat_on_bus, 2, 2), 751 "dt_chosen_label": (dt_chosen_label, 1, 1), 752 "dt_chosen_enabled": (dt_chosen_enabled, 1, 1), 753 "dt_chosen_path": (dt_chosen_path, 1, 1), 754 "dt_chosen_has_compat": (dt_chosen_has_compat, 2, 2), 755 "dt_path_enabled": (dt_node_enabled, 1, 1), 756 "dt_alias_enabled": (dt_node_enabled, 1, 1), 757 "dt_nodelabel_enabled": (dt_nodelabel_enabled, 1, 1), 758 "dt_nodelabel_enabled_with_compat": (dt_nodelabel_enabled_with_compat, 2, 2), 759 "dt_chosen_reg_addr_int": (dt_chosen_reg, 1, 3), 760 "dt_chosen_reg_addr_hex": (dt_chosen_reg, 1, 3), 761 "dt_chosen_reg_size_int": (dt_chosen_reg, 1, 3), 762 "dt_chosen_reg_size_hex": (dt_chosen_reg, 1, 3), 763 "dt_node_reg_addr_int": (dt_node_reg, 1, 3), 764 "dt_node_reg_addr_hex": (dt_node_reg, 1, 3), 765 "dt_node_reg_size_int": (dt_node_reg, 1, 3), 766 "dt_node_reg_size_hex": (dt_node_reg, 1, 3), 767 "dt_node_bool_prop": (dt_node_bool_prop, 2, 2), 768 "dt_nodelabel_bool_prop": (dt_nodelabel_bool_prop, 2, 2), 769 "dt_chosen_bool_prop": (dt_chosen_bool_prop, 2, 2), 770 "dt_node_has_prop": (dt_node_has_prop, 2, 2), 771 "dt_nodelabel_has_prop": (dt_nodelabel_has_prop, 2, 2), 772 "dt_node_int_prop_int": (dt_node_int_prop, 2, 3), 773 "dt_node_int_prop_hex": (dt_node_int_prop, 2, 3), 774 "dt_node_array_prop_int": (dt_node_array_prop, 3, 4), 775 "dt_node_array_prop_hex": (dt_node_array_prop, 3, 4), 776 "dt_node_str_prop_equals": (dt_node_str_prop_equals, 3, 3), 777 "dt_nodelabel_has_compat": (dt_nodelabel_has_compat, 2, 2), 778 "dt_node_has_compat": (dt_node_has_compat, 2, 2), 779 "dt_nodelabel_path": (dt_nodelabel_path, 1, 1), 780 "dt_node_parent": (dt_node_parent, 1, 1), 781 "dt_nodelabel_array_prop_has_val": (dt_nodelabel_array_prop_has_val, 3, 3), 782 "dt_gpio_hogs_enabled": (dt_gpio_hogs_enabled, 0, 0), 783 "shields_list_contains": (shields_list_contains, 1, 1), 784} 785
