Lines Matching +full:1 +full:- +full:a
1 # Copyright (c) 2018-2019 Linaro
4 # SPDX-License-Identifier: Apache-2.0
17 "python-devicetree", "src"))
22 doc_mode = os.environ.get('KCONFIG_DOC_MODE') == "1"
27 # The "if" handles a missing dts.
60 This function takes a 'chosen' property and treats that property as a path
62 has a "label" property and return the value of that "label". If not, we
80 This function returns "y" if /chosen contains a property named 'chosen'
92 This function takes a /chosen node property and returns the path
104 This function takes a /chosen node property and returns 'y' if the
122 This function is used to test if a node is enabled (has status
125 The 'node' argument is a string which is either a path or an
128 If 'name' is 'dt_path_enabled', 'node' is an alias or a path. If
155 should be a node label, like "foo" is here:
157 foo: some-node { ... };
201 This function takes a 'node' and will look to see if that 'node' has a
203 the value of the property 'prop' as either a string int or string hex
208 'k' or 'K' divide by 1024 (1 << 10)
209 'm' or 'M' divide by 1,048,576 (1 << 20)
210 'g' or 'G' divide by 1,073,741,824 (1 << 30)
211 'kb' or 'Kb' divide by 8192 (1 << 13)
212 'mb' or 'Mb' divide by 8,388,608 (1 << 23)
213 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33)
229 This function takes a 'node' and will look to see if that 'node' has a
231 the value of the property 'prop' at the given 'index' as either a string int
237 'k' or 'K' divide by 1024 (1 << 10)
238 'm' or 'M' divide by 1,048,576 (1 << 20)
239 'g' or 'G' divide by 1,073,741,824 (1 << 30)
254 This function takes a 'node', a property name ('prop'), index ('index') and
255 a cell ('cell') and it will look to see if that node has a property
256 called 'prop' and if that 'prop' is an phandle-array type.
257 Then it will check if that phandle array has a cell matching the given index
263 'k' or 'K' divide by 1024 (1 << 10)
264 'm' or 'M' divide by 1,048,576 (1 << 20)
265 'g' or 'G' divide by 1,073,741,824 (1 << 30)
272 if node.props[prop].type != "phandle-array":
282 This function takes a 'chosen' property and treats that property as a path
284 node has a register at the given 'index' and return the address value of
289 'k' or 'K' divide by 1024 (1 << 10)
290 'm' or 'M' divide by 1,048,576 (1 << 20)
291 'g' or 'G' divide by 1,073,741,824 (1 << 30)
292 'kb' or 'Kb' divide by 8192 (1 << 13)
293 'mb' or 'Mb' divide by 8,388,608 (1 << 23)
294 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33)
306 This function takes a 'chosen' property and treats that property as a path
308 has a register at the given 'index' and return the size value of that reg,
313 'k' or 'K' divide by 1024 (1 << 10)
314 'm' or 'M' divide by 1,048,576 (1 << 20)
315 'g' or 'G' divide by 1,073,741,824 (1 << 30)
316 'kb' or 'Kb' divide by 8192 (1 << 13)
317 'mb' or 'Mb' divide by 8,388,608 (1 << 23)
318 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33)
331 the result to either a string int or string hex value.
345 This function takes a 'chosen' property and treats that property as a path
347 node has a register, and if that node has a grandparent that has a register
353 'k' or 'K' divide by 1024 (1 << 10)
354 'm' or 'M' divide by 1,048,576 (1 << 20)
355 'g' or 'G' divide by 1,073,741,824 (1 << 30)
356 'kb' or 'Kb' divide by 8192 (1 << 13)
357 'mb' or 'Mb' divide by 8,388,608 (1 << 23)
358 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33)
377 the result to either a string int or string hex value.
387 This function takes a 'path' and looks for an EDT node at that path. If it
388 finds an EDT node, it will look to see if that node has a register at the
393 'k' or 'K' divide by 1024 (1 << 10)
394 'm' or 'M' divide by 1,048,576 (1 << 20)
395 'g' or 'G' divide by 1,073,741,824 (1 << 30)
396 'kb' or 'Kb' divide by 8192 (1 << 13)
397 'mb' or 'Mb' divide by 8,388,608 (1 << 23)
398 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33)
413 This function takes a 'path' and looks for an EDT node at that path. If it
414 finds an EDT node, it will look to see if that node has a register at the
419 'k' or 'K' divide by 1024 (1 << 10)
420 'm' or 'M' divide by 1,048,576 (1 << 20)
421 'g' or 'G' divide by 1,073,741,824 (1 << 30)
422 'kb' or 'Kb' divide by 8192 (1 << 13)
423 'mb' or 'Mb' divide by 8,388,608 (1 << 23)
424 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33)
440 the result to either a string int or string hex value.
454 should be a node label, like "foo" is here:
456 foo: some-node { ... };
476 a node with 'search_arg' and if node exists, checks if 'prop' exists
477 inside the node and is a boolean, if it is true, returns "y".
501 This function takes a 'path' and looks for an EDT node at that path. If it
502 finds an EDT node, it will look to see if that node has a boolean property
513 This function takes a 'label' and looks for an EDT node with that label.
514 If it finds an EDT node, it will look to see if that node has a boolean
525 This function takes a /chosen node property named 'chosen', and
526 looks for the chosen node. If that node exists and has a boolean
537 a node with 'search_arg' and if node exists, then checks if 'prop'
555 This function takes a 'path' and looks for an EDT node at that path. If it
556 finds an EDT node, it will look to see if that node has a property
567 This function takes a 'label' and looks for an EDT node with that label.
568 If it finds an EDT node, it will look to see if that node has a property
579 This function takes a 'path' and property name ('prop') looks for an EDT
581 node has a property called 'prop' and if that 'prop' is an integer type
582 will return the value of the property 'prop' as either a string int or
587 'k' or 'K' divide by 1024 (1 << 10)
588 'm' or 'M' divide by 1,048,576 (1 << 20)
589 'g' or 'G' divide by 1,073,741,824 (1 << 30)
590 'kb' or 'Kb' divide by 8192 (1 << 13)
591 'mb' or 'Mb' divide by 8,388,608 (1 << 23)
592 'gb' or 'Gb' divide by 8,589,934,592 (1 << 33)
610 This function takes a 'path', property name ('prop') and index ('index')
612 look to see if that node has a property called 'prop' and if that 'prop'
614 'index' as either a string int or string hex value. If not found we return 0.
618 'k' or 'K' divide by 1024 (1 << 10)
619 'm' or 'M' divide by 1,048,576 (1 << 20)
620 'g' or 'G' divide by 1,073,741,824 (1 << 30)
637 This function takes a 'path', property name ('prop'), index ('index') and
638 a cell ('cell') and looks for an EDT node at that path.
639 If it finds an EDT node, it will look to see if that node has a property
640 called 'prop' and if that 'prop' is an phandle-array type.
641 Then it will check if that phandle array has a cell matching the given index
643 either a string int or string hex value. If not found we return 0.
647 'k' or 'K' divide by 1024 (1 << 10)
648 'm' or 'M' divide by 1,048,576 (1 << 20)
649 'g' or 'G' divide by 1,073,741,824 (1 << 30)
665 This function takes a 'path' and a property name ('prop') and
667 it will look to see if that node has a property called 'prop'
669 path to the pointed-to node, or an empty string if there is
691 This function takes a 'path' and property name ('prop') looks for an EDT
693 node has a property 'prop' of type string. If that 'prop' is equal to 'val'
719 This function takes a 'compat' and returns "y" if any compatible node
730 This function takes a 'compat' and returns "y" if we find a status "okay"
741 This function takes a 'compat' and returns "y" if we find an enabled
756 This function takes a 'compat', a 'prop', and a 'value'.
758 enabled node with compatible 'compat' also has a valid property 'prop'.
760 also has a valid property 'prop' with value 'value'.
777 This function takes a 'compat', and a 'prop'.
794 This function takes a 'label' and looks for an EDT node with that label.
810 This function takes a 'path' and looks for an EDT node at that path. If it
830 This function takes a 'label' and returns "y" if an enabled node with
847 This function looks for a node with node label 'label'.
848 If the node exists, it checks if the node node has a property
866 This function takes a node label (not a label property) and
879 This function takes a 'path' and looks for an EDT node at that path. If it
913 Normalize the string, so that the string only contains alpha-numeric
914 characters or underscores. All non-alpha-numeric characters are replaced
918 return re.sub(r'[^a-zA-Z0-9_]', '_', string).upper()
925 has been split using ";" as a separator and "n" otherwise.
937 Extracts a portion of the string, removing characters from the front, back or both.
951 if there is only one argument, it will be split with a comma and processed
952 as a sequence of numbers.
956 $(add, 10, 3) # -> 13
957 $(add, 10, 3, 2) # -> 15
958 $(sub, 10, 3) # -> 7
959 $(sub, 10, 3, 2) # -> 5
960 $(mul, 10, 3) # -> 30
961 $(mul, 10, 3, 2) # -> 60
962 $(div, 10, 3) # -> 3
963 $(div, 10, 3, 2) # -> 1
964 $(mod, 10, 3) # -> 1
965 $(mod, 10, 3, 2) # -> 1
966 $(inc, 1) # -> 2
967 $(inc, 1, 1) # -> "2,2"
968 $(inc, $(inc, 1, 1)) # -> "3,3"
969 $(dec, 1) # -> 0
970 $(dec, 1, 1) # -> "0,0"
971 $(dec, $(dec, 1, 1)) # -> "-1,-1"
972 $(add, $(inc, 1, 1)) # -> 4
973 $(div, $(dec, 1, 1)) # Error (0 div 0)
976 intarray = map(int, args if len(args) > 1 else args[0].split(","))
999 Returns a string that concatenates numbers with a comma as a separator.
1002 intarray = map(int, args if len(args) > 1 else args[0].split(","))
1005 return ",".join(map(lambda a: str(a + 1), intarray))
1007 return ",".join(map(lambda a: str(a - 1), intarray))
1017 # Each python function is given a kconf object and its name in the
1022 "dt_has_compat": (dt_has_compat, 1, 1),
1023 "dt_compat_enabled": (dt_compat_enabled, 1, 1),
1027 "dt_chosen_label": (dt_chosen_label, 1, 1),
1028 "dt_chosen_enabled": (dt_chosen_enabled, 1, 1),
1029 "dt_chosen_path": (dt_chosen_path, 1, 1),
1031 "dt_path_enabled": (dt_node_enabled, 1, 1),
1032 "dt_alias_enabled": (dt_node_enabled, 1, 1),
1033 "dt_nodelabel_enabled": (dt_nodelabel_enabled, 1, 1),
1035 "dt_chosen_reg_addr_int": (dt_chosen_reg, 1, 3),
1036 "dt_chosen_reg_addr_hex": (dt_chosen_reg, 1, 3),
1037 "dt_chosen_reg_size_int": (dt_chosen_reg, 1, 3),
1038 "dt_chosen_reg_size_hex": (dt_chosen_reg, 1, 3),
1039 "dt_node_reg_addr_int": (dt_node_reg, 1, 3),
1040 "dt_node_reg_addr_hex": (dt_node_reg, 1, 3),
1041 "dt_node_reg_size_int": (dt_node_reg, 1, 3),
1042 "dt_node_reg_size_hex": (dt_node_reg, 1, 3),
1043 "dt_nodelabel_reg_addr_int": (dt_nodelabel_reg, 1, 3),
1044 "dt_nodelabel_reg_addr_hex": (dt_nodelabel_reg, 1, 3),
1045 "dt_nodelabel_reg_size_int": (dt_nodelabel_reg, 1, 3),
1046 "dt_nodelabel_reg_size_hex": (dt_nodelabel_reg, 1, 3),
1062 "dt_nodelabel_path": (dt_nodelabel_path, 1, 1),
1063 "dt_node_parent": (dt_node_parent, 1, 1),
1066 "dt_chosen_partition_addr_int": (dt_chosen_partition_addr, 1, 3),
1067 "dt_chosen_partition_addr_hex": (dt_chosen_partition_addr, 1, 3),
1068 "normalize_upper": (normalize_upper, 1, 1),
1069 "shields_list_contains": (shields_list_contains, 1, 1),
1071 "add": (arith, 1, 255),
1072 "sub": (arith, 1, 255),
1073 "mul": (arith, 1, 255),
1074 "div": (arith, 1, 255),
1075 "mod": (arith, 1, 255),
1076 "max": (arith, 1, 255),
1077 "min": (arith, 1, 255),
1078 "inc": (inc_dec, 1, 255),
1079 "dec": (inc_dec, 1, 255),