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.contents_size = 0 59 self.align = None 60 self.align_size = None 61 self.align_end = None 62 self.pad_before = 0 63 self.pad_after = 0 64 self.pos_unset = False 65 if read_node: 66 self.ReadNode() 67 68 @staticmethod 69 def Create(section, node, etype=None): 70 """Create a new entry for a node. 71 72 Args: 73 section: Image object containing this node 74 node: Node object containing information about the entry to create 75 etype: Entry type to use, or None to work it out (used for tests) 76 77 Returns: 78 A new Entry object of the correct type (a subclass of Entry) 79 """ 80 if not etype: 81 etype = fdt_util.GetString(node, 'type', node.name) 82 83 # Convert something like 'u-boot@0' to 'u_boot' since we are only 84 # interested in the type. 85 module_name = etype.replace('-', '_') 86 if '@' in module_name: 87 module_name = module_name.split('@')[0] 88 module = modules.get(module_name) 89 90 # Also allow entry-type modules to be brought in from the etype directory. 91 92 # Import the module if we have not already done so. 93 if not module: 94 old_path = sys.path 95 sys.path.insert(0, os.path.join(our_path, 'etype')) 96 try: 97 if have_importlib: 98 module = importlib.import_module(module_name) 99 else: 100 module = __import__(module_name) 101 except ImportError: 102 raise ValueError("Unknown entry type '%s' in node '%s'" % 103 (etype, node.path)) 104 finally: 105 sys.path = old_path 106 modules[module_name] = module 107 108 # Call its constructor to get the object we want. 109 obj = getattr(module, 'Entry_%s' % module_name) 110 return obj(section, etype, node) 111 112 def ReadNode(self): 113 """Read entry information from the node 114 115 This reads all the fields we recognise from the node, ready for use. 116 """ 117 self.pos = fdt_util.GetInt(self._node, 'pos') 118 self.size = fdt_util.GetInt(self._node, 'size') 119 self.align = fdt_util.GetInt(self._node, 'align') 120 if tools.NotPowerOfTwo(self.align): 121 raise ValueError("Node '%s': Alignment %s must be a power of two" % 122 (self._node.path, self.align)) 123 self.pad_before = fdt_util.GetInt(self._node, 'pad-before', 0) 124 self.pad_after = fdt_util.GetInt(self._node, 'pad-after', 0) 125 self.align_size = fdt_util.GetInt(self._node, 'align-size') 126 if tools.NotPowerOfTwo(self.align_size): 127 raise ValueError("Node '%s': Alignment size %s must be a power " 128 "of two" % (self._node.path, self.align_size)) 129 self.align_end = fdt_util.GetInt(self._node, 'align-end') 130 self.pos_unset = fdt_util.GetBool(self._node, 'pos-unset') 131 132 def SetPrefix(self, prefix): 133 """Set the name prefix for a node 134 135 Args: 136 prefix: Prefix to set, or '' to not use a prefix 137 """ 138 if prefix: 139 self.name = prefix + self.name 140 141 def ObtainContents(self): 142 """Figure out the contents of an entry. 143 144 Returns: 145 True if the contents were found, False if another call is needed 146 after the other entries are processed. 147 """ 148 # No contents by default: subclasses can implement this 149 return True 150 151 def Pack(self, pos): 152 """Figure out how to pack the entry into the section 153 154 Most of the time the entries are not fully specified. There may be 155 an alignment but no size. In that case we take the size from the 156 contents of the entry. 157 158 If an entry has no hard-coded position, it will be placed at @pos. 159 160 Once this function is complete, both the position and size of the 161 entry will be know. 162 163 Args: 164 Current section position pointer 165 166 Returns: 167 New section position pointer (after this entry) 168 """ 169 if self.pos is None: 170 if self.pos_unset: 171 self.Raise('No position set with pos-unset: should another ' 172 'entry provide this correct position?') 173 self.pos = tools.Align(pos, self.align) 174 needed = self.pad_before + self.contents_size + self.pad_after 175 needed = tools.Align(needed, self.align_size) 176 size = self.size 177 if not size: 178 size = needed 179 new_pos = self.pos + size 180 aligned_pos = tools.Align(new_pos, self.align_end) 181 if aligned_pos != new_pos: 182 size = aligned_pos - self.pos 183 new_pos = aligned_pos 184 185 if not self.size: 186 self.size = size 187 188 if self.size < needed: 189 self.Raise("Entry contents size is %#x (%d) but entry size is " 190 "%#x (%d)" % (needed, needed, self.size, self.size)) 191 # Check that the alignment is correct. It could be wrong if the 192 # and pos or size values were provided (i.e. not calculated), but 193 # conflict with the provided alignment values 194 if self.size != tools.Align(self.size, self.align_size): 195 self.Raise("Size %#x (%d) does not match align-size %#x (%d)" % 196 (self.size, self.size, self.align_size, self.align_size)) 197 if self.pos != tools.Align(self.pos, self.align): 198 self.Raise("Position %#x (%d) does not match align %#x (%d)" % 199 (self.pos, self.pos, self.align, self.align)) 200 201 return new_pos 202 203 def Raise(self, msg): 204 """Convenience function to raise an error referencing a node""" 205 raise ValueError("Node '%s': %s" % (self._node.path, msg)) 206 207 def GetPath(self): 208 """Get the path of a node 209 210 Returns: 211 Full path of the node for this entry 212 """ 213 return self._node.path 214 215 def GetData(self): 216 return self.data 217 218 def GetPositions(self): 219 return {} 220 221 def SetPositionSize(self, pos, size): 222 self.pos = pos 223 self.size = size 224 225 def ProcessContents(self): 226 pass 227 228 def WriteSymbols(self, section): 229 """Write symbol values into binary files for access at run time 230 231 Args: 232 section: Section containing the entry 233 """ 234 pass 235 236 def CheckPosition(self): 237 """Check that the entry positions are correct 238 239 This is used for entries which have extra position requirements (other 240 than having to be fully inside their section). Sub-classes can implement 241 this function and raise if there is a problem. 242 """ 243 pass 244 245 def WriteMap(self, fd, indent): 246 """Write a map of the entry to a .map file 247 248 Args: 249 fd: File to write the map to 250 indent: Curent indent level of map (0=none, 1=one level, etc.) 251 """ 252 print('%s%08x %08x %s' % (' ' * indent, self.pos, self.size, 253 self.name), file=fd) 254