Lines Matching refs:self
52 def __init__(self, name):
54 self.name = name
55 if not FdtProperty.__validate_dt_name(self.name):
56 raise Exception("Invalid name '%s'" % self.name)
58 def get_name(self):
60 return self.name
62 def __str__(self):
64 return "Property(%s)" % self.name
66 def dts_represent(self, depth=0):
68 return INDENT*depth + self.name + ';'
70 def dtb_represent(self, string_store, pos=0, version=17):
72 # print "%x:%s" % (pos, self)
73 strpos = string_store.find(self.name+'\0')
76 string_store += self.name+'\0'
81 def json_represent(self, depth=0):
83 return '%s: null' % json.dumps(self.name)
85 def to_raw(self):
89 def __getitem__(self, value):
93 def __ne__(self, node):
96 return not self.__eq__(node)
98 def __eq__(self, node):
104 if self.name != node.get_name():
168 def __init__(self, name, strings):
170 FdtProperty.__init__(self, name)
180 self.strings = strings
187 def dts_represent(self, depth=0):
189 return INDENT*depth + self.name + ' = "' + \
190 '", "'.join(self.strings) + '";'
192 def dtb_represent(self, string_store, pos=0, version=17):
194 # print "%x:%s" % (pos, self)
196 for chars in self.strings:
203 strpos = string_store.find(self.name+'\0')
206 string_store += self.name+'\0'
211 def json_represent(self, depth=0):
213 result = '%s: ["strings", ' % json.dumps(self.name)
214 result += ', '.join([json.dumps(stri) for stri in self.strings])
218 def to_raw(self):
220 return ''.join([chars+'\0' for chars in self.strings])
222 def __str__(self):
224 return "Property(%s,Strings:%s)" % (self.name, self.strings)
226 def __getitem__(self, index):
228 return self.strings[index]
230 def __len__(self):
232 return len(self.strings)
234 def __eq__(self, node):
238 if not FdtProperty.__eq__(self, node):
240 if self.__len__() != len(node):
242 for index in range(self.__len__()):
243 if self.strings[index] != node[index]:
250 def __init__(self, name, words):
252 FdtProperty.__init__(self, name)
259 self.words = words
271 def dts_represent(self, depth=0):
273 return INDENT*depth + self.name + ' = <' + \
274 ' '.join(["0x%08x" % word for word in self.words]) + ">;"
276 def dtb_represent(self, string_store, pos=0, version=17):
278 # # print "%x:%s" % (pos, self)
279 strpos = string_store.find(self.name+'\0')
282 string_store += self.name+'\0'
283 blob = pack('>III', FDT_PROP, len(self.words)*4, strpos) + \
284 pack('').join([pack('>I', word) for word in self.words])
288 def json_represent(self, depth=0):
290 result = '%s: ["words", "' % json.dumps(self.name)
291 result += '", "'.join(["0x%08x" % word for word in self.words])
295 def to_raw(self):
297 return ''.join([pack('>I', word) for word in self.words])
299 def __str__(self):
301 return "Property(%s,Words:%s)" % (self.name, self.words)
303 def __getitem__(self, index):
305 return self.words[index]
307 def __len__(self):
309 return len(self.words)
311 def __eq__(self, node):
315 if not FdtProperty.__eq__(self, node):
317 if self.__len__() != len(node):
319 for index in range(self.__len__()):
320 if self.words[index] != node[index]:
328 def __init__(self, name, bytez):
330 FdtProperty.__init__(self, name)
337 self.bytes = bytez
344 def dts_represent(self, depth=0):
346 return INDENT*depth + self.name + ' = [' + \
348 for byte in self.bytes]) + "];"
350 def dtb_represent(self, string_store, pos=0, version=17):
352 # print "%x:%s" % (pos, self)
353 strpos = string_store.find(self.name+'\0')
356 string_store += self.name+'\0'
357 blob = pack('>III', FDT_PROP, len(self.bytes), strpos)
358 blob += pack('').join([pack('>b', byte) for byte in self.bytes])
364 def json_represent(self, depth=0):
366 result = '%s: ["bytes", "' % json.dumps(self.name)
368 for byte in self.bytes])
372 def to_raw(self):
374 return ''.join([pack('>b', byte) for byte in self.bytes])
376 def __str__(self):
378 return "Property(%s,Bytes:%s)" % (self.name, self.bytes)
380 def __getitem__(self, index):
382 return self.bytes[index]
384 def __len__(self):
386 return len(self.bytes)
388 def __eq__(self, node):
392 if not FdtProperty.__eq__(self, node):
394 if self.__len__() != len(node):
396 for index in range(self.__len__()):
397 if self.bytes[index] != node[index]:
405 def __init__(self):
408 def get_name(self): # pylint: disable-msg=R0201
412 def __str__(self):
416 def dts_represent(self, depth=0): # pylint: disable-msg=R0201
420 def dtb_represent(self, string_store, pos=0, version=17):
422 # print "%x:%s" % (pos, self)
436 def __init__(self, name):
438 self.name = name
439 self.subdata = []
440 self.parent = None
441 if not FdtNode.__validate_dt_name(self.name):
442 raise Exception("Invalid name '%s'" % self.name)
444 def get_name(self):
446 return self.name
448 def __check_name_duplicate(self, name):
450 for data in self.subdata:
456 def add_subnode(self, node):
458 self.append(node)
460 def add_raw_attribute(self, name, raw_value):
462 self.append(FdtProperty.new_raw_property(name, raw_value))
464 def set_parent_node(self, node):
469 self.parent = node
471 def get_parent_node(self):
473 return self.parent
475 def __str__(self):
477 return "Node(%s)" % self.name
479 def dts_represent(self, depth=0):
482 for sub in self.subdata])
485 return INDENT*depth + self.name + ' {\n' + \
488 def dtb_represent(self, strings_store, pos=0, version=17):
493 # print "%x:%s" % (pos, self)
495 if self.get_name() == '/':
499 blob += self.get_name().encode('ascii') + pack('b', 0)
503 for sub in self.subdata:
510 def json_represent(self, depth=0):
514 for sub in self.subdata
518 if self.get_name() == '/':
521 return json.dumps(self.name) + ': {\n' + \
524 def __getitem__(self, index):
526 return self.subdata[index]
528 def __setitem__(self, index, subnode):
532 if self.subdata[index].get_name() != subnode.get_name() and \
533 self.__check_name_duplicate(subnode.get_name()):
535 (self, subnode))
538 self.subdata[index] = subnode
540 def __len__(self):
542 return len(self.subdata)
544 def __ne__(self, node):
550 return not self.__eq__(node)
552 def __eq__(self, node):
560 if self.name != node.get_name():
562 curnames = set([subnode.get_name() for subnode in self.subdata
568 for subnode in [subnode for subnode in self.subdata
575 def append(self, subnode):
577 if self.__check_name_duplicate(subnode.get_name()):
579 (self, subnode))
582 self.subdata.append(subnode)
584 def pop(self, index=-1):
586 return self.subdata.pop(index)
588 def insert(self, index, subnode):
590 if self.__check_name_duplicate(subnode.get_name()):
592 (self, subnode))
595 self.subdata.insert(index, subnode)
597 def _find(self, name):
599 for i in range(0, len(self.subdata)):
600 if not isinstance(self.subdata[i], FdtNop) and \
601 name == self.subdata[i].get_name():
605 def remove(self, name):
609 index = self._find(name)
612 return self.subdata.pop(index)
614 def index(self, name):
618 index = self._find(name)
623 def merge(self, node):
631 index = self._find(subnode.get_name())
635 dup.set_parent_node(self)
636 self.append(dup)
638 self.subdata[index].merge(subnode)
640 self.subdata[index] = copy(subnode)
642 def walk(self):
646 node = self
675 def __init__(self, version=17, last_comp_version=16, boot_cpuid_phys=0):
677 self.header = {'magic': FDT_MAGIC,
687 self.rootnode = None
688 self.prenops = None
689 self.postnops = None
690 self.reserve_entries = None
692 def add_rootnode(self, rootnode, prenops=None, postnops=None):
694 self.rootnode = rootnode
695 self.prenops = prenops
696 self.postnops = postnops
698 def get_rootnode(self):
700 return self.rootnode
702 def add_reserve_entries(self, reserve_entries):
705 self.reserve_entries = reserve_entries
707 def to_dts(self):
710 result += "// version:\t\t%d\n" % self.header['version']
712 self.header['last_comp_version']
713 if self.header['version'] >= 2:
715 self.header['boot_cpuid_phys']
717 if self.reserve_entries is not None:
718 for entry in self.reserve_entries:
729 if self.prenops:
730 result += '\n'.join([nop.dts_represent() for nop in self.prenops])
732 if self.rootnode is not None:
733 result += self.rootnode.dts_represent()
734 if self.postnops:
736 result += '\n'.join([nop.dts_represent() for nop in self.postnops])
739 def to_dtb(self):
741 if self.rootnode is None:
744 if self.reserve_entries is not None:
745 for entry in self.reserve_entries:
751 if self.header['version'] >= 2:
753 if self.header['version'] >= 3:
755 if self.header['version'] >= 17:
764 self.rootnode.dtb_represent('', dt_start, self.header['version'])
765 if self.prenops is not None:
767 for nop in self.prenops])\
769 if self.postnops is not None:
771 for nop in self.postnops])
773 self.header['size_dt_strings'] = len(blob_strings)
774 self.header['size_dt_struct'] = len(blob_dt)
775 self.header['off_mem_rsvmap'] = header_size
776 self.header['off_dt_struct'] = dt_start
777 self.header['off_dt_strings'] = dt_start + len(blob_dt)
778 self.header['totalsize'] = dt_start + len(blob_dt) + len(blob_strings)
779 blob_header = pack('>IIIIIII', self.header['magic'],
780 self.header['totalsize'],
781 self.header['off_dt_struct'],
782 self.header['off_dt_strings'],
783 self.header['off_mem_rsvmap'],
784 self.header['version'],
785 self.header['last_comp_version'])
786 if self.header['version'] >= 2:
787 blob_header += pack('>I', self.header['boot_cpuid_phys'])
788 if self.header['version'] >= 3:
789 blob_header += pack('>I', self.header['size_dt_strings'])
790 if self.header['version'] >= 17:
791 blob_header += pack('>I', self.header['size_dt_struct'])
795 def to_json(self):
797 if self.rootnode is None:
799 return self.rootnode.json_represent()
801 def resolve_path(self, path):
804 if self.rootnode is None:
811 return self.rootnode
812 curnode = self.rootnode
918 def __extract_fdt_header(self):
920 header = Struct(self.__fdt_header_format)
922 data = self.infile.read(header.size)
923 result = dict(zip(self.__fdt_header_names, header.unpack_from(data)))
925 data = self.infile.read(header_entry.size)
928 data = self.infile.read(header_entry.size)
931 data = self.infile.read(header_entry.size)
935 def __extract_fdt_reserve_entries(self):
937 header = Struct(self.__fdt_reserve_entry_format)
939 self.infile.seek(self.fdt_header['off_mem_rsvmap'])
941 data = self.infile.read(header.size)
942 result = dict(zip(self.__fdt_reserve_entry_names,
948 def __extract_fdt_nodename(self):
951 pos = self.infile.tell()
953 byte = self.infile.read(1)
959 self.infile.seek(align_pos)
962 def __extract_fdt_string(self, prop_string_pos):
965 pos = self.infile.tell()
966 self.infile.seek(self.fdt_header['off_dt_strings']+prop_string_pos)
968 byte = self.infile.read(1)
972 self.infile.seek(pos)
975 def __extract_fdt_prop(self):
977 prop = Struct(self.__fdt_dt_prop_format)
978 pos = self.infile.tell()
979 data = self.infile.read(prop.size)
983 if self.fdt_header['version'] < 16 and prop_size >= 8:
986 self.infile.seek(prop_start)
987 value = self.infile.read(prop_size)
989 align_pos = self.infile.tell()
991 self.infile.seek(align_pos)
993 return (self.__extract_fdt_string(prop_string_pos), value)
995 def __extract_fdt_dt(self):
997 cell = Struct(self.__fdt_dt_cell_format)
999 self.infile.seek(self.fdt_header['off_dt_struct'])
1001 data = self.infile.read(cell.size)
1005 # print "*** %s" % self.__fdt_dt_tag_name.get(tag, '')
1006 if self.__fdt_dt_tag_name.get(tag, '') in 'node_begin':
1007 name = self.__extract_fdt_nodename()
1011 elif self.__fdt_dt_tag_name.get(tag, '') in ('node_end', 'nop'):
1013 elif self.__fdt_dt_tag_name.get(tag, '') in 'end':
1016 elif self.__fdt_dt_tag_name.get(tag, '') in 'prop':
1017 propdata = self.__extract_fdt_prop()
1023 def __init__(self, infile):
1025 self.infile = infile
1026 self.fdt_header = self.__extract_fdt_header()
1027 if self.fdt_header['magic'] != FDT_MAGIC:
1029 if self.fdt_header['version'] > FDT_MAX_VERSION:
1030 raise Exception('Invalid Version %d' % self.fdt_header['version'])
1031 if self.fdt_header['last_comp_version'] > FDT_MAX_VERSION-1:
1033 self.fdt_header['last_comp_version'])
1034 self.fdt_reserve_entries = self.__extract_fdt_reserve_entries()
1035 self.fdt_dt_tags = self.__extract_fdt_dt()
1037 def __to_nodes(self):
1046 for tag in self.fdt_dt_tags:
1047 if self.__fdt_dt_tag_name.get(tag[0], '') in 'node_begin':
1055 elif self.__fdt_dt_tag_name.get(tag[0], '') in 'node_end':
1058 elif self.__fdt_dt_tag_name.get(tag[0], '') in 'nop':
1065 elif self.__fdt_dt_tag_name.get(tag[0], '') in 'prop':
1068 elif self.__fdt_dt_tag_name.get(tag[0], '') in 'end':
1072 def to_fdt(self):
1076 if self.fdt_header['version'] >= 2:
1077 boot_cpuid_phys = self.fdt_header['boot_cpuid_phys']
1080 fdt = Fdt(version=self.fdt_header['version'],
1081 last_comp_version=self.fdt_header['last_comp_version'],
1083 (prenops, rootnode, postnops) = self.__to_nodes()
1085 fdt.add_reserve_entries(self.fdt_reserve_entries)