17 	def __init__(self, message):  argument
18 		self.message = message
21 	def __init__(self, name):  argument
22 		self.name = name
23 		self.values = []
25 	def has_name(self, name):  argument
26 		for (n, value) in self.values:
31 	def names(self):  argument
32 		return [n for (n, value) in self.values]
34 	def dump(self):  argument
36 		for (name, value) in self.values:
40 		print("enum %s {" % self.name)
41 		for (name, value) in self.values:
48 	def dump_pack_struct(self):  argument
52 	def __init__(self, name, low, high, shr, type, parser):  argument
53 		self.name = name
54 		self.low = low
55 		self.high = high
56 		self.shr = shr
57 		self.type = type
69 		if self.type == "boolean" and not low == high:
71 		elif self.type == "float" and not (high - low == 31 or high - low == 15):
73 		elif not self.type in builtin_types and not self.type in parser.enums:
74 			raise parser.error("unknown type '%s'" % self.type)
76 	def ctype(self, var_name):  argument
77 		if self.type == None:
80 		elif self.type == "boolean":
83 		elif self.type == "uint" or self.type == "hex" or self.type == "a3xx_regid":
86 		elif self.type == "int":
89 		elif self.type == "fixed":
91 			val = "((int32_t)(%s * %d.0))" % (var_name, 1 << self.radix)
92 		elif self.type == "ufixed":
94 			val = "((uint32_t)(%s * %d.0))" % (var_name, 1 << self.radix)
95 		elif self.type == "float" and self.high - self.low == 31:
98 		elif self.type == "float" and self.high - self.low == 15:
101 		elif self.type in [ "address", "waddress" ]:
105 			type = "enum %s" % self.type
108 		if self.shr > 0:
109 			val = "(%s >> %d)" % (val, self.shr)
150 	def __init__(self, name, template):  argument
151 		self.name = name
152 		self.inline = False
154 			self.fields = template.fields[:]
156 			self.fields = []
159 	def get_address_field(self):  argument
160 		for f in self.fields:
165 	def dump_regpair_builder(self, reg):  argument
168 		for f in self.fields:
184 		for f in self.fields:
195 		address = self.get_address_field()
207 	def dump_pack_struct(self, reg=None):  argument
214 		for f in self.fields:
239 		self.dump_regpair_builder(reg)
243 		if self.get_address_field():
256 	def dump(self, prefix=None):  argument
258 			prefix = self.name
259 		for f in self.fields:
281 	def __init__(self, attrs, domain, variant, parent, index_type):  argument
283 			self.local_name = attrs["name"]
285 			self.local_name = ""
286 		self.domain = domain
287 		self.variant = variant
288 		self.parent = parent
289 		if self.parent:
290 			self.name = self.parent.name + "_" + self.local_name
292 			self.name = self.local_name
294 			self.offsets = map(lambda i: "0x%08x" % int(i, 0), attrs["offsets"].split(","))
295 			self.fixed_offsets = True
297 			self.offsets = map(lambda s: "(%s)" % s , attrs["doffsets"].split(","))
298 			self.fixed_offsets = True
300 			self.offset = int(attrs["offset"], 0)
301 			self.stride = int(attrs["stride"], 0)
302 			self.fixed_offsets = False
304 			self.index_type = index_type
306 			self.index_type = None
307 		self.length = int(attrs["length"], 0)
309 			self.usages = attrs["usage"].split(',')
311 			self.usages = None
313 	def index_ctype(self):  argument
314 		if not self.index_type:
317 			return "enum %s" % self.index_type.name
320 	def indices(self):  argument
321 		if self.parent:
322 			indices = self.parent.indices()
325 		if self.length != 1:
326 			if self.fixed_offsets:
327 				indices.append((self.index_ctype(), None, "__offset_%s" % self.local_name))
329 				indices.append((self.index_ctype(), self.stride, None))
332 	def total_offset(self):  argument
334 		if not self.fixed_offsets:
335 			offset += self.offset
336 		if self.parent:
337 			offset += self.parent.total_offset()
340 	def dump(self):  argument
341 		proto = indices_varlist(self.indices())
342 		strides = indices_strides(self.indices())
343 		array_offset = self.total_offset()
344 		if self.fixed_offsets:
345 			print("static inline uint32_t __offset_%s(%s idx)" % (self.local_name, self.index_ctype()))
347 			if self.index_type:
348 				for val, offset in zip(self.index_type.names(), self.offsets):
351 				for idx, offset in enumerate(self.offsets):
356 			tab_to("#define REG_%s_%s" % (self.domain, self.name), "0x%08x\n" % array_offset)
358 …tab_to("#define REG_%s_%s(%s)" % (self.domain, self.name, proto), "(0x%08x + %s )\n" % (array_offs…
360 	def dump_pack_struct(self):  argument
363 	def dump_regpair_builder(self):  argument
367 	def __init__(self, attrs, domain, array, bit_size):  argument
368 		self.name = attrs["name"]
369 		self.domain = domain
370 		self.array = array
371 		self.offset = int(attrs["offset"], 0)
372 		self.type = None
373 		self.bit_size = bit_size
375 			self.name = array.name + "_" + self.name
376 		self.full_name = self.domain + "_" + self.name
378 			self.stride = int(attrs["stride"], 0)
379 			self.length = int(attrs["length"], 0)
381 			self.stride = None
382 			self.length = None
385 	def indices(self):  argument
386 		if self.array:
387 			indices = self.array.indices()
390 		if self.stride:
391 			indices.append(("uint32_t", self.stride, None))
394 	def total_offset(self):  argument
395 		if self.array:
396 			return self.array.total_offset() + self.offset
398 			return self.offset
400 	def dump(self):  argument
401 		proto = indices_prototype(self.indices())
402 		strides = indices_strides(self.indices())
403 		offset = self.total_offset()
405 			tab_to("#define REG_%s" % self.full_name, "0x%08x" % offset)
407 …print("static inline uint32_t REG_%s(%s) { return 0x%08x + %s; }" % (self.full_name, proto, offset…
409 		if self.bitset.inline:
410 			self.bitset.dump(self.full_name)
412 	def dump_pack_struct(self):  argument
413 		if self.bitset.inline:
414 			self.bitset.dump_pack_struct(self)
416 	def dump_regpair_builder(self):  argument
417 		if self.bitset.inline:
418 			self.bitset.dump_regpair_builder(self)
420 	def dump_py(self):  argument
421 		print("\tREG_%s = 0x%08x" % (self.full_name, self.offset))
425 	def __init__(self):  argument
426 		self.current_array = None
427 		self.current_domain = None
428 		self.current_prefix = None
429 		self.current_prefix_type = None
430 		self.current_stripe = None
431 		self.current_bitset = None
432 		self.current_bitsize = 32
435 		self.current_varset = None
438 		self.variant_regs = {}
441 		self.usage_regs = collections.defaultdict(list)
442 		self.bitsets = {}
443 		self.enums = {}
444 		self.variants = set()
445 		self.file = []
446 		self.xml_files = []
447 		self.copyright_year = None
448 		self.authors = []
449 		self.license = None
451 	def error(self, message):  argument
452 		parser, filename = self.stack[-1]
455 	def prefix(self, variant=None):  argument
456 		if self.current_prefix_type == "variant" and variant:
458 		elif self.current_stripe:
459 			return self.current_stripe + "_" + self.current_domain
460 		elif self.current_prefix:
461 			return self.current_prefix + "_" + self.current_domain
463 			return self.current_domain
465 	def parse_field(self, name, attrs):  argument
474 				high = self.current_bitsize - 1
486 			b = Field(name, low, high, shr, type, self)
491 			self.current_bitset.fields.append(b)
493 			raise self.error(e)
495 	def parse_varset(self, attrs):  argument
497 		varset = self.current_varset
499 			varset = self.enums[attrs["varset"]]
502 	def parse_variants(self, attrs):  argument
509 		varset = self.parse_varset(attrs)
515 	def add_all_variants(self, reg, attrs, parent_variant):  argument
519 		variant = self.parse_variants(attrs)
523 		if reg.name not in self.variant_regs:
524 			self.variant_regs[reg.name] = {}
527 			v = next(iter(self.variant_regs[reg.name]))
528 			assert self.variant_regs[reg.name][v].bit_size == reg.bit_size
530 		self.variant_regs[reg.name][variant] = reg
532 	def add_all_usages(self, reg, usages):  argument
537 			self.usage_regs[usage].append(reg)
539 		self.variants.add(reg.domain)
541 	def do_validate(self, schemafile):  argument
542 		if not self.validate:
548 			parser, filename = self.stack[-1]
565 				raise self.error("Cannot find schema for: " + filename)
573 				raise self.error("Schema validation failed for: " + filename + "\n" + error_str)
575 			if self.validate:
580 	def do_parse(self, filename):  argument
582 		if filepath in self.xml_files:
584 		self.xml_files.append(filepath)
587 		self.stack.append((parser, filename))
588 		parser.StartElementHandler = self.start_element
589 		parser.EndElementHandler = self.end_element
590 		parser.CharacterDataHandler = self.character_data
593 		self.stack.pop()
596 	def parse(self, rnn_path, filename, validate):  argument
597 		self.path = rnn_path
598 		self.stack = []
599 		self.validate = validate
600 		self.do_parse(filename)
602 	def parse_reg(self, attrs, bit_size):  argument
603 		self.current_bitsize = bit_size
604 		if "type" in attrs and attrs["type"] in self.bitsets:
605 			bitset = self.bitsets[attrs["type"]]
607 				self.current_bitset = Bitset(attrs["name"], bitset)
608 				self.current_bitset.inline = True
610 				self.current_bitset = bitset
612 			self.current_bitset = Bitset(attrs["name"], None)
613 			self.current_bitset.inline = True
615 				self.parse_field(None, attrs)
617 		variant = self.parse_variants(attrs)
618 		if not variant and self.current_array:
619 			variant = self.current_array.variant
621 		self.current_reg = Reg(attrs, self.prefix(variant), self.current_array, bit_size)
622 		self.current_reg.bitset = self.current_bitset
624 		if len(self.stack) == 1:
625 			self.file.append(self.current_reg)
628 			self.add_all_variants(self.current_reg, attrs, variant)
633 		elif self.current_array:
634 			usages = self.current_array.usages
636 		self.add_all_usages(self.current_reg, usages)
638 	def start_element(self, name, attrs):  argument
639 		self.cdata = ""
642 			self.do_parse(os.path.join(self.path, filename))
644 			self.current_domain = attrs["name"]
646 				self.current_prefix = self.parse_variants(attrs)
647 				self.current_prefix_type = attrs["prefix"]
649 				self.current_prefix = None
650 				self.current_prefix_type = None
652 				self.current_varset = self.enums[attrs["varset"]]
654 			self.current_stripe = self.parse_variants(attrs)
656 			self.current_enum_value = 0
657 			self.current_enum = Enum(attrs["name"])
658 			self.enums[attrs["name"]] = self.current_enum
659 			if len(self.stack) == 1:
660 				self.file.append(self.current_enum)
665 				value = self.current_enum_value
666 			self.current_enum.values.append((attrs["name"], value))
668 			self.parse_reg(attrs, 32)
670 			self.parse_reg(attrs, 64)
672 			self.current_bitsize = 32
673 			variant = self.parse_variants(attrs)
674 			index_type = self.enums[attrs["index"]] if "index" in attrs else None
675 			self.current_array = Array(attrs, self.prefix(variant), variant, self.current_array, index_type)
676 			if len(self.stack) == 1:
677 				self.file.append(self.current_array)
679 			self.current_bitset = Bitset(attrs["name"], None)
681 				self.current_bitset.inline = True
682 			self.bitsets[self.current_bitset.name] = self.current_bitset
683 			if len(self.stack) == 1 and not self.current_bitset.inline:
684 				self.file.append(self.current_bitset)
685 		elif name == "bitfield" and self.current_bitset:
686 			self.parse_field(attrs["name"], attrs)
688 			self.do_validate(attrs["xsi:schemaLocation"])
690 			self.copyright_year = attrs["year"]
692 			self.authors.append(attrs["name"] + " <" + attrs["email"] + "> " + attrs["name"])
694 	def end_element(self, name):  argument
696 			self.current_domain = None
697 			self.current_prefix = None
698 			self.current_prefix_type = None
700 			self.current_stripe = None
702 			self.current_bitset = None
704 			self.current_reg = None
706 			self.current_array = self.current_array.parent
708 			self.current_enum = None
710 			self.license = self.cdata
712 	def character_data(self, data):  argument
713 		self.cdata += data
715 	def dump_reg_usages(self):  argument
717 		for usage, regs in self.usage_regs.items():
719 				variants = self.variant_regs.get(reg.name)
725 					for variant in self.variants:
730 		for usage, regs in self.usage_regs.items():
756 	def dump(self):  argument
760 		for e in self.file:
771 		self.dump_reg_usages()
774 	def dump_regs_py(self):  argument
776 		for e in self.file:
784 	def dump_reg_variants(self, regname, variants):  argument
852 	def dump_structs(self):  argument
853 		for e in self.file:
856 		for regname in self.variant_regs:
857 			self.dump_reg_variants(regname, self.variant_regs[regname])