path: root/radeonreg.py

#!/usr/bin/python
# -*- coding: utf-8 -*-

import re
from xml.etree import ElementTree

class RadeonReg:
    def __init__(self, unit, name, count, access, addr, stride, desc):
        self.unit = unit
        self.name = name
        self.desc = desc
        self.count = count
        self.access = access
        self.addr = addr
        self.fields = []
        self.stride = stride
    
    def equals(self, rhs):
        if  self.unit != rhs.unit or \
            self.name != rhs.name or \
            self.desc != rhs.desc or \
            self.count != rhs.count or \
            self.access != rhs.access or \
            self.addr != rhs.addr or \
            self.stride != rhs.stride or \
            len(self.fields) != len(rhs.fields): return False
        
        for i in xrange(len(self.fields)):
            if not self.fields[i].equals(rhs.fields[i]): return False
        
        return True

class RadeonField:
    def __init__(self, name, low, high, desc):
        self.name = name
        self.desc = desc
        self.low = low if low <= high else high
        self.high = high if high >= low else low
        self.enum = None
    
    def equals(self, rhs):
        if  self.name == rhs.name and \
            self.desc == rhs.desc and \
            self.low == rhs.low and \
            self.high == rhs.high and \
            self.enum == rhs.enum: return True
        return False

class EnumEntry:
    def __init__(self, val, name, desc):
        self.val = val
        self.name = name
        self.desc = desc

class RadeonEnum:
    def __init__(self):
        self.entries = []
        self.refs = 0
        
    def add(self, val, name, desc):
        self.entries.append(EnumEntry(val, name, desc))
        
    def reference(self):
        self.refs = self.refs + 1

    def equals(self, rhs):
        if len(self.entries) != len(rhs.entries): return False
        for i in xrange(len(self.entries)):
            if self.entries[i].val != rhs.entries[i].val: return False
            if self.entries[i].name != rhs.entries[i].name: return False
            if self.entries[i].desc != rhs.entries[i].desc: return False
        return True

enums = []

def AddEnum(e):
    for i in xrange(len(enums)):
        if e.equals(enums[i]):
            return i
    enums.append(e)
    return len(enums)-1

enum_regex = re.compile('(\d\d?)( - |: |=)((?:(?!\d\d?(?: - |: |=)).)*)', re.DOTALL)
enum_desc = re.compile('(\d\d?( - |: |=)|POSSIBLE VALUES:)')
enum_ename = re.compile('([A-Za-z0-9_]*)')
reserved_regex = re.compile('[Rr][Ee][Ss][Ee][Rr][Vv][Ee][Dd]')

def ExtractEnum(s):
    dl = s.split('\n')
    d = ''
    for line in dl:
        if enum_desc.match(line): break
        d += ' ' + line
    d = StripSpaces(d)
    
    enum = RadeonEnum()
    m = enum_regex.findall(s)
    for entry in m:
        val = int(entry[0])
        desc = StripSpaces(entry[2].replace('\n', ' '))
        if reserved_regex.search(desc): continue
        name = StripUnders(enum_ename.match(desc.replace(' ', '_')).group(1).upper())
        enum.add(val, name, desc)
    
    if len(enum.entries) == 0: enum = None
    return [d, enum]

subs = [re.compile('^.+ 2008 Advanced Micro Devices, Inc.$'),
        re.compile('^Proprietary *[0-9]*$'),
        re.compile('^. *Revision [0-9\.]* *[A-Za-z]* [0-9]{1,2}, [0-9]*$'),
        re.compile('^.$'),
        re.compile('^ *$'),
        re.compile('\n'),
        re.compile('^[0-9]+.[0-9]+ .* Registers.*$'),
        re.compile('^\(Access: [RW]\)')]
stupid_linebreaks = re.compile('-\n0x')

