Lines Matching +full:self +full:- +full:update
2 # SPDX-License-Identifier: GPL-2.0+
17 # contains the base classes and defines the high-level API. You can use
40 def __init__(self, node, offset, name, bytes): argument
41 self._node = node
42 self._offset = offset
43 self.name = name
44 self.value = None
45 self.bytes = str(bytes)
46 self.dirty = False
48 self.type = TYPE_BOOL
49 self.value = True
51 self.type, self.value = self.BytesToValue(bytes)
53 def RefreshOffset(self, poffset): argument
54 self._offset = poffset
56 def Widen(self, newprop): argument
76 update the current property to be like the second, since it is less
79 if newprop.type < self.type:
80 self.type = newprop.type
82 if type(newprop.value) == list and type(self.value) != list:
83 self.value = [self.value]
85 if type(self.value) == list and len(newprop.value) > len(self.value):
86 val = self.GetEmpty(self.type)
87 while len(self.value) < len(newprop.value):
88 self.value.append(val)
90 def BytesToValue(self, bytes): argument
102 TYPE_INT: a byte-swapped integer stored as a 4-byte string
103 TYPE_BYTE: a byte stored as a single-byte string
109 count = len(strings) - 1
110 if count > 0 and not strings[-1]:
111 for string in strings[:-1]:
125 return TYPE_STRING, strings[:-1]
140 def GetEmpty(self, type): argument
155 def GetOffset(self): argument
161 self._node._fdt.CheckCache()
162 return self._node._fdt.GetStructOffset(self._offset)
164 def SetInt(self, val): argument
171 val: Integer value (32-bit, single cell)
173 self.bytes = struct.pack('>I', val);
174 self.value = self.bytes
175 self.type = TYPE_INT
176 self.dirty = True
178 def SetData(self, bytes): argument
184 self.bytes = str(bytes)
185 self.type, self.value = self.BytesToValue(bytes)
186 self.dirty = True
188 def Sync(self, auto_resize=False): argument
196 have enough space for the update
201 if self._offset is None or self.dirty:
202 node = self._node
205 while fdt_obj.setprop(node.Offset(), self.name, self.bytes,
206 (libfdt.NOSPACE,)) == -libfdt.NOSPACE:
208 fdt_obj.setprop(node.Offset(), self.name, self.bytes)
210 fdt_obj.setprop(node.Offset(), self.name, self.bytes)
225 def __init__(self, fdt, parent, offset, name, path): argument
226 self._fdt = fdt
227 self.parent = parent
228 self._offset = offset
229 self.name = name
230 self.path = path
231 self.subnodes = []
232 self.props = {}
234 def GetFdt(self): argument
240 return self._fdt
242 def FindNode(self, name): argument
250 for subnode in self.subnodes:
255 def Offset(self): argument
258 This should be used instead of self._offset directly, to ensure that
261 self._fdt.CheckCache()
262 return self._offset
264 def Scan(self): argument
270 fdt_obj = self._fdt._fdt_obj
271 self.props = self._fdt.GetProps(self)
272 phandle = fdt_obj.get_phandle(self.Offset())
274 self._fdt.phandle_to_node[phandle] = self
276 offset = fdt_obj.first_subnode(self.Offset(), QUIET_NOTFOUND)
278 sep = '' if self.path[-1] == '/' else '/'
280 path = self.path + sep + name
281 node = Node(self._fdt, self, offset, name, path)
282 self.subnodes.append(node)
287 def Refresh(self, my_offset): argument
290 Note: This does not take account of property offsets - these will not
293 fdt_obj = self._fdt._fdt_obj
294 if self._offset != my_offset:
295 self._offset = my_offset
296 offset = fdt_obj.first_subnode(self._offset, QUIET_NOTFOUND)
297 for subnode in self.subnodes:
303 if offset != -libfdt.FDT_ERR_NOTFOUND:
306 poffset = fdt_obj.first_property_offset(self._offset, QUIET_NOTFOUND)
309 prop = self.props.get(p.name)
316 def DeleteProp(self, prop_name): argument
326 CheckErr(self._fdt._fdt_obj.delprop(self.Offset(), prop_name),
327 "Node '%s': delete property: '%s'" % (self.path, prop_name))
328 del self.props[prop_name]
329 self._fdt.Invalidate()
331 def AddZeroProp(self, prop_name): argument
337 self.props[prop_name] = Prop(self, None, prop_name, '\0' * 4)
339 def AddEmptyProp(self, prop_name, len): argument
350 self.props[prop_name] = Prop(self, None, prop_name, value)
352 def SetInt(self, prop_name, val): argument
353 """Update an integer property int the device tree.
364 self.props[prop_name].SetInt(val)
366 def SetData(self, prop_name, val): argument
376 self.props[prop_name].SetData(val)
378 def SetString(self, prop_name, val): argument
386 val: String value to set (will be \0-terminated in DT)
388 self.props[prop_name].SetData(val + chr(0))
390 def AddString(self, prop_name, val): argument
400 self.props[prop_name] = Prop(self, None, prop_name, val + chr(0))
402 def AddSubnode(self, name): argument
411 path = self.path + '/' + name
412 subnode = Node(self._fdt, self, None, name, path)
413 self.subnodes.append(subnode)
416 def Sync(self, auto_resize=False): argument
424 have enough space for the update
429 if self._offset is None:
431 fdt_obj = self._fdt._fdt_obj
434 offset = fdt_obj.add_subnode(self.parent._offset, self.name,
436 if offset != -libfdt.NOSPACE:
440 offset = fdt_obj.add_subnode(self.parent._offset, self.name)
441 self._offset = offset
446 for node in reversed(self.subnodes):
452 prop_list = sorted(self.props.values(), key=lambda prop: prop._offset,
465 def __init__(self, fname): argument
466 self._fname = fname
467 self._cached_offsets = False
468 self.phandle_to_node = {}
469 if self._fname:
470 self._fname = fdt_util.EnsureCompiled(self._fname)
472 with open(self._fname) as fd:
473 self._fdt_obj = libfdt.Fdt(fd.read())
480 data: Device-tree data blob
489 def LookupPhandle(self, phandle): argument
498 return self.phandle_to_node.get(phandle)
500 def Scan(self, root='/'): argument
503 This fills in the self._root property
510 self._cached_offsets = True
511 self._root = self.Node(self, None, 0, '/', '/')
512 self._root.Scan()
514 def GetRoot(self): argument
520 return self._root
522 def GetNode(self, path): argument
526 path: Path to look up, e.g. '/microcode/update@0'
530 node = self._root
540 def Flush(self): argument
545 with open(self._fname, 'wb') as fd:
546 fd.write(self._fdt_obj.as_bytearray())
548 def Sync(self, auto_resize=False): argument
553 have enough space for the update
558 self._root.Sync(auto_resize)
559 self.Invalidate()
561 def Pack(self): argument
567 CheckErr(self._fdt_obj.pack(), 'pack')
568 self.Invalidate()
570 def GetContents(self): argument
576 return self._fdt_obj.as_bytearray()
578 def GetFdtObj(self): argument
584 return self._fdt_obj
586 def GetProps(self, node): argument
600 poffset = self._fdt_obj.first_property_offset(node._offset,
603 p = self._fdt_obj.get_property_by_offset(poffset)
607 poffset = self._fdt_obj.next_property_offset(poffset,
611 def Invalidate(self): argument
613 self._cached_offsets = False
615 def CheckCache(self): argument
617 if self._cached_offsets:
619 self.Refresh()
620 self._cached_offsets = True
622 def Refresh(self): argument
624 self._root.Refresh(0)
626 def GetStructOffset(self, offset): argument
634 return self._fdt_obj.off_dt_struct() + offset
637 def Node(self, fdt, parent, offset, name, path): argument