src/interface_decl.py

   1
   2 class Pin(object):
   3     """ pin interface declaration.
   4         * name is the name of the pin
   5         * ready, enabled and io all create a (* .... *) prefix
   6         * action changes it to an "in" if true
   7     """
   8
   9     def __init__(self, name,
  10                  ready=True,
  11                  enabled=True,
  12                  io=False,
  13                  action=False,
  14                  bitspec=None):
  15         self.name = name
  16         self.ready = ready
  17         self.enabled = enabled
  18         self.io = io
  19         self.action = action
  20         self.bitspec = bitspec if bitspec else '1'
  21
  22     def ifacefmt(self, fmtfn=None):
  23         res = '    '
  24         status = []
  25         if self.ready:
  26             status.append('always_ready')
  27         if self.enabled:
  28             status.append('always_enabled')
  29         if self.io:
  30             status.append('result="io"')
  31         if status:
  32             res += '(*'
  33             res += ','.join(status)
  34             res += '*)'
  35         res += " method "
  36         if self.io:
  37             res += "\n                      "
  38         name = fmtfn(self.name)
  39         if self.action:
  40             res += " Action "
  41             res += name
  42             res += ' (Bit#(%s) in)' % self.bitspec
  43         else:
  44             res += " Bit#(%s) " % self.bitspec
  45             res += name
  46         res += ";"
  47         return res
  48
  49     def ifacedef(self, fmtoutfn=None, fmtinfn=None, fmtdecfn=None):
  50         res = '      method '
  51         if self.action:
  52             fmtname = fmtinfn(self.name)
  53             res += "Action  "
  54             res += fmtdecfn(self.name)
  55             res += '(Bit#(%s) in);\n' % self.bitspec
  56             res += '         %s<=in;\n' % fmtname
  57             res += '      endmethod'
  58         else:
  59             fmtname = fmtoutfn(self.name)
  60             res += "%s=%s;" % (self.name, fmtname)
  61         return res
  62
  63
  64 class Interface(object):
  65     """ create an interface from a list of pinspecs.
  66         each pinspec is a dictionary, see Pin class arguments
  67     """
  68
  69     def __init__(self, pinspecs):
  70         self.pins = []
  71         for p in pinspecs:
  72             if p.get('outen') is True:  # special case, generate 3 pins
  73                 _p = {}
  74                 _p.update(p)
  75                 del _p['outen']
  76                 for psuffix in ['out', 'outen', 'in']:
  77                     _p['name'] = "%s_%s" % (p['name'], psuffix)
  78                     _p['action'] = psuffix != 'in'
  79                     self.pins.append(Pin(**_p))
  80             else:
  81                 self.pins.append(Pin(**p))
  82
  83     def ifacefmt(self, *args):
  84         res = '\n'.join(map(self.ifacefmtdecpin, self.pins)).format(*args)
  85         return '\n' + res
  86
  87     def ifacefmtdecfn(self, name):
  88         return name
  89
  90     def ifacefmtdecfn2(self, name):
  91         return name
  92
  93     def ifacefmtoutfn(self, name):
  94         return "wr%s" % name
  95
  96     def ifacefmtinfn(self, name):
  97         return "wr%s" % name
  98
  99     def ifacefmtdecpin(self, pin):
 100         return pin.ifacefmt(self.ifacefmtdecfn)
 101
 102     def ifacefmtpin(self, pin):
 103         return pin.ifacedef(self.ifacefmtoutfn, self.ifacefmtinfn,
 104                             self.ifacefmtdecfn2)
 105
 106     def ifacedef(self, *args):
 107         res = '\n'.join(map(self.ifacefmtpin, self.pins))
 108         res = res.format(*args)
 109         return '\n' + res + '\n'
 110
 111
 112 class IOInterface(Interface):
 113
 114     def ifacefmtoutfn(self, name):
 115         """ for now strip off io{0}_ part """
 116         return "cell{0}_mux_out.%s" % name[6:]
 117
 118     def ifacefmtinfn(self, name):
 119         return "cell{0}_mux_in"
 120
 121
 122 # ========= Interface declarations ================ #
 123
 124 mux_interface = Interface([{'name': 'cell{0}_mux', 'ready':False,
 125                       'enabled':False,
 126                      'bitspec': '{1}', 'action': True}])
 127
 128 io_interface = IOInterface([{'name': 'io{0}_outputval', 'enabled': False},
 129                           {'name': 'io{0}_output_en', 'enabled': False},
 130                           {'name': 'io{0}_input_en', 'enabled': False},
 131                           {'name': 'io{0}_pullup_en', 'enabled': False},
 132                           {'name': 'io{0}_pulldown_en', 'enabled': False},
 133                           {'name': 'io{0}_drivestrength', 'enabled': False},
 134                           {'name': 'io{0}_pushpull_en', 'enabled': False},
 135                           {'name': 'io{0}_opendrain_en', 'enabled': False},
 136                           {'name': 'io{0}_inputval', 'action': True, 'io': True},
 137                           ])
 138
 139 # == Peripheral Interface definitions == #
 140 # these are the interface of the peripherals to the pin mux
 141 # Outputs from the peripherals will be inputs to the pinmux
 142 # module. Hence the change in direction for most pins
 143
 144 uartinterface_decl = Interface([{'name': 'uart{0}_rx'},
 145                                 {'name': 'uart{0}_tx', 'action': True},
 146                                 ])
 147
 148 spiinterface_decl = Interface([{'name': 'spi{0}_sclk', 'action': True},
 149                                {'name': 'spi{0}_mosi', 'action': True},
 150                                {'name': 'spi{0}_nss', 'action': True},
 151                                {'name': 'spi{0}_miso'},
 152                                ])
 153
 154 twiinterface_decl = Interface([{'name': 'twi{0}_sda', 'outen': True},
 155                                {'name': 'twi{0}_scl', 'outen': True},
 156                                ])
 157
 158 sdinterface_decl = Interface([{'name': 'sd{0}_clk', 'action': True},
 159                               {'name': 'sd{0}_cmd', 'action': True},
 160                               {'name': 'sd{0}_d0', 'outen': True},
 161                               {'name': 'sd{0}_d1', 'outen': True},
 162                               {'name': 'sd{0}_d2', 'outen': True},
 163                               {'name': 'sd{0}_d3', 'outen': True}
 164                               ])
 165
 166 jtaginterface_decl = Interface([{'name': 'jtag{0}_tdi'},
 167                                 {'name': 'jtag{0}_tms'},
 168                                 {'name': 'jtag{0}_tclk'},
 169                                 {'name': 'jtag{0}_trst'},
 170                                 {'name': 'jtag{0}_tdo', 'action': True}])
 171
 172 pwminterface_decl = Interface([{'name': "pwm{0}_pwm", 'action': True}])
 173
 174 # ======================================= #
 175
 176 # basic test
 177 if __name__ == '__main__':
 178
 179     def _pinmunge(p, sep, repl, dedupe=True):
 180         """ munges the text so it's easier to compare.
 181             splits by separator, strips out blanks, re-joins.
 182         """
 183         p = p.strip()
 184         p = p.split(sep)
 185         if dedupe:
 186             p = filter(lambda x: x, p)  # filter out blanks
 187         return repl.join(p)
 188
 189     def pinmunge(p):
 190         """ munges the text so it's easier to compare.
 191         """
 192         # first join lines by semicolons, strip out returns
 193         p = p.split(";")
 194         p = map(lambda x: x.replace('\n', ''), p)
 195         p = '\n'.join(p)
 196         # now split first by brackets, then spaces (deduping on spaces)
 197         p = _pinmunge(p, "(", " ( ", False)
 198         p = _pinmunge(p, ")", " ) ", False)
 199         p = _pinmunge(p, " ", " ")
 200         return p
 201
 202     from interface_def import io_interface_def
 203     print io_interface_def.format(0)
 204     print io_interface.ifacedef(0)
 205     assert io_interface_def.format(0) == io_interface.ifacedef(0)
 206
 207     mux_interfacetest = '''
 208           method Action cell{0}_mux(Bit#({1}) in);'''
 209     print pinmunge(mux_interfacetest.format(0,1))
 210     print pinmunge(mux_interface.ifacefmt(0, 1))
 211     from interface_def import mux_interface_def
 212     print repr(mux_interface_def.format(0, 1))
 213     print repr(mux_interface.ifacedef(0, 1))
 214     assert mux_interface_def.format(0,1) == mux_interface.ifacedef(0,1)
 215