def ReadPDFDump(filename):
    pdffile = open(filename, 'r')
    pdflines = pdffile.readlines()
    pdffile.close()

    formatted = ''
    for line in pdflines:
        out = line
        for regex in subs:
            out = regex.sub('', out)
            
        if out != '':
            formatted += out + '\n'

    formatted = stupid_linebreaks.sub('-0x', formatted);
    return formatted + '\n'

spaces = re.compile(' +')
spaces_end = re.compile('(^ | $)', re.MULTILINE)

def StripSpaces(s):
    return spaces_end.sub('', spaces.sub(' ', s))

uscores = re.compile('_+')
uscores_end = re.compile('(^_|_$)', re.MULTILINE)
def StripUnders(s):
    return uscores_end.sub('', uscores.sub('_', s))

reg_regex = re.compile(
'([A-Za-z0-9_]{1,4}):([A-Za-z0-9_]+)(\[([0-9]+)-([0-9]+)\]?|)([A-Za-z0-9_]*).*\[([RW\/]+)\].*[^,]? ?MMReg:0x([0-9A-Fa-f]{1,6})(-0x([0-9A-Fa-f]{1,6})|).*'
'(\nDESCRIPTION: (.*(\n.*)*?))?'
'\nField Name +.*? +Description.*\n'
'([^·]*\n)+'
)
field_regex = re.compile(
'([A-Za-z0-9_]+) +([0-9]{1,2})(:([0-9]{1,2})|) +(0x[0-9A-Fa-f]+|[Nn]one) +(.*(\n  +.*)*)'
)

def FormatPDFDump(pdf):
    regs = []
    m = reg_regex.findall(pdf)
    for reg in m:
        unit = reg[0]
        name = StripUnders(reg[1] + '_' + reg[5])
        addr = [ int(reg[7], 16), int(reg[9], 16) if reg[9] != '' else int(reg[7], 16) ]
        access = reg[6].lower().replace('/', '')
        count = (int(reg[4]) - int(reg[3]) + 1) if reg[3] != '' and reg[4] != '' else 1
        stride = ((addr[1] - addr[0]) / (count - 1)) if count > 1 else 4
        desc = StripSpaces(reg[11].replace('\n', ' '))
        regs.append(RadeonReg(unit, name, count, access, addr[0], stride, desc))
        
        f = field_regex.findall(reg[13])
        for field in f:
            fname = field[0]
            fbits = [ int(field[1]), int(field[3]) if field[3] != '' else int(field[1]) ]
            fdesc = StripSpaces(field[5])
            regs[-1].fields.append(RadeonField(fname, fbits[1], fbits[0], fdesc))
            
            e = ExtractEnum(fdesc)
            regs[-1].fields[-1].desc = e[0]
            if e[1] != None: regs[-1].fields[-1].enum = AddEnum(e[1])
            
        if len(regs[-1].fields) > 0:
            if regs[-1].fields[0].low == 0 and regs[-1].fields[0].high == 31:
                regs[-1].fields = []

    return regs

def CompareRegs(regs1, regs2):
    regs_a = []
    regs_b = []
    regs_both = []
    
    for r1r in regs1:
        for r2r in regs2:
            if r1r.equals(r2r): regs_both.append(r1r)
    
    for r1r in regs1:
        inboth = False
        for rb in regs_both:
            if r1r.equals(rb): inboth = True
        
        if not inboth:
            regs_a.append(r1r)

    for r2r in regs2:
        inboth = False
        for rb in regs_both:
            if r2r.equals(rb): inboth = True
        
        if not inboth:
            regs_b.append(r2r)
                
    return [regs_both, regs_a, regs_b]

