hardware/utils/rule.py

40     def __init__(self, region: Region, kernel_name: str, page_bits: int, max_size: int, condition_macro: str = None, user_ok: bool = False):
41         self.macro = condition_macro
42         self.desc = region.owner.path
43         self.kernel_offset = -1
44         self.page_bits = page_bits
45         self.labels = {}  # dict of label => offset within region.
46         self.user_ok = user_ok
50         self.size = aligned.size
51         self.base = aligned.base
52         self.regions = aligned.make_chunks(1 << page_bits)
53         self.labels[kernel_name] = region.base - aligned.base
55     def has_macro(self):
57         return self.macro is not None
59     def take_labels(self, other_group: 'KernelRegionGroup'):
61         if self != other_group:
64             self.labels[k] = v
65         self.desc += ', ' + other_group.desc
67     def get_macro(self):
69         return get_macro_str(self.macro)
71     def get_endif(self):
73         return get_endif(self.macro)
75     def set_kernel_offset(self, offset):
78         self.kernel_offset = offset
79         return offset + self.size
81     def get_labelled_addresses(self):
84         for (k, v) in self.labels.items():
85             ret[v + self.kernel_offset] = k
88     def get_map_offset(self, reg):
90         index = self.regions.index(reg)
91         return self.kernel_offset + (index * (1 << self.page_bits))
93     def get_desc(self):
95         return self.desc
97     def __repr__(self):
98         return 'KernelRegion(reg={},labels={})'.format(self.regions, self.labels)
100     def __eq__(self, other):
101         return other.base == self.base and other.size == self.size
107     def __init__(self, label: str, irq: int, prio: int = 0, sel_macro: str = None, false_irq: int = -1, enable_macro: str = None, desc: str = None):
108         self.label = label
109         self.irq = irq
110         self.prio = prio
111         self.sel_macro = sel_macro
112         self.false_irq = false_irq
113         self.enable_macro = enable_macro
114         self.desc = desc
116     def get_enable_macro_str(self):
118         return get_macro_str(self.enable_macro)
120     def has_enable(self):
122         return self.enable_macro is not None
124     def get_enable_endif(self):
126         return get_endif(self.enable_macro)
128     def get_sel_macro_str(self):
130         return get_macro_str(self.sel_macro)
132     def has_sel(self):
134         return self.sel_macro is not None
136     def get_sel_endif(self):
138         return get_endif(self.sel_macro)
140     def __repr__(self):
141         return 'KernelInterrupt(label={},irq={},sel_macro={},false_irq={})'.format(self.label, self.irq, self.sel_macro, self.false_irq)
147     def __init__(self, rule: dict, config: Config):
148         self.rule = rule
149         self.regions: Dict[int, Dict] = {}
150         self.interrupts = rule.get('interrupts', {})
151         self.config = config
154             self.regions[reg['index']] = reg
157     def get_regions(self, node: WrappedNode) -> List[KernelRegionGroup]:
162         for (i, rule) in self.regions.items():
171             max_size = 1 << self.config.get_device_page_bits()
178                                          self.config.get_device_page_bits(), max_size, macro, user))
183     def get_interrupts(self, tree: FdtParser, node: WrappedNode) -> List[KernelInterrupt]:
188         for name, rule in self.interrupts.items():
218     def __init__(self, yaml: dict, config: Config):
219         self.rules = {}
223                 self.rules[compat] = rule
225     def get_rule(self, device: WrappedNode) -> DeviceRule:
232             if compat in self.rules:
233                 return self.rules[compat]
238     def get_matched_compatible(self, device: WrappedNode) -> str:
244             if compat in self.rules: