src/bsv/peripheral_gen/gpio.py

   1 from bsv.peripheral_gen.base import PBase
   2
   3
   4 class gpio(PBase):
   5
   6     def slowimport(self):
   7         return "import pinmux::*;\n" + \
   8                "import mux::*;\n" + \
   9                "import gpio::*;\n"
  10
  11     def extifinstance2(self, name, count):
  12         template = "interface pad_config{0} = {1}.pad_config;"
  13         dname = self.mksuffix(self.name, count)
  14         return template.format(dname, name)
  15
  16     def slowifdeclmux(self, name, count):
  17         size = len(self.peripheral.pinspecs)
  18         dname = self.mksuffix(self.name, count)
  19         return "interface GPIO_config#(%d) pad_config%s;" % \
  20             (size, dname)
  21
  22     def num_axi_regs32(self):
  23         return 2
  24
  25     def axi_slave_idx(self, idx, name, ifacenum, typ):
  26         """ generates AXI slave number definition, except
  27             GPIO also has a muxer per bank
  28         """
  29         name = name.upper()
  30         mname = 'mux' + name[4:]
  31         mname = mname.upper()
  32         print "AXIslavenum", name, mname
  33         (ret, x) = PBase.axi_slave_idx(self, idx, name, ifacenum, typ)
  34         (ret2, x) = PBase.axi_slave_idx(self, idx + 1, mname, ifacenum, typ)
  35         return ("%s\n%s" % (ret, ret2), 2)
  36
  37     def mkslow_peripheral(self, size=0):
  38         print "gpioslow", self.peripheral, dir(self.peripheral)
  39         size = len(self.peripheral.pinspecs)
  40         dflt = "'b%s" % ("0"*size*2)
  41         return "MUX#(%d) mux{0} <- mkmux(%s);\n" % (size, dflt)+ \
  42                "GPIO#(%d) gpio{0} <- mkgpio();" % size
  43
  44     def mk_connection(self, count, fabricname, typ):
  45         print "GPIO mk_conn", self.name, count
  46         res = []
  47         dname = self.mksuffix(self.name, count)
  48         for i, n in enumerate(['gpio' + dname, 'mux' + dname]):
  49             res.append(PBase.mk_connection(self, count, fabricname, typ, n))
  50         return '\n'.join(res)
  51
  52     def _mk_connection(self, name=None, count=0):
  53         n = self.mksuffix(name, count)
  54         if name.startswith('gpio'):
  55             return "gpio{0}.axi_slave".format(n)
  56         if name.startswith('mux'):
  57             return "mux{0}.axi_slave".format(n)
  58
  59     def mksuffix(self, name, i):
  60         if name.startswith('mux'):
  61             return name[3:]
  62         return name[4:]
  63
  64     def mk_cellconn(self, cellnum, name, count):
  65         ret = []
  66         bank = self.mksuffix(name, count)
  67         txt = "pinmux.mux_lines.cell{0}_mux(mux{1}.mux_config.mux[{2}]);"
  68         for p in self.peripheral.pinspecs:
  69             ret.append(txt.format(cellnum, bank, p['name'][1:]))
  70             cellnum += 1
  71         return ("\n".join(ret), cellnum)
  72
  73     def pinname_out(self, pname):
  74         return "func.gpio_out[{0}]".format(pname[1:])
  75
  76     def pinname_outen(self, pname):
  77         return "func.gpio_out_en[{0}]".format(pname[1:])
  78
  79     def _mk_pincon(self, name, count, typ):
  80         #ret = [PBase.mk_pincon(self, name, count)]
  81         # special-case for gpio in, store in a temporary vector
  82         assert typ == 'slow'
  83         ret = []
  84         plen = len(self.peripheral.pinspecs)
  85         template = "mkConnection({0}.{1},\n\t\t\t{2}_{1});"
  86         ps = "pinmux.peripheral_side.%s" % name
  87         n = "{0}.func.gpio".format(name)
  88         for ptype in ['out', 'out_en', 'in']:
  89             ret.append(template.format(ps, ptype, n))
  90         return '\n'.join(ret)