1#!/usr/bin/python 2# 3# Copyright (C) 2017 Google, Inc 4# Written by Simon Glass <sjg@chromium.org> 5# 6# SPDX-License-Identifier: GPL-2.0+ 7# 8 9"""Device tree to platform data class 10 11This supports converting device tree data to C structures definitions and 12static data. 13""" 14 15import collections 16import copy 17import sys 18 19import fdt 20import fdt_util 21 22# When we see these properties we ignore them - i.e. do not create a structure member 23PROP_IGNORE_LIST = [ 24 '#address-cells', 25 '#gpio-cells', 26 '#size-cells', 27 'compatible', 28 'linux,phandle', 29 "status", 30 'phandle', 31 'u-boot,dm-pre-reloc', 32 'u-boot,dm-tpl', 33 'u-boot,dm-spl', 34] 35 36# C type declarations for the tyues we support 37TYPE_NAMES = { 38 fdt.TYPE_INT: 'fdt32_t', 39 fdt.TYPE_BYTE: 'unsigned char', 40 fdt.TYPE_STRING: 'const char *', 41 fdt.TYPE_BOOL: 'bool', 42 fdt.TYPE_INT64: 'fdt64_t', 43} 44 45STRUCT_PREFIX = 'dtd_' 46VAL_PREFIX = 'dtv_' 47 48# This holds information about a property which includes phandles. 49# 50# max_args: integer: Maximum number or arguments that any phandle uses (int). 51# args: Number of args for each phandle in the property. The total number of 52# phandles is len(args). This is a list of integers. 53PhandleInfo = collections.namedtuple('PhandleInfo', ['max_args', 'args']) 54 55 56def conv_name_to_c(name): 57 """Convert a device-tree name to a C identifier 58 59 This uses multiple replace() calls instead of re.sub() since it is faster 60 (400ms for 1m calls versus 1000ms for the 're' version). 61 62 Args: 63 name: Name to convert 64 Return: 65 String containing the C version of this name 66 """ 67 new = name.replace('@', '_at_') 68 new = new.replace('-', '_') 69 new = new.replace(',', '_') 70 new = new.replace('.', '_') 71 return new 72 73def tab_to(num_tabs, line): 74 """Append tabs to a line of text to reach a tab stop. 75 76 Args: 77 num_tabs: Tab stop to obtain (0 = column 0, 1 = column 8, etc.) 78 line: Line of text to append to 79 80 Returns: 81 line with the correct number of tabs appeneded. If the line already 82 extends past that tab stop then a single space is appended. 83 """ 84 if len(line) >= num_tabs * 8: 85 return line + ' ' 86 return line + '\t' * (num_tabs - len(line) // 8) 87 88def get_value(ftype, value): 89 """Get a value as a C expression 90 91 For integers this returns a byte-swapped (little-endian) hex string 92 For bytes this returns a hex string, e.g. 0x12 93 For strings this returns a literal string enclosed in quotes 94 For booleans this return 'true' 95 96 Args: 97 type: Data type (fdt_util) 98 value: Data value, as a string of bytes 99 """ 100 if ftype == fdt.TYPE_INT: 101 return '%#x' % fdt_util.fdt32_to_cpu(value) 102 elif ftype == fdt.TYPE_BYTE: 103 return '%#x' % ord(value[0]) 104 elif ftype == fdt.TYPE_STRING: 105 return '"%s"' % value 106 elif ftype == fdt.TYPE_BOOL: 107 return 'true' 108 elif ftype == fdt.TYPE_INT64: 109 return '%#x' % value 110 111def get_compat_name(node): 112 """Get a node's first compatible string as a C identifier 113 114 Args: 115 node: Node object to check 116 Return: 117 Tuple: 118 C identifier for the first compatible string 119 List of C identifiers for all the other compatible strings 120 (possibly empty) 121 """ 122 compat = node.props['compatible'].value 123 aliases = [] 124 if isinstance(compat, list): 125 compat, aliases = compat[0], compat[1:] 126 return conv_name_to_c(compat), [conv_name_to_c(a) for a in aliases] 127 128 129class DtbPlatdata(object): 130 """Provide a means to convert device tree binary data to platform data 131 132 The output of this process is C structures which can be used in space- 133 constrained encvironments where the ~3KB code overhead of device tree 134 code is not affordable. 135 136 Properties: 137 _fdt: Fdt object, referencing the device tree 138 _dtb_fname: Filename of the input device tree binary file 139 _valid_nodes: A list of Node object with compatible strings 140 _include_disabled: true to include nodes marked status = "disabled" 141 _outfile: The current output file (sys.stdout or a real file) 142 _lines: Stashed list of output lines for outputting in the future 143 """ 144 def __init__(self, dtb_fname, include_disabled): 145 self._fdt = None 146 self._dtb_fname = dtb_fname 147 self._valid_nodes = None 148 self._include_disabled = include_disabled 149 self._outfile = None 150 self._lines = [] 151 self._aliases = {} 152 153 def setup_output(self, fname): 154 """Set up the output destination 155 156 Once this is done, future calls to self.out() will output to this 157 file. 158 159 Args: 160 fname: Filename to send output to, or '-' for stdout 161 """ 162 if fname == '-': 163 self._outfile = sys.stdout 164 else: 165 self._outfile = open(fname, 'w') 166 167 def out(self, line): 168 """Output a string to the output file 169 170 Args: 171 line: String to output 172 """ 173 self._outfile.write(line) 174 175 def buf(self, line): 176 """Buffer up a string to send later 177 178 Args: 179 line: String to add to our 'buffer' list 180 """ 181 self._lines.append(line) 182 183 def get_buf(self): 184 """Get the contents of the output buffer, and clear it 185 186 Returns: 187 The output buffer, which is then cleared for future use 188 """ 189 lines = self._lines 190 self._lines = [] 191 return lines 192 193 def get_phandle_argc(self, prop, node_name): 194 """Check if a node contains phandles 195 196 We have no reliable way of detecting whether a node uses a phandle 197 or not. As an interim measure, use a list of known property names. 198 199 Args: 200 prop: Prop object to check 201 Return: 202 Number of argument cells is this is a phandle, else None 203 """ 204 if prop.name in ['clocks']: 205 val = prop.value 206 if not isinstance(val, list): 207 val = [val] 208 i = 0 209 210 max_args = 0 211 args = [] 212 while i < len(val): 213 phandle = fdt_util.fdt32_to_cpu(val[i]) 214 target = self._fdt.phandle_to_node.get(phandle) 215 if not target: 216 raise ValueError("Cannot parse '%s' in node '%s'" % 217 (prop.name, node_name)) 218 prop_name = '#clock-cells' 219 cells = target.props.get(prop_name) 220 if not cells: 221 raise ValueError("Node '%s' has no '%s' property" % 222 (target.name, prop_name)) 223 num_args = fdt_util.fdt32_to_cpu(cells.value) 224 max_args = max(max_args, num_args) 225 args.append(num_args) 226 i += 1 + num_args 227 return PhandleInfo(max_args, args) 228 return None 229 230 def scan_dtb(self): 231 """Scan the device tree to obtain a tree of nodes and properties 232 233 Once this is done, self._fdt.GetRoot() can be called to obtain the 234 device tree root node, and progress from there. 235 """ 236 self._fdt = fdt.FdtScan(self._dtb_fname) 237 238 def scan_node(self, root): 239 """Scan a node and subnodes to build a tree of node and phandle info 240 241 This adds each node to self._valid_nodes. 242 243 Args: 244 root: Root node for scan 245 """ 246 for node in root.subnodes: 247 if 'compatible' in node.props: 248 status = node.props.get('status') 249 if (not self._include_disabled and not status or 250 status.value != 'disabled'): 251 self._valid_nodes.append(node) 252 253 # recurse to handle any subnodes 254 self.scan_node(node) 255 256 def scan_tree(self): 257 """Scan the device tree for useful information 258 259 This fills in the following properties: 260 _valid_nodes: A list of nodes we wish to consider include in the 261 platform data 262 """ 263 self._valid_nodes = [] 264 return self.scan_node(self._fdt.GetRoot()) 265 266 @staticmethod 267 def get_num_cells(node): 268 """Get the number of cells in addresses and sizes for this node 269 270 Args: 271 node: Node to check 272 273 Returns: 274 Tuple: 275 Number of address cells for this node 276 Number of size cells for this node 277 """ 278 parent = node.parent 279 na, ns = 2, 2 280 if parent: 281 na_prop = parent.props.get('#address-cells') 282 ns_prop = parent.props.get('#size-cells') 283 if na_prop: 284 na = fdt_util.fdt32_to_cpu(na_prop.value) 285 if ns_prop: 286 ns = fdt_util.fdt32_to_cpu(ns_prop.value) 287 return na, ns 288 289 def scan_reg_sizes(self): 290 """Scan for 64-bit 'reg' properties and update the values 291 292 This finds 'reg' properties with 64-bit data and converts the value to 293 an array of 64-values. This allows it to be output in a way that the 294 C code can read. 295 """ 296 for node in self._valid_nodes: 297 reg = node.props.get('reg') 298 if not reg: 299 continue 300 na, ns = self.get_num_cells(node) 301 total = na + ns 302 303 if reg.type != fdt.TYPE_INT: 304 raise ValueError("Node '%s' reg property is not an int") 305 if len(reg.value) % total: 306 raise ValueError("Node '%s' reg property has %d cells " 307 'which is not a multiple of na + ns = %d + %d)' % 308 (node.name, len(reg.value), na, ns)) 309 reg.na = na 310 reg.ns = ns 311 if na != 1 or ns != 1: 312 reg.type = fdt.TYPE_INT64 313 i = 0 314 new_value = [] 315 val = reg.value 316 if not isinstance(val, list): 317 val = [val] 318 while i < len(val): 319 addr = fdt_util.fdt_cells_to_cpu(val[i:], reg.na) 320 i += na 321 size = fdt_util.fdt_cells_to_cpu(val[i:], reg.ns) 322 i += ns 323 new_value += [addr, size] 324 reg.value = new_value 325 326 def scan_structs(self): 327 """Scan the device tree building up the C structures we will use. 328 329 Build a dict keyed by C struct name containing a dict of Prop 330 object for each struct field (keyed by property name). Where the 331 same struct appears multiple times, try to use the 'widest' 332 property, i.e. the one with a type which can express all others. 333 334 Once the widest property is determined, all other properties are 335 updated to match that width. 336 """ 337 structs = {} 338 for node in self._valid_nodes: 339 node_name, _ = get_compat_name(node) 340 fields = {} 341 342 # Get a list of all the valid properties in this node. 343 for name, prop in node.props.items(): 344 if name not in PROP_IGNORE_LIST and name[0] != '#': 345 fields[name] = copy.deepcopy(prop) 346 347 # If we've seen this node_name before, update the existing struct. 348 if node_name in structs: 349 struct = structs[node_name] 350 for name, prop in fields.items(): 351 oldprop = struct.get(name) 352 if oldprop: 353 oldprop.Widen(prop) 354 else: 355 struct[name] = prop 356 357 # Otherwise store this as a new struct. 358 else: 359 structs[node_name] = fields 360 361 upto = 0 362 for node in self._valid_nodes: 363 node_name, _ = get_compat_name(node) 364 struct = structs[node_name] 365 for name, prop in node.props.items(): 366 if name not in PROP_IGNORE_LIST and name[0] != '#': 367 prop.Widen(struct[name]) 368 upto += 1 369 370 struct_name, aliases = get_compat_name(node) 371 for alias in aliases: 372 self._aliases[alias] = struct_name 373 374 return structs 375 376 def scan_phandles(self): 377 """Figure out what phandles each node uses 378 379 We need to be careful when outputing nodes that use phandles since 380 they must come after the declaration of the phandles in the C file. 381 Otherwise we get a compiler error since the phandle struct is not yet 382 declared. 383 384 This function adds to each node a list of phandle nodes that the node 385 depends on. This allows us to output things in the right order. 386 """ 387 for node in self._valid_nodes: 388 node.phandles = set() 389 for pname, prop in node.props.items(): 390 if pname in PROP_IGNORE_LIST or pname[0] == '#': 391 continue 392 info = self.get_phandle_argc(prop, node.name) 393 if info: 394 if not isinstance(prop.value, list): 395 prop.value = [prop.value] 396 # Process the list as pairs of (phandle, id) 397 value_it = iter(prop.value) 398 for phandle_cell, _ in zip(value_it, value_it): 399 phandle = fdt_util.fdt32_to_cpu(phandle_cell) 400 target_node = self._fdt.phandle_to_node[phandle] 401 node.phandles.add(target_node) 402 403 404 def generate_structs(self, structs): 405 """Generate struct defintions for the platform data 406 407 This writes out the body of a header file consisting of structure 408 definitions for node in self._valid_nodes. See the documentation in 409 README.of-plat for more information. 410 """ 411 self.out('#include <stdbool.h>\n') 412 self.out('#include <libfdt.h>\n') 413 414 # Output the struct definition 415 for name in sorted(structs): 416 self.out('struct %s%s {\n' % (STRUCT_PREFIX, name)) 417 for pname in sorted(structs[name]): 418 prop = structs[name][pname] 419 info = self.get_phandle_argc(prop, structs[name]) 420 if info: 421 # For phandles, include a reference to the target 422 self.out('\t%s%s[%d]' % (tab_to(2, 'struct phandle_2_cell'), 423 conv_name_to_c(prop.name), 424 len(prop.value) / 2)) 425 else: 426 ptype = TYPE_NAMES[prop.type] 427 self.out('\t%s%s' % (tab_to(2, ptype), 428 conv_name_to_c(prop.name))) 429 if isinstance(prop.value, list): 430 self.out('[%d]' % len(prop.value)) 431 self.out(';\n') 432 self.out('};\n') 433 434 for alias, struct_name in self._aliases.iteritems(): 435 self.out('#define %s%s %s%s\n'% (STRUCT_PREFIX, alias, 436 STRUCT_PREFIX, struct_name)) 437 438 def output_node(self, node): 439 """Output the C code for a node 440 441 Args: 442 node: node to output 443 """ 444 struct_name, _ = get_compat_name(node) 445 var_name = conv_name_to_c(node.name) 446 self.buf('static struct %s%s %s%s = {\n' % 447 (STRUCT_PREFIX, struct_name, VAL_PREFIX, var_name)) 448 for pname, prop in node.props.items(): 449 if pname in PROP_IGNORE_LIST or pname[0] == '#': 450 continue 451 member_name = conv_name_to_c(prop.name) 452 self.buf('\t%s= ' % tab_to(3, '.' + member_name)) 453 454 # Special handling for lists 455 if isinstance(prop.value, list): 456 self.buf('{') 457 vals = [] 458 # For phandles, output a reference to the platform data 459 # of the target node. 460 info = self.get_phandle_argc(prop, node.name) 461 if info: 462 # Process the list as pairs of (phandle, id) 463 value_it = iter(prop.value) 464 for phandle_cell, id_cell in zip(value_it, value_it): 465 phandle = fdt_util.fdt32_to_cpu(phandle_cell) 466 id_num = fdt_util.fdt32_to_cpu(id_cell) 467 target_node = self._fdt.phandle_to_node[phandle] 468 name = conv_name_to_c(target_node.name) 469 vals.append('{&%s%s, %d}' % (VAL_PREFIX, name, id_num)) 470 else: 471 for val in prop.value: 472 vals.append(get_value(prop.type, val)) 473 474 # Put 8 values per line to avoid very long lines. 475 for i in xrange(0, len(vals), 8): 476 if i: 477 self.buf(',\n\t\t') 478 self.buf(', '.join(vals[i:i + 8])) 479 self.buf('}') 480 else: 481 self.buf(get_value(prop.type, prop.value)) 482 self.buf(',\n') 483 self.buf('};\n') 484 485 # Add a device declaration 486 self.buf('U_BOOT_DEVICE(%s) = {\n' % var_name) 487 self.buf('\t.name\t\t= "%s",\n' % struct_name) 488 self.buf('\t.platdata\t= &%s%s,\n' % (VAL_PREFIX, var_name)) 489 self.buf('\t.platdata_size\t= sizeof(%s%s),\n' % (VAL_PREFIX, var_name)) 490 self.buf('};\n') 491 self.buf('\n') 492 493 self.out(''.join(self.get_buf())) 494 495 def generate_tables(self): 496 """Generate device defintions for the platform data 497 498 This writes out C platform data initialisation data and 499 U_BOOT_DEVICE() declarations for each valid node. Where a node has 500 multiple compatible strings, a #define is used to make them equivalent. 501 502 See the documentation in doc/driver-model/of-plat.txt for more 503 information. 504 """ 505 self.out('#include <common.h>\n') 506 self.out('#include <dm.h>\n') 507 self.out('#include <dt-structs.h>\n') 508 self.out('\n') 509 nodes_to_output = list(self._valid_nodes) 510 511 # Keep outputing nodes until there is none left 512 while nodes_to_output: 513 node = nodes_to_output[0] 514 # Output all the node's dependencies first 515 for req_node in node.phandles: 516 if req_node in nodes_to_output: 517 self.output_node(req_node) 518 nodes_to_output.remove(req_node) 519 self.output_node(node) 520 nodes_to_output.remove(node) 521 522 523def run_steps(args, dtb_file, include_disabled, output): 524 """Run all the steps of the dtoc tool 525 526 Args: 527 args: List of non-option arguments provided to the problem 528 dtb_file: Filename of dtb file to process 529 include_disabled: True to include disabled nodes 530 output: Name of output file 531 """ 532 if not args: 533 raise ValueError('Please specify a command: struct, platdata') 534 535 plat = DtbPlatdata(dtb_file, include_disabled) 536 plat.scan_dtb() 537 plat.scan_tree() 538 plat.scan_reg_sizes() 539 plat.setup_output(output) 540 structs = plat.scan_structs() 541 plat.scan_phandles() 542 543 for cmd in args[0].split(','): 544 if cmd == 'struct': 545 plat.generate_structs(structs) 546 elif cmd == 'platdata': 547 plat.generate_tables() 548 else: 549 raise ValueError("Unknown command '%s': (use: struct, platdata)" % 550 cmd) 551