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         self.name = name
  15         self.ready = ready
  16         self.enabled = enabled
  17         self.io = io
  18         self.action = action
  19
  20     def __str__(self):
  21         res = '    '
  22         status = []
  23         if self.ready:
  24             status.append('always_ready')
  25         if self.enabled:
  26             status.append('always_enabled')
  27         if self.io:
  28             status.append('result="io"')
  29         if status:
  30             res += '(*'
  31             res += ','.join(status)
  32             res += '*)'
  33         res += " method "
  34         if self.action:
  35             res += " Action "
  36             res += self.name
  37             res += ' (Bit#(1) in)'
  38         else:
  39             res += " Bit#(1) "
  40             res += self.name
  41         res += ";"
  42         return res
  43
  44
  45 class Interface(object):
  46     """ create an interface from a list of pinspecs.
  47         each pinspec is a dictionary, see Pin class arguments
  48     """
  49
  50     def __init__(self, pinspecs):
  51         self.pins = []
  52         for p in pinspecs:
  53             if p.get('outen') is True:  # special case, generate 3 pins
  54                 _p = {}
  55                 _p.update(p)
  56                 del _p['outen']
  57                 for psuffix in ['out', 'outen', 'in']:
  58                     _p['name'] = "%s_%s" % (p['name'], psuffix)
  59                     _p['action'] = psuffix != 'in'
  60                     self.pins.append(Pin(**_p))
  61             else:
  62                 self.pins.append(Pin(**p))
  63
  64     def __str__(self):
  65         return '\n'.join(map(str, self.pins))
  66
  67     def format(self, i):
  68         return str(self).format(i)
  69
  70 # basic test
  71 if __name__ == '__main__':
  72
  73     def _pinmunge(p, sep, repl, dedupe=True):
  74         """ munges the text so it's easier to compare.
  75             splits by separator, strips out blanks, re-joins.
  76         """
  77         p = p.strip()
  78         p = p.split(sep)
  79         if dedupe:
  80             p = filter(lambda x: x, p)  # filter out blanks
  81         return repl.join(p)
  82
  83     def pinmunge(p):
  84         """ munges the text so it's easier to compare.
  85         """
  86         # first join lines by semicolons, strip out returns
  87         p = p.split(";")
  88         p = map(lambda x: x.replace('\n', ''), p)
  89         p = '\n'.join(p)
  90         # now split first by brackets, then spaces (deduping on spaces)
  91         p = _pinmunge(p, "(", " ( ", False)
  92         p = _pinmunge(p, ")", " ) ", False)
  93         p = _pinmunge(p, " ", " ")
  94         return p
  95
  96 # ========= Interface declarations ================ #
  97
  98 mux_interface = '''
  99       method Action cell{0}_mux(Bit#({1}) in);'''
 100
 101 io_interface = Interface([{'name': 'io_outputval_{0}', 'enabled': False},
 102                           {'name': 'io_output_en_{0}', 'enabled': False},
 103                           {'name': 'io_input_en_{0}', 'enabled': False},
 104                           {'name': 'io_pullup_en_{0}', 'enabled': False},
 105                           {'name': 'io_pulldown_en_{0}', 'enabled': False},
 106                           {'name': 'io_drivestrength_{0}', 'enabled': False},
 107                           {'name': 'io_pushpull_en_{0}', 'enabled': False},
 108                           {'name': 'io_opendrain_en_{0}', 'enabled': False},
 109                           {'name': 'io_inputval_{0}', 'action': True, 'io': True},
 110                           ])
 111
 112 # == Peripheral Interface definitions == #
 113 # these are the interface of the peripherals to the pin mux
 114 # Outputs from the peripherals will be inputs to the pinmux
 115 # module. Hence the change in direction for most pins
 116
 117 uartinterface_decl = Interface([{'name': 'tx_{0}', 'action': True},
 118                                 {'name': 'rx_{0}'},
 119                                 ])
 120
 121 spiinterface_decl = Interface([{'name': 'sclk_{0}', 'action': True},
 122                                {'name': 'mosi_{0}', 'action': True},
 123                                {'name': 'ss_{0}', 'action': True},
 124                                {'name': 'miso_{0}'},
 125                                ])
 126
 127 twiinterface_decl = Interface([{'name': 'sda{0}', 'outen': True},
 128                                {'name': 'scl{0}', 'outen': True},
 129                                ])
 130
 131 sdinterface_decl = Interface([{'name': 'sd{0}_clk', 'action': True},
 132                               {'name': 'sd{0}_cmd', 'action': True},
 133                               {'name': 'sd{0}_d0', 'outen': True},
 134                               {'name': 'sd{0}_d1', 'outen': True},
 135                               {'name': 'sd{0}_d2', 'outen': True},
 136                               {'name': 'sd{0}_d3', 'outen': True}
 137                               ])
 138
 139 jtaginterface_decl = Interface([{'name': 'jtag{0}_tdi'},
 140                                 {'name': 'jtag{0}_tms'},
 141                                 {'name': 'jtag{0}_tclk'},
 142                                 {'name': 'jtag{0}_trst'},
 143                                 {'name': 'jtag{0}_tdo', 'action': True}])
 144
 145 pwminterface_decl = Interface([{'name': "pwm{0}", 'action': True}])
 146
 147 # ======================================= #