tools/hardware/device.py

21     def __init__(self, node: pyfdt.pyfdt.FdtNode, parent: 'WrappedNode', path: str):
22         self.node = node
23         self.parent = parent
24         self.depth = 0
25         self.path = path
26         self.children: Dict[str, 'WrappedNode'] = OrderedDict()
27         self.props: Dict[str, pyfdt.pyfdt.FdtProperty] = {}
31             self.props[prop.get_name()] = prop
34             parent.add_child(self)
35             self.depth = parent.depth + 1
36             self.is_cpu_addressable: bool = parent.is_cpu_addressable and \
37                 'ranges' in self.props
39             self.is_cpu_addressable = True  # root node is always cpu addressable
41     def add_child(self, child: 'WrappedNode'):
43         self.children[child.node.get_name()] = child
45     def get_prop(self, name: str) -> pyfdt.pyfdt.FdtProperty:
47         return self.props[name]
49     def has_prop(self, name: str) -> bool:
51         return name in self.props
53     def get_phandle(self) -> int:
55         if 'phandle' not in self.props:
58         return self.props['phandle'].words[0]
60     def get_interrupt_parent(self) -> int:
62         if 'interrupt-parent' not in self.props:
63             return self.parent.get_interrupt_parent()
64         return self.props['interrupt-parent'].words[0]
66     def is_mmio_device(self) -> bool:
68         return self.is_cpu_addressable
70     def recursive_get_addr_cells(self) -> int:
75         if '#address-cells' in self.props:
76             return self.props['#address-cells'].words[0]
77         if self.parent is None:
80         return self.parent.recursive_get_addr_cells()
82     def get_addr_cells(self) -> int:
85         if '#address-cells' in self.props:
86             return self.props['#address-cells'].words[0]
91     def get_size_cells(self) -> int:
94         if '#size-cells' in self.props:
95             return self.props['#size-cells'].words[0]
100     def get_regions(self) -> List[Region]:
101         if 'reg' not in self.props:
105         prop = list(self.props['reg'].words)
106         sizes = (self.parent.get_addr_cells(), self.parent.get_size_cells())
108             reg.append(Region(self.parent._translate_child_address(r[0]), r[1], self))
111     def parse_address(self, array) -> int:
113         size = self.parent.get_addr_cells()
116     def get_interrupts(self, tree: 'FdtParser') -> List[int]:
118         if 'interrupts-extended' in self.props:
119             data = list(self.props['interrupts-extended'].words)
123                 irqs.append(interrupt_parent.parse_irq(self, data))
124         elif 'interrupts' in self.props:
125             data = list(self.props['interrupts'].words)
126             interrupt_parent = tree.get_irq_controller(self.get_interrupt_parent())
128                 irqs.append(interrupt_parent.parse_irq(self, data))
131     def get_interrupt_affinities(self) -> List[int]:
132         if not self.has_prop('interrupt-affinity'):
134         return list(self.get_prop('interrupt-affinity').words)
136     def visit(self, visitor: Any):
138         ret = [visitor(self)]
141         for child in self.children.values():
145     def __iter__(self) -> Generator['WrappedNode', None, None]:
147         for child in self.children.values():
150     def _translate_child_address(self, addr: int) -> int:
154         if self.parent is None:
158         if 'ranges' not in self.props:
159             logging.warning('cannot translate address through node ' + self.path)
162         if not isinstance(self.props['ranges'], pyfdt.pyfdt.FdtPropertyWords):
163             return self.parent._translate_child_address(addr)
165         addr = Utils.translate_address(self, addr)
166         return self.parent._translate_child_address(addr)
168     def __hash__(self):
169         return hash(self.path)
184         # child-addr is self.get_addr_cells() long
185         # parent-addr is self.parent.get_addr_cells() long
186         # length is self.get_size_cells() long