src/bsv/peripheral_gen/gpio.py

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