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)).format(*args)
 108         return '\n' + res + '\n'
 109
 110
 111 class IOInterface(Interface):
 112
 113     def ifacefmtoutfn(self, name):
 114         return "cell{0}_mux_out.%s" % (name[3:-4])
 115
 116     def ifacefmtinfn(self, name):
 117         return "cell{0}_mux_in"
 118
 119
 120 # ========= Interface declarations ================ #
 121
 122 mux_interface = Interface([{'name': 'cell{0}_mux', 'ready':False,
 123                       'enabled':False,
 124                      'bitspec': '{1}', 'action': True}])
 125
 126 io_interface = IOInterface([{'name': 'io_outputval_{0}', 'enabled': False},
 127                           {'name': 'io_output_en_{0}', 'enabled': False},
 128                           {'name': 'io_input_en_{0}', 'enabled': False},
 129                           {'name': 'io_pullup_en_{0}', 'enabled': False},
 130                           {'name': 'io_pulldown_en_{0}', 'enabled': False},
 131                           {'name': 'io_drivestrength_{0}', 'enabled': False},
 132                           {'name': 'io_pushpull_en_{0}', 'enabled': False},
 133                           {'name': 'io_opendrain_en_{0}', 'enabled': False},
 134                           {'name': 'io_inputval_{0}', 'action': True, 'io': True},
 135                           ])
 136
 137 # == Peripheral Interface definitions == #
 138 # these are the interface of the peripherals to the pin mux
 139 # Outputs from the peripherals will be inputs to the pinmux
 140 # module. Hence the change in direction for most pins
 141
 142 uartinterface_decl = Interface([{'name': 'uart{0}_rx'},
 143                                 {'name': 'uart{0}_tx', 'action': True},
 144                                 ])
 145
 146 spiinterface_decl = Interface([{'name': 'spi{0}_sclk', 'action': True},
 147                                {'name': 'spi{0}_mosi', 'action': True},
 148                                {'name': 'spi{0}_nss', 'action': True},
 149                                {'name': 'spi{0}_miso'},
 150                                ])
 151
 152 twiinterface_decl = Interface([{'name': 'sda{0}', 'outen': True},
 153                                {'name': 'scl{0}', 'outen': True},
 154                                ])
 155
 156 sdinterface_decl = Interface([{'name': 'sd{0}_clk', 'action': True},
 157                               {'name': 'sd{0}_cmd', 'action': True},
 158                               {'name': 'sd{0}_d0', 'outen': True},
 159                               {'name': 'sd{0}_d1', 'outen': True},
 160                               {'name': 'sd{0}_d2', 'outen': True},
 161                               {'name': 'sd{0}_d3', 'outen': True}
 162                               ])
 163
 164 jtaginterface_decl = Interface([{'name': 'jtag{0}_tdi'},
 165                                 {'name': 'jtag{0}_tms'},
 166                                 {'name': 'jtag{0}_tclk'},
 167                                 {'name': 'jtag{0}_trst'},
 168                                 {'name': 'jtag{0}_tdo', 'action': True}])
 169
 170 pwminterface_decl = Interface([{'name': "pwm{0}", 'action': True}])
 171
 172 # ======================================= #
 173
 174 # basic test
 175 if __name__ == '__main__':
 176
 177     def _pinmunge(p, sep, repl, dedupe=True):
 178         """ munges the text so it's easier to compare.
 179             splits by separator, strips out blanks, re-joins.
 180         """
 181         p = p.strip()
 182         p = p.split(sep)
 183         if dedupe:
 184             p = filter(lambda x: x, p)  # filter out blanks
 185         return repl.join(p)
 186
 187     def pinmunge(p):
 188         """ munges the text so it's easier to compare.
 189         """
 190         # first join lines by semicolons, strip out returns
 191         p = p.split(";")
 192         p = map(lambda x: x.replace('\n', ''), p)
 193         p = '\n'.join(p)
 194         # now split first by brackets, then spaces (deduping on spaces)
 195         p = _pinmunge(p, "(", " ( ", False)
 196         p = _pinmunge(p, ")", " ) ", False)
 197         p = _pinmunge(p, " ", " ")
 198         return p
 199
 200     from interface_def import io_interface_def
 201     print io_interface_def.format(0)
 202     print io_interface.ifacedef(0)
 203     assert io_interface_def.format(0) == io_interface.ifacedef(0)
 204
 205     mux_interfacetest = '''
 206           method Action cell{0}_mux(Bit#({1}) in);'''
 207     print pinmunge(mux_interfacetest.format(0,1))
 208     print pinmunge(mux_interface.ifacefmt(0, 1))
 209     from interface_def import mux_interface_def
 210     print repr(mux_interface_def.format(0, 1))
 211     print repr(mux_interface.ifacedef(0, 1))
 212     assert mux_interface_def.format(0,1) == mux_interface.ifacedef(0,1)
 213