def CreateXML(handle, regs, variants):
    comment = ElementTree.Comment(
"""
This file was automatically generated from radeonreg.py.

I strongly suggest running "tidy -m -xml 'name_of_file.xml'" on this file
before attempting to read it.

~ C.
""")
    preamble = ElementTree.PI("xml", "version=\"1.0\" encoding=\"UTF-8\"")

    database_attrs = {
        "xmlns": "http://nouveau.freedesktop.org/",
        "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
        "xsi:schemaLocation": "rules-ng.xsd",
    }
    database = ElementTree.Element("database", database_attrs)
    domain = ElementTree.SubElement(database, "domain", name="R300")

    for i, enum in enumerate(enums):
        if enum.refs > 1:
            enum_tag = ElementTree.Element("enum")
            enum_tag.attrib["name"] = "ENUM%d" % i
            for entry in enum.entries:
                if not entry.name:
                    continue
                value = ElementTree.SubElement(enum_tag, "value")
                value.attrib["name"] = entry.name
                value.attrib["value"] = str(entry.val)
                doc = ElementTree.SubElement(value, "doc")
                doc.text = entry.desc
            if enum_tag:
                database.append(enum_tag)

    for (group, name, prepend) in regs:
        group_tag = ElementTree.SubElement(database, "group", name=name)
        # "prepend" isn't (yet) recognized by the schema
        #group_tag.attrib["prepend"] = "%s_" % prepend
        for reg in group:
            if reg.count > 1:
                stripe = ElementTree.SubElement(group_tag, "stripe")
                stripe.attrib["offset"] = "0x%04X" % reg.addr
                stripe.attrib["stride"] = "0x%04X" % reg.stride
                stripe.attrib["length"] = str(reg.count)

                reg32 = ElementTree.SubElement(stripe, "reg32",
                    name=reg.name, access=reg.access, offset="0x0")
            else:
                reg32 = ElementTree.SubElement(group_tag, "reg32",
                    name=reg.name, access=reg.access)
                reg32.attrib["offset"] = "0x%04X" % reg.addr

            if reg.desc:
                ElementTree.SubElement(reg32, "doc").text = reg.desc

            for field in reg.fields:
                bitfield = ElementTree.SubElement(reg32, "bitfield",
                    name=field.name, high=str(field.high), low=str(field.low))
                ElementTree.SubElement(reg32, "doc").text = field.desc
                if field.enum:
                    if enums[field.enum].refs == 1:
                        for entry in enums[field.enum].entries:
                            if not entry.name:
                                continue
                            value = ElementTree.SubElement(bitfield, "value")
                            value.attrib["name"] = entry.name
                            value.attrib["value"] = str(entry.val)
                            doc = ElementTree.SubElement(value, "doc")
                            doc.text = entry.desc
                    else:
                        use_enum = ElementTree.SubElement(bitfield, "use-enum")
                        use_enum.attrib["ref"] = "ENUM%d" % field.enum

    for (name, groups) in variants:
        variant = ElementTree.SubElement(database, "variant", id=name)
        for group in groups:
            ElementTree.SubElement(variant, "use-group", ref=group)

    ElementTree.ElementTree(preamble).write(handle)
    ElementTree.ElementTree(comment).write(handle)
    ElementTree.ElementTree(database).write(handle)

def ReferenceEnums(regs):
    for reg in regs:
        for field in reg.fields:
            if field.enum != None:
                enums[field.enum].reference()

r300regs = FormatPDFDump(ReadPDFDump('R3xx_3D_Registers.txt'))
r500regs = FormatPDFDump(ReadPDFDump('R5xx_Acceleration_v1.3.txt'))
finalregs = CompareRegs(r300regs, r500regs)
regs_both = finalregs[0]
regs_r300 = finalregs[1]
regs_r500 = finalregs[2]
ReferenceEnums(regs_both)
ReferenceEnums(regs_r300)
ReferenceEnums(regs_r500)
xmlfile = open("r300reg.xml", "w")
CreateXML(xmlfile,
    [
        [regs_both, 'rX00_regs', 'R300'],
        [regs_r300, 'r300_regs', 'R300'],
        [regs_r500, 'r500_regs', 'R500']
    ],
    [
        ['r300', ['rX00_regs', 'r300_regs']],
        ['r500', ['rX00_regs', 'r500_regs']]
    ]
)
xmlfile.close()