src/freedreno/registers/gen_header.py

   1 #!/usr/bin/python3
   2
   3 import xml.parsers.expat
   4 import sys
   5 import os
   6
   7 class Error(Exception):
   8         def __init__(self, message):
   9                 self.message = message
  10
  11 class Enum(object):
  12         def __init__(self, name):
  13                 self.name = name
  14                 self.values = []
  15
  16         def dump(self):
  17                 prev = 0
  18                 use_hex = False
  19                 for (name, value) in self.values:
  20                         if value > 0x1000:
  21                                 use_hex = True
  22
  23                 print("enum %s {" % self.name)
  24                 for (name, value) in self.values:
  25                         if use_hex:
  26                                 print("\t%s = 0x%08x," % (name, value))
  27                         else:
  28                                 print("\t%s = %d," % (name, value))
  29                 print("};\n")
  30
  31         def dump_pack_struct(self):
  32                 pass
  33
  34 class Field(object):
  35         def __init__(self, name, low, high, shr, type, parser):
  36                 self.name = name
  37                 self.low = low
  38                 self.high = high
  39                 self.shr = shr
  40                 self.type = type
  41
  42                 builtin_types = [ None, "boolean", "uint", "hex", "int", "fixed", "ufixed", "float", "address", "waddress" ]
  43
  44                 if low < 0 or low > 31:
  45                         raise parser.error("low attribute out of range: %d" % low)
  46                 if high < 0 or high > 31:
  47                         raise parser.error("high attribute out of range: %d" % high)
  48                 if high < low:
  49                         raise parser.error("low is greater than high: low=%d, high=%d" % (low, high))
  50                 if self.type == "boolean" and not low == high:
  51                         raise parser.error("booleans should be 1 bit fields");
  52                 elif self.type == "float" and not (high - low == 31 or high - low == 15):
  53                         raise parser.error("floats should be 16 or 32 bit fields")
  54                 elif not self.type in builtin_types and not self.type in parser.enums:
  55                         raise parser.error("unknown type '%s'" % self.type);
  56
  57         def ctype(self, var_name):
  58                 if self.type == None:
  59                         type = "uint32_t"
  60                         val = var_name
  61                 elif self.type == "boolean":
  62                         type = "bool"
  63                         val = var_name
  64                 elif self.type == "uint" or self.type == "hex":
  65                         type = "uint32_t"
  66                         val = var_name
  67                 elif self.type == "int":
  68                         type = "int32_t"
  69                         val = var_name
  70                 elif self.type == "fixed":
  71                         type = "float"
  72                         val = "((int32_t)(%s * %d.0))" % (var_name, 1 << self.radix)
  73                 elif self.type == "ufixed":
  74                         type = "float"
  75                         val = "((uint32_t)(%s * %d.0))" % (var_name, 1 << self.radix)
  76                 elif self.type == "float" and self.high - self.low == 31:
  77                         type = "float"
  78                         val = "fui(%s)" % var_name
  79                 elif self.type == "float" and self.high - self.low == 15:
  80                         type = "float"
  81                         val = "util_float_to_half(%s)" % var_name
  82                 elif self.type in [ "address", "waddress" ]:
  83                         type = "uint64_t"
  84                         val = var_name
  85                 else:
  86                         type = "enum %s" % self.type
  87                         val = var_name
  88
  89                 if self.shr > 0:
  90                         val = "(%s >> %d)" % (val, self.shr)
  91
  92                 return (type, val)
  93
  94 def tab_to(name, value):
  95         tab_count = (68 - (len(name) & ~7)) // 8
  96         if tab_count == 0:
  97                 tab_count = 1
  98         print(name + ('\t' * tab_count) + value)
  99
 100 def mask(low, high):
 101         return ((0xffffffff >> (32 - (high + 1 - low))) << low)
 102
 103 class Bitset(object):
 104         def __init__(self, name, template):
 105                 self.name = name
 106                 self.inline = False
 107                 if template:
 108                         self.fields = template.fields
 109                 else:
 110                         self.fields = []
 111
 112         def dump_pack_struct(self, prefix=None, array=None):
 113                 def field_name(prefix, name):
 114                         if f.name:
 115                                 name = f.name.lower()
 116                         else:
 117                                 name = prefix.lower()
 118
 119                         if (name in [ "double", "float", "int" ]) or not (name[0].isalpha()):
 120                                         name = "_" + name
 121
 122                         return name
 123
 124                 if not prefix:
 125                         return
 126                 if prefix == None:
 127                         prefix = self.name
 128
 129                 print("struct %s {" % prefix)
 130                 for f in self.fields:
 131                         if f.type in [ "address", "waddress" ]:
 132                                 tab_to("    __bo_type", "bo;")
 133                                 tab_to("    uint32_t", "bo_offset;")
 134                                 continue
 135                         name = field_name(prefix, f.name)
 136
 137                         type, val = f.ctype("var")
 138
 139                         tab_to("    %s" % type, "%s;" % name)
 140                 tab_to("    uint32_t", "unknown;")
 141                 tab_to("    uint32_t", "dword;")
 142                 print("};\n")
 143
 144                 address = None;
 145                 for f in self.fields:
 146                         if f.type in [ "address", "waddress" ]:
 147                                 address = f
 148                 if array:
 149                         print("static inline struct fd_reg_pair\npack_%s(uint32_t i, struct %s fields)\n{" %
 150                                   (prefix, prefix));
 151                 else:
 152                         print("static inline struct fd_reg_pair\npack_%s(struct %s fields)\n{" %
 153                                   (prefix, prefix));
 154
 155                 print("#ifndef NDEBUG")
 156                 known_mask = 0
 157                 for f in self.fields:
 158                         known_mask |= mask(f.low, f.high)
 159                         if f.type in [ "boolean", "address", "waddress" ]:
 160                                 continue
 161                         type, val = f.ctype("fields.%s" % field_name(prefix, f.name))
 162                         print("    assert((%-40s & 0x%08x) == 0);" % (val, 0xffffffff ^ mask(0 , f.high - f.low)))
 163                 print("    assert((%-40s & 0x%08x) == 0);" % ("fields.unknown", known_mask))
 164                 print("#endif\n")
 165
 166                 print("    return (struct fd_reg_pair) {")
 167                 if array:
 168                         print("        .reg = REG_%s(i)," % prefix)
 169                 else:
 170                         print("        .reg = REG_%s," % prefix)
 171
 172                 print("        .value =")
 173                 for f in self.fields:
 174                         if f.type in [ "address", "waddress" ]:
 175                                 continue
 176                         else:
 177                                 type, val = f.ctype("fields.%s" % field_name(prefix, f.name))
 178                                 print("            (%-40s << %2d) |" % (val, f.low))
 179                 print("            fields.unknown | fields.dword,")
 180
 181                 if address:
 182                         print("        .bo = fields.bo,")
 183                         if f.type == "waddress":
 184                                 print("        .bo_write = true,")
 185                         print("        .bo_offset = fields.bo_offset,")
 186                         print("        .bo_shift = %d" % address.shr)
 187
 188                 print("    };\n}\n")
 189
 190                 if address:
 191                         skip = ", { .reg = 0 }"
 192                 else:
 193                         skip = ""
 194
 195                 if array:
 196                         print("#define %s(i, ...) pack_%s(i, (struct %s) { __VA_ARGS__ })%s\n" %
 197                                   (prefix, prefix, prefix, skip))
 198                 else:
 199                         print("#define %s(...) pack_%s((struct %s) { __VA_ARGS__ })%s\n" %
 200                                   (prefix, prefix, prefix, skip))
 201
 202
 203         def dump(self, prefix=None):
 204                 if prefix == None:
 205                         prefix = self.name
 206                 for f in self.fields:
 207                         if f.name:
 208                                 name = prefix + "_" + f.name
 209                         else:
 210                                 name = prefix
 211
 212                         if not f.name and f.low == 0 and f.shr == 0 and not f.type in ["float", "fixed", "ufixed"]:
 213                                 pass
 214                         elif f.type == "boolean" or (f.type == None and f.low == f.high):
 215                                 tab_to("#define %s" % name, "0x%08x" % (1 << f.low))
 216                         else:
 217                                 tab_to("#define %s__MASK" % name, "0x%08x" % mask(f.low, f.high))
 218                                 tab_to("#define %s__SHIFT" % name, "%d" % f.low)
 219                                 type, val = f.ctype("val")
 220
 221                                 print("static inline uint32_t %s(%s val)\n{" % (name, type))
 222                                 if f.shr > 0:
 223                                         print("\tassert(!(val & 0x%x));" % mask(0, f.shr - 1))
 224                                 print("\treturn ((%s) << %s__SHIFT) & %s__MASK;\n}" % (val, name, name))
 225                 print()
 226
 227 class Array(object):
 228         def __init__(self, attrs, domain):
 229                 self.name = attrs["name"]
 230                 self.domain = domain
 231                 self.offset = int(attrs["offset"], 0)
 232                 self.stride = int(attrs["stride"], 0)
 233                 self.length = int(attrs["length"], 0)
 234
 235         def dump(self):
 236                 print("static inline uint32_t REG_%s_%s(uint32_t i0) { return 0x%08x + 0x%x*i0; }\n" % (self.domain, self.name, self.offset, self.stride))
 237
 238         def dump_pack_struct(self):
 239                 pass
 240
 241 class Reg(object):
 242         def __init__(self, attrs, domain, array, bit_size):
 243                 self.name = attrs["name"]
 244                 self.domain = domain
 245                 self.array = array
 246                 self.offset = int(attrs["offset"], 0)
 247                 self.type = None
 248                 self.bit_size = bit_size
 249
 250                 if self.array:
 251                         self.full_name = self.domain + "_" + self.array.name + "_" + self.name
 252                 else:
 253                         self.full_name = self.domain + "_" + self.name
 254
 255         def dump(self):
 256                 if self.array:
 257                         offset = self.array.offset + self.offset
 258                         print("static inline uint32_t REG_%s(uint32_t i0) { return 0x%08x + 0x%x*i0; }" % (self.full_name, offset, self.array.stride))
 259                 else:
 260                         tab_to("#define REG_%s" % self.full_name, "0x%08x" % self.offset)
 261
 262                 if self.bitset.inline:
 263                         self.bitset.dump(self.full_name)
 264                 print("")
 265
 266         def dump_pack_struct(self):
 267                 if self.bitset.inline:
 268                         self.bitset.dump_pack_struct(self.full_name, not self.array == None)
 269
 270
 271 def parse_variants(attrs):
 272                 if not "variants" in attrs:
 273                                 return None
 274                 variant = attrs["variants"].split(",")[0]
 275                 if "-" in variant:
 276                         variant = variant[:variant.index("-")]
 277
 278                 return variant
 279
 280 class Parser(object):
 281         def __init__(self):
 282                 self.current_array = None
 283                 self.current_domain = None
 284                 self.current_prefix = None
 285                 self.current_stripe = None
 286                 self.current_bitset = None
 287                 self.bitsets = {}
 288                 self.enums = {}
 289                 self.file = []
 290
 291         def error(self, message):
 292                 parser, filename = self.stack[-1]
 293                 return Error("%s:%d:%d: %s" % (filename, parser.CurrentLineNumber, parser.CurrentColumnNumber, message))
 294
 295         def prefix(self):
 296                 if self.current_stripe:
 297                         return self.current_stripe + "_" + self.current_domain
 298                 elif self.current_prefix:
 299                         return self.current_prefix + "_" + self.current_domain
 300                 else:
 301                         return self.current_domain
 302
 303         def parse_field(self, name, attrs):
 304                 try:
 305                         if "pos" in attrs:
 306                                 high = low = int(attrs["pos"], 0)
 307                         elif "high" in attrs and "low" in attrs:
 308                                 high = int(attrs["high"], 0)
 309                                 low = int(attrs["low"], 0)
 310                         else:
 311                                 low = 0
 312                                 high = 31
 313
 314                         if "type" in attrs:
 315                                 type = attrs["type"]
 316                         else:
 317                                 type = None
 318
 319                         if "shr" in attrs:
 320                                 shr = int(attrs["shr"], 0)
 321                         else:
 322                                 shr = 0
 323
 324                         b = Field(name, low, high, shr, type, self)
 325
 326                         if type == "fixed" or type == "ufixed":
 327                                 b.radix = int(attrs["radix"], 0)
 328
 329                         self.current_bitset.fields.append(b)
 330                 except ValueError as e:
 331                         raise self.error(e);
 332
 333         def do_parse(self, filename):
 334                 file = open(filename, "rb")
 335                 parser = xml.parsers.expat.ParserCreate()
 336                 self.stack.append((parser, filename))
 337                 parser.StartElementHandler = self.start_element
 338                 parser.EndElementHandler = self.end_element
 339                 parser.ParseFile(file)
 340                 self.stack.pop()
 341                 file.close()
 342
 343         def parse(self, filename):
 344                 self.path = os.path.dirname(filename)
 345                 self.stack = []
 346                 self.do_parse(filename)
 347
 348         def parse_reg(self, attrs, bit_size):
 349                 if "type" in attrs and attrs["type"] in self.bitsets:
 350                         self.current_bitset = self.bitsets[attrs["type"]]
 351                 else:
 352                         self.current_bitset = Bitset(attrs["name"], None)
 353                         self.current_bitset.inline = True
 354                         if "type" in attrs:
 355                                 self.parse_field(None, attrs)
 356
 357                 self.current_reg = Reg(attrs, self.prefix(), self.current_array, bit_size)
 358                 self.current_reg.bitset = self.current_bitset
 359
 360                 if len(self.stack) == 1:
 361                         self.file.append(self.current_reg)
 362
 363         def start_element(self, name, attrs):
 364                 if name == "import":
 365                         filename = os.path.basename(attrs["file"])
 366                         self.do_parse(os.path.join(self.path, filename))
 367                 elif name == "domain":
 368                         self.current_domain = attrs["name"]
 369                         if "prefix" in attrs and attrs["prefix"] == "chip":
 370                                 self.current_prefix = parse_variants(attrs)
 371                 elif name == "stripe":
 372                         self.current_stripe = parse_variants(attrs)
 373                 elif name == "enum":
 374                         self.current_enum_value = 0
 375                         self.current_enum = Enum(attrs["name"])
 376                         self.enums[attrs["name"]] = self.current_enum
 377                         if len(self.stack) == 1:
 378                                 self.file.append(self.current_enum)
 379                 elif name == "value":
 380                         if "value" in attrs:
 381                                 value = int(attrs["value"], 0)
 382                         else:
 383                                 value = self.current_enum_value
 384                         self.current_enum.values.append((attrs["name"], value))
 385                         # self.current_enum_value = value + 1
 386                 elif name == "reg32":
 387                         self.parse_reg(attrs, 32)
 388                 elif name == "reg64":
 389                         self.parse_reg(attrs, 64)
 390                 elif name == "array":
 391                         self.current_array = Array(attrs, self.prefix())
 392                         if len(self.stack) == 1:
 393                                 self.file.append(self.current_array)
 394                 elif name == "bitset":
 395                         self.current_bitset = Bitset(attrs["name"], None)
 396                         if "inline" in attrs and attrs["inline"] == "yes":
 397                                 self.current_bitset.inline = True
 398                         self.bitsets[self.current_bitset.name] = self.current_bitset
 399                         if len(self.stack) == 1 and not self.current_bitset.inline:
 400                                 self.file.append(self.current_bitset)
 401                 elif name == "bitfield" and self.current_bitset:
 402                         self.parse_field(attrs["name"], attrs)
 403
 404         def end_element(self, name):
 405                 if name == "domain":
 406                         self.current_domain = None
 407                         self.current_prefix = None
 408                 elif name == "stripe":
 409                         self.current_stripe = None
 410                 elif name == "bitset":
 411                         self.current_bitset = None
 412                 elif name == "reg32":
 413                         self.current_reg = None
 414                 elif name == "array":
 415                         self.current_array = None;
 416                 elif name == "enum":
 417                         self.current_enum = None
 418
 419         def dump(self):
 420                 enums = []
 421                 bitsets = []
 422                 regs = []
 423                 for e in self.file:
 424                         if isinstance(e, Enum):
 425                                 enums.append(e)
 426                         elif isinstance(e, Bitset):
 427                                 bitsets.append(e)
 428                         else:
 429                                 regs.append(e)
 430
 431                 for e in enums + bitsets + regs:
 432                         e.dump()
 433
 434         def dump_structs(self):
 435                 for e in self.file:
 436                         e.dump_pack_struct()
 437
 438
 439 def main():
 440         p = Parser()
 441         xml_file = sys.argv[1]
 442         if len(sys.argv) > 2 and sys.argv[2] == '--pack-structs':
 443                 do_structs = True
 444                 guard = str.replace(os.path.basename(xml_file), '.', '_').upper() + '_STRUCTS'
 445         else:
 446                 do_structs = False
 447                 guard = str.replace(os.path.basename(xml_file), '.', '_').upper()
 448
 449         print("#ifndef %s\n#define %s\n" % (guard, guard))
 450
 451         try:
 452                 p.parse(xml_file)
 453         except Error as e:
 454                 print(e)
 455                 exit(1)
 456
 457         if do_structs:
 458                 p.dump_structs()
 459         else:
 460                 p.dump()
 461
 462         print("\n#endif /* %s */" % guard)
 463
 464 if __name__ == '__main__':
 465         main()