1# SPDX-License-Identifier: GPL-2.0+ 2# Copyright (c) 2016 Google, Inc 3# 4# Base class for all entries 5# 6 7from __future__ import print_function 8 9# importlib was introduced in Python 2.7 but there was a report of it not 10# working in 2.7.12, so we work around this: 11# http://lists.denx.de/pipermail/u-boot/2016-October/269729.html 12try: 13 import importlib 14 have_importlib = True 15except: 16 have_importlib = False 17 18import fdt_util 19import os 20import sys 21import tools 22 23modules = {} 24 25our_path = os.path.dirname(os.path.realpath(__file__)) 26 27class Entry(object): 28 """An Entry in the section 29 30 An entry corresponds to a single node in the device-tree description 31 of the section. Each entry ends up being a part of the final section. 32 Entries can be placed either right next to each other, or with padding 33 between them. The type of the entry determines the data that is in it. 34 35 This class is not used by itself. All entry objects are subclasses of 36 Entry. 37 38 Attributes: 39 section: The section containing this entry 40 node: The node that created this entry 41 pos: Absolute position of entry within the section, None if not known 42 size: Entry size in bytes, None if not known 43 contents_size: Size of contents in bytes, 0 by default 44 align: Entry start position alignment, or None 45 align_size: Entry size alignment, or None 46 align_end: Entry end position alignment, or None 47 pad_before: Number of pad bytes before the contents, 0 if none 48 pad_after: Number of pad bytes after the contents, 0 if none 49 data: Contents of entry (string of bytes) 50 """ 51 def __init__(self, section, etype, node, read_node=True, name_prefix=''): 52 self.section = section 53 self.etype = etype 54 self._node = node 55 self.name = node and (name_prefix + node.name) or 'none' 56 self.pos = None 57 self.size = None 58 self.data = '' 59 self.contents_size = 0 60 self.align = None 61 self.align_size = None 62 self.align_end = None 63 self.pad_before = 0 64 self.pad_after = 0 65 self.pos_unset = False 66 if read_node: 67 self.ReadNode() 68 69 @staticmethod 70 def Create(section, node, etype=None): 71 """Create a new entry for a node. 72 73 Args: 74 section: Image object containing this node 75 node: Node object containing information about the entry to create 76 etype: Entry type to use, or None to work it out (used for tests) 77 78 Returns: 79 A new Entry object of the correct type (a subclass of Entry) 80 """ 81 if not etype: 82 etype = fdt_util.GetString(node, 'type', node.name) 83 84 # Convert something like 'u-boot@0' to 'u_boot' since we are only 85 # interested in the type. 86 module_name = etype.replace('-', '_') 87 if '@' in module_name: 88 module_name = module_name.split('@')[0] 89 module = modules.get(module_name) 90 91 # Also allow entry-type modules to be brought in from the etype directory. 92 93 # Import the module if we have not already done so. 94 if not module: 95 old_path = sys.path 96 sys.path.insert(0, os.path.join(our_path, 'etype')) 97 try: 98 if have_importlib: 99 module = importlib.import_module(module_name) 100 else: 101 module = __import__(module_name) 102 except ImportError: 103 raise ValueError("Unknown entry type '%s' in node '%s'" % 104 (etype, node.path)) 105 finally: 106 sys.path = old_path 107 modules[module_name] = module 108 109 # Call its constructor to get the object we want. 110 obj = getattr(module, 'Entry_%s' % module_name) 111 return obj(section, etype, node) 112 113 def ReadNode(self): 114 """Read entry information from the node 115 116 This reads all the fields we recognise from the node, ready for use. 117 """ 118 self.pos = fdt_util.GetInt(self._node, 'pos') 119 self.size = fdt_util.GetInt(self._node, 'size') 120 self.align = fdt_util.GetInt(self._node, 'align') 121 if tools.NotPowerOfTwo(self.align): 122 raise ValueError("Node '%s': Alignment %s must be a power of two" % 123 (self._node.path, self.align)) 124 self.pad_before = fdt_util.GetInt(self._node, 'pad-before', 0) 125 self.pad_after = fdt_util.GetInt(self._node, 'pad-after', 0) 126 self.align_size = fdt_util.GetInt(self._node, 'align-size') 127 if tools.NotPowerOfTwo(self.align_size): 128 raise ValueError("Node '%s': Alignment size %s must be a power " 129 "of two" % (self._node.path, self.align_size)) 130 self.align_end = fdt_util.GetInt(self._node, 'align-end') 131 self.pos_unset = fdt_util.GetBool(self._node, 'pos-unset') 132 133 def AddMissingProperties(self): 134 """Add new properties to the device tree as needed for this entry""" 135 for prop in ['pos', 'size']: 136 if not prop in self._node.props: 137 self._node.AddZeroProp(prop) 138 139 def SetCalculatedProperties(self): 140 """Set the value of device-tree properties calculated by binman""" 141 self._node.SetInt('pos', self.pos) 142 self._node.SetInt('size', self.size) 143 144 def ProcessFdt(self, fdt): 145 return True 146 147 def SetPrefix(self, prefix): 148 """Set the name prefix for a node 149 150 Args: 151 prefix: Prefix to set, or '' to not use a prefix 152 """ 153 if prefix: 154 self.name = prefix + self.name 155 156 def SetContents(self, data): 157 """Set the contents of an entry 158 159 This sets both the data and content_size properties 160 161 Args: 162 data: Data to set to the contents (string) 163 """ 164 self.data = data 165 self.contents_size = len(self.data) 166 167 def ProcessContentsUpdate(self, data): 168 """Update the contens of an entry, after the size is fixed 169 170 This checks that the new data is the same size as the old. 171 172 Args: 173 data: Data to set to the contents (string) 174 175 Raises: 176 ValueError if the new data size is not the same as the old 177 """ 178 if len(data) != self.contents_size: 179 self.Raise('Cannot update entry size from %d to %d' % 180 (len(data), self.contents_size)) 181 self.SetContents(data) 182 183 def ObtainContents(self): 184 """Figure out the contents of an entry. 185 186 Returns: 187 True if the contents were found, False if another call is needed 188 after the other entries are processed. 189 """ 190 # No contents by default: subclasses can implement this 191 return True 192 193 def Pack(self, pos): 194 """Figure out how to pack the entry into the section 195 196 Most of the time the entries are not fully specified. There may be 197 an alignment but no size. In that case we take the size from the 198 contents of the entry. 199 200 If an entry has no hard-coded position, it will be placed at @pos. 201 202 Once this function is complete, both the position and size of the 203 entry will be know. 204 205 Args: 206 Current section position pointer 207 208 Returns: 209 New section position pointer (after this entry) 210 """ 211 if self.pos is None: 212 if self.pos_unset: 213 self.Raise('No position set with pos-unset: should another ' 214 'entry provide this correct position?') 215 self.pos = tools.Align(pos, self.align) 216 needed = self.pad_before + self.contents_size + self.pad_after 217 needed = tools.Align(needed, self.align_size) 218 size = self.size 219 if not size: 220 size = needed 221 new_pos = self.pos + size 222 aligned_pos = tools.Align(new_pos, self.align_end) 223 if aligned_pos != new_pos: 224 size = aligned_pos - self.pos 225 new_pos = aligned_pos 226 227 if not self.size: 228 self.size = size 229 230 if self.size < needed: 231 self.Raise("Entry contents size is %#x (%d) but entry size is " 232 "%#x (%d)" % (needed, needed, self.size, self.size)) 233 # Check that the alignment is correct. It could be wrong if the 234 # and pos or size values were provided (i.e. not calculated), but 235 # conflict with the provided alignment values 236 if self.size != tools.Align(self.size, self.align_size): 237 self.Raise("Size %#x (%d) does not match align-size %#x (%d)" % 238 (self.size, self.size, self.align_size, self.align_size)) 239 if self.pos != tools.Align(self.pos, self.align): 240 self.Raise("Position %#x (%d) does not match align %#x (%d)" % 241 (self.pos, self.pos, self.align, self.align)) 242 243 return new_pos 244 245 def Raise(self, msg): 246 """Convenience function to raise an error referencing a node""" 247 raise ValueError("Node '%s': %s" % (self._node.path, msg)) 248 249 def GetPath(self): 250 """Get the path of a node 251 252 Returns: 253 Full path of the node for this entry 254 """ 255 return self._node.path 256 257 def GetData(self): 258 return self.data 259 260 def GetPositions(self): 261 return {} 262 263 def SetPositionSize(self, pos, size): 264 self.pos = pos 265 self.size = size 266 267 def ProcessContents(self): 268 pass 269 270 def WriteSymbols(self, section): 271 """Write symbol values into binary files for access at run time 272 273 Args: 274 section: Section containing the entry 275 """ 276 pass 277 278 def CheckPosition(self): 279 """Check that the entry positions are correct 280 281 This is used for entries which have extra position requirements (other 282 than having to be fully inside their section). Sub-classes can implement 283 this function and raise if there is a problem. 284 """ 285 pass 286 287 def WriteMap(self, fd, indent): 288 """Write a map of the entry to a .map file 289 290 Args: 291 fd: File to write the map to 292 indent: Curent indent level of map (0=none, 1=one level, etc.) 293 """ 294 print('%s%08x %08x %s' % (' ' * indent, self.pos, self.size, 295 self.name), file=fd) 296