src/bsv/peripheral_gen.py

   1 import types
   2 from copy import deepcopy
   3
   4
   5 class PBase(object):
   6     def __init__(self, name):
   7         self.name = name
   8
   9     def axibase(self, name, ifacenum):
  10         name = name.upper()
  11         return "%(name)s%(ifacenum)dBase" % locals()
  12
  13     def axiend(self, name, ifacenum):
  14         name = name.upper()
  15         return "%(name)s%(ifacenum)dEnd" % locals()
  16
  17     def axi_reg_def(self, start, name, ifacenum):
  18         name = name.upper()
  19         offs = self.num_axi_regs32() * 4 * 16
  20         end = start + offs - 1
  21         bname = self.axibase(name, ifacenum)
  22         bend = self.axiend(name, ifacenum)
  23         comment = "%d 32-bit regs" % self.num_axi_regs32()
  24         return ("    `define %(bname)s 'h%(start)08X\n"
  25                 "    `define %(bend)s  'h%(end)08X // %(comment)s" % locals(),
  26                 offs)
  27
  28     def axi_slave_name(self, name, ifacenum):
  29         name = name.upper()
  30         return "{0}{1}_slave_num".format(name, ifacenum)
  31
  32     def axi_slave_idx(self, idx, name, ifacenum):
  33         name = self.axi_slave_name(name, ifacenum)
  34         return ("typedef {0} {1};".format(idx, name), 1)
  35
  36     def axi_addr_map(self, name, ifacenum):
  37         bname = self.axibase(name, ifacenum)
  38         bend = self.axiend(name, ifacenum)
  39         name = self.axi_slave_name(name, ifacenum)
  40         return """\
  41         if(addr>=`{0} && addr<=`{1})
  42             return tuple2(True,fromInteger(valueOf({2})));
  43         else""".format(bname, bend, name)
  44
  45     def mk_pincon(self, name, count):
  46         # TODO: really should be using bsv.interface_decl.Interfaces
  47         # pin-naming rules.... logic here is hard-coded to duplicate
  48         # it (see Interface.__init__ outen)
  49         ret = []
  50         for p in self.peripheral.pinspecs:
  51             typ = p['type']
  52             pname = p['name']
  53             #n = "{0}{1}".format(self.name, self.mksuffix(name, count))
  54             n = name  # "{0}{1}".format(self.name, self.mksuffix(name, count))
  55             ret.append("    //%s %s" % (n, str(p)))
  56             sname = self.peripheral.pname(pname).format(count)
  57             ps = "pinmux.peripheral_side.%s" % sname
  58             if typ == 'out' or typ == 'inout':
  59                 ret.append("    rule con_%s%d_%s_out;" % (name, count, pname))
  60                 fname = self.pinname_out(pname)
  61                 if fname:
  62                     if p.get('outen'):
  63                         ps_ = ps + '_out'
  64                     else:
  65                         ps_ = ps
  66                     n_ = "{0}{1}".format(n, count)
  67                     ret.append("      {0}({1}.{2});".format(ps_, n_, fname))
  68                 fname = None
  69                 if p.get('outen'):
  70                     fname = self.pinname_outen(pname)
  71                 if fname:
  72                     if isinstance(fname, str):
  73                         fname = "{0}{1}.{2}".format(n, count, fname)
  74                     fname = self.pinname_tweak(pname, 'outen', fname)
  75                     ret.append("      {0}_outen({1});".format(ps, fname))
  76                 ret.append("    endrule")
  77             if typ == 'in' or typ == 'inout':
  78                 fname = self.pinname_in(pname)
  79                 if fname:
  80                     if p.get('outen'):
  81                         ps_ = ps + '_in'
  82                     else:
  83                         ps_ = ps
  84                     ret.append(
  85                         "    rule con_%s%d_%s_in;" %
  86                         (name, count, pname))
  87                     ret.append("      {1}.{2}({0});".format(ps_, n, fname))
  88                     ret.append("    endrule")
  89         return '\n'.join(ret)
  90
  91     def mk_cellconn(self, *args):
  92         return ''
  93
  94     def mkslow_peripheral(self, size=0):
  95         return ''
  96
  97     def mksuffix(self, name, i):
  98         return i
  99
 100     def __mk_connection(self, con, aname):
 101         txt = "        mkConnection (slow_fabric.v_to_slaves\n" + \
 102             "                    [fromInteger(valueOf({1}))],\n" + \
 103             "                    {0});"
 104
 105         print "PBase __mk_connection", self.name, aname
 106         if not con:
 107             return ''
 108         return txt.format(con, aname)
 109
 110     def mk_connection(self, count, name=None):
 111         if name is None:
 112             name = self.name
 113         print "PBase mk_conn", self.name, count
 114         aname = self.axi_slave_name(name, count)
 115         #dname = self.mksuffix(name, count)
 116         #dname = "{0}{1}".format(name, dname)
 117         con = self._mk_connection(name, count).format(count, aname)
 118         return self.__mk_connection(con, aname)
 119
 120     def _mk_connection(self, name=None, count=0):
 121         return ''
 122
 123     def pinname_out(self, pname):
 124         return ''
 125
 126     def pinname_in(self, pname):
 127         return ''
 128
 129     def pinname_outen(self, pname):
 130         return ''
 131
 132     def pinname_tweak(self, pname, typ, txt):
 133         return txt
 134
 135
 136 class uart(PBase):
 137
 138     def slowimport(self):
 139         return "          import Uart16550         :: *;"
 140
 141     def slowifdecl(self):
 142         return "            interface RS232_PHY_Ifc uart{0}_coe;\n" + \
 143                "            method Bit#(1) uart{0}_intr;"
 144
 145     def num_axi_regs32(self):
 146         return 8
 147
 148     def mkslow_peripheral(self, size=0):
 149         return "        Uart16550_AXI4_Lite_Ifc uart{0} <- \n" + \
 150                "                mkUart16550(clocked_by uart_clock,\n" + \
 151                "                    reset_by uart_reset, sp_clock, sp_reset);"
 152
 153     def _mk_connection(self, name=None, count=0):
 154         return "uart{0}.slave_axi_uart"
 155
 156     def pinname_out(self, pname):
 157         return {'tx': 'coe_rs232.sout'}.get(pname, '')
 158
 159     def pinname_in(self, pname):
 160         return {'rx': 'coe_rs232.sin'}.get(pname, '')
 161
 162
 163 class rs232(PBase):
 164
 165     def slowimport(self):
 166         return "        import Uart_bs::*;\n" + \
 167                "        import RS232_modified::*;"
 168
 169     def slowifdecl(self):
 170         return "            interface RS232 uart{0}_coe;"
 171
 172     def num_axi_regs32(self):
 173         return 2
 174
 175     def mkslow_peripheral(self, size=0):
 176         return "        //Ifc_Uart_bs uart{0} <-" + \
 177                "        //       mkUart_bs(clocked_by uart_clock,\n" + \
 178                "        //          reset_by uart_reset,sp_clock, sp_reset);" +\
 179                "        Ifc_Uart_bs uart{0} <-" + \
 180                "                mkUart_bs(clocked_by sp_clock,\n" + \
 181                "                    reset_by sp_reset, sp_clock, sp_reset);"
 182
 183     def _mk_connection(self, name=None, count=0):
 184         return "uart{0}.slave_axi_uart"
 185
 186     def pinname_out(self, pname):
 187         return {'tx': 'coe_rs232.sout'}.get(pname, '')
 188
 189     def pinname_in(self, pname):
 190         return {'rx': 'coe_rs232.sin'}.get(pname, '')
 191
 192
 193 class twi(PBase):
 194
 195     def slowimport(self):
 196         return "        import I2C_top           :: *;"
 197
 198     def slowifdecl(self):
 199         return "            interface I2C_out twi{0}_out;\n" + \
 200                "            method Bit#(1) twi{0}_isint;"
 201
 202     def num_axi_regs32(self):
 203         return 8
 204
 205     def mkslow_peripheral(self, size=0):
 206         return "        I2C_IFC twi{0} <- mkI2CController();"
 207
 208     def _mk_connection(self, name=None, count=0):
 209         return "twi{0}.slave_i2c_axi"
 210
 211     def pinname_out(self, pname):
 212         return {'sda': 'out.sda_out',
 213                 'scl': 'out.scl_out'}.get(pname, '')
 214
 215     def pinname_in(self, pname):
 216         return {'sda': 'out.sda_in',
 217                 'scl': 'out.scl_in'}.get(pname, '')
 218
 219     def pinname_outen(self, pname):
 220         return {'sda': 'out.sda_outen',
 221                 'scl': 'out.scl_outen'}.get(pname, '')
 222
 223     def pinname_tweak(self, pname, typ, txt):
 224         if typ == 'outen':
 225             return "pack({0})".format(txt)
 226         return txt
 227
 228
 229 class qspi(PBase):
 230
 231     def slowimport(self):
 232         return "        import qspi              :: *;"
 233
 234     def slowifdecl(self):
 235         return "            interface QSPI_out qspi{0}_out;\n" + \
 236                "            method Bit#(1) qspi{0}_isint;"
 237
 238     def num_axi_regs32(self):
 239         return 13
 240
 241     def mkslow_peripheral(self, size=0):
 242         return "        Ifc_qspi qspi{0} <-  mkqspi();"
 243
 244     def _mk_connection(self, name=None, count=0):
 245         return "qspi{0}.slave"
 246
 247     def pinname_out(self, pname):
 248         return {'ck': 'out.clk_o',
 249                 'nss': 'out.ncs_o',
 250                 'io0': 'out.io_o[0]',
 251                 'io1': 'out.io_o[1]',
 252                 'io2': 'out.io_o[2]',
 253                 'io3': 'out.io_o[3]',
 254                 }.get(pname, '')
 255
 256     def pinname_outen(self, pname):
 257         return {'ck': 1,
 258                 'nss': 1,
 259                 'io0': 'out.io_enable[0]',
 260                 'io1': 'out.io_enable[1]',
 261                 'io2': 'out.io_enable[2]',
 262                 'io3': 'out.io_enable[3]',
 263                 }.get(pname, '')
 264
 265     def mk_pincon(self, name, count):
 266         ret = [PBase.mk_pincon(self, name, count)]
 267         # special-case for gpio in, store in a temporary vector
 268         plen = len(self.peripheral.pinspecs)
 269         ret.append("    // XXX NSS and CLK are hard-coded master")
 270         ret.append("    // TODO: must add qspi slave-mode")
 271         ret.append("    // all ins done in one rule from 4-bitfield")
 272         ret.append("    rule con_%s%d_io_in;" % (name, count))
 273         ret.append("       {0}{1}.out.io_i({{".format(name, count))
 274         for i, p in enumerate(self.peripheral.pinspecs):
 275             typ = p['type']
 276             pname = p['name']
 277             if not pname.startswith('io'):
 278                 continue
 279             idx = pname[1:]
 280             n = name
 281             sname = self.peripheral.pname(pname).format(count)
 282             ps = "pinmux.peripheral_side.%s_in" % sname
 283             comma = '' if i == 5 else ','
 284             ret.append("            {0}{1}".format(ps, comma))
 285         ret.append("        });")
 286         ret.append("    endrule")
 287         return '\n'.join(ret)
 288
 289
 290 class pwm(PBase):
 291
 292     def slowimport(self):
 293         return "        import pwm::*;"
 294
 295     def slowifdecl(self):
 296         return "        interface PWMIO pwm{0}_o;"
 297
 298     def num_axi_regs32(self):
 299         return 4
 300
 301     def mkslow_peripheral(self, size=0):
 302         return "        Ifc_PWM_bus pwm{0}_bus <- mkPWM_bus(sp_clock);"
 303
 304     def _mk_connection(self, name=None, count=0):
 305         return "pwm{0}_bus.axi4_slave"
 306
 307     def pinname_out(self, pname):
 308         return {'out': 'pwm_io.pwm_o'}.get(pname, '')
 309
 310
 311 class gpio(PBase):
 312
 313     def slowimport(self):
 314         return "     import pinmux::*;\n" + \
 315                "     import mux::*;\n" + \
 316                "     import gpio::*;\n"
 317
 318     def slowifdecl(self):
 319         return "        interface GPIO_config#({1}) pad_config{0};"
 320
 321     def num_axi_regs32(self):
 322         return 2
 323
 324     def axi_slave_idx(self, idx, name, ifacenum):
 325         """ generates AXI slave number definition, except
 326             GPIO also has a muxer per bank
 327         """
 328         name = name.upper()
 329         mname = 'mux' + name[4:]
 330         mname = mname.upper()
 331         print "AXIslavenum", name,  mname
 332         (ret, x) = PBase.axi_slave_idx(self, idx, name, ifacenum)
 333         (ret2, x) = PBase.axi_slave_idx(self, idx, mname, ifacenum)
 334         return ("%s\n%s" % (ret, ret2), 2)
 335
 336     def mkslow_peripheral(self, size=0):
 337         print "gpioslow", self.peripheral,  dir(self.peripheral)
 338         size = len(self.peripheral.pinspecs)
 339         return "        MUX#(%d) mux{0} <- mkmux();\n" % size + \
 340                "        GPIO#(%d) gpio{0} <- mkgpio();" % size
 341
 342     def mk_connection(self, count):
 343         print "GPIO mk_conn", self.name, count
 344         res = []
 345         dname = self.mksuffix(self.name, count)
 346         for i, n in enumerate(['gpio' + dname, 'mux' + dname]):
 347             res.append(PBase.mk_connection(self, count, n))
 348         return '\n'.join(res)
 349
 350     def _mk_connection(self, name=None, count=0):
 351         n = self.mksuffix(name, count)
 352         if name.startswith('gpio'):
 353             return "gpio{0}.axi_slave".format(n)
 354         if name.startswith('mux'):
 355             return "mux{0}.axi_slave".format(n)
 356
 357     def mksuffix(self, name, i):
 358         if name.startswith('mux'):
 359             return name[3:]
 360         return name[4:]
 361
 362     def mk_cellconn(self, cellnum, name, count):
 363         ret = []
 364         bank = self.mksuffix(name, count)
 365         txt = "       pinmux.mux_lines.cell{0}_mux(mux{1}.mux_config.mux[{2}]);"
 366         for p in self.peripheral.pinspecs:
 367             ret.append(txt.format(cellnum, bank, p['name'][1:]))
 368             cellnum += 1
 369         return ("\n".join(ret), cellnum)
 370
 371     def pinname_out(self, pname):
 372         return "func.gpio_out[{0}]".format(pname[1:])
 373
 374     def pinname_outen(self, pname):
 375         return {'sda': 'out.sda_outen',
 376                 'scl': 'out.scl_outen'}.get(pname, '')
 377
 378     def mk_pincon(self, name, count):
 379         ret = [PBase.mk_pincon(self, name, count)]
 380         # special-case for gpio in, store in a temporary vector
 381         plen = len(self.peripheral.pinspecs)
 382         ret.append("    rule con_%s%d_in;" % (name, count))
 383         ret.append("       Vector#({0},Bit#(1)) temp;".format(plen))
 384         for p in self.peripheral.pinspecs:
 385             typ = p['type']
 386             pname = p['name']
 387             idx = pname[1:]
 388             n = name
 389             sname = self.peripheral.pname(pname).format(count)
 390             ps = "pinmux.peripheral_side.%s_in" % sname
 391             ret.append("        temp[{0}]={1};".format(idx, ps))
 392         ret.append("        {0}.func.gpio_in(temp);".format(name))
 393         ret.append("    endrule")
 394         return '\n'.join(ret)
 395
 396
 397 axi_slave_declarations = """\
 398 typedef  0  SlowMaster;
 399 {0}
 400 typedef  TAdd#(LastGen_slave_num,`ifdef CLINT       1 `else 0 `endif )
 401               CLINT_slave_num;
 402 typedef  TAdd#(CLINT_slave_num  ,`ifdef PLIC        1 `else 0 `endif )
 403               Plic_slave_num;
 404 typedef  TAdd#(Plic_slave_num   ,`ifdef AXIEXP      1 `else 0 `endif )
 405               AxiExp1_slave_num;
 406 typedef TAdd#(AxiExp1_slave_num,1) Num_Slow_Slaves;
 407 """
 408
 409 pinmux_cellrule = """\
 410     rule connect_select_lines_pinmux;
 411 {0}
 412     endrule
 413 """
 414
 415
 416 class CallFn(object):
 417     def __init__(self, peripheral, name):
 418         self.peripheral = peripheral
 419         self.name = name
 420
 421     def __call__(self, *args):
 422         #print "__call__", self.name, self.peripheral.slow, args
 423         if not self.peripheral.slow:
 424             return ''
 425         return getattr(self.peripheral.slow, self.name)(*args[1:])
 426
 427
 428 class PeripheralIface(object):
 429     def __init__(self, ifacename):
 430         self.slow = None
 431         slow = slowfactory.getcls(ifacename)
 432         print "Iface", ifacename, slow
 433         if slow:
 434             self.slow = slow(ifacename)
 435             self.slow.peripheral = self
 436         for fname in ['slowimport', 'slowifdecl', 'mkslow_peripheral',
 437                       'mk_connection', 'mk_cellconn', 'mk_pincon']:
 438             fn = CallFn(self, fname)
 439             setattr(self, fname, types.MethodType(fn, self))
 440
 441         #print "PeripheralIface"
 442         #print dir(self)
 443
 444     def mksuffix(self, name, i):
 445         if self.slow is None:
 446             return i
 447         return self.slow.mksuffix(name, i)
 448
 449     def axi_reg_def(self, start, count):
 450         if not self.slow:
 451             return ('', 0)
 452         return self.slow.axi_reg_def(start, self.ifacename, count)
 453
 454     def axi_slave_idx(self, start, count):
 455         if not self.slow:
 456             return ('', 0)
 457         return self.slow.axi_slave_idx(start, self.ifacename, count)
 458
 459     def axi_addr_map(self, count):
 460         if not self.slow:
 461             return ''
 462         return self.slow.axi_addr_map(self.ifacename, count)
 463
 464
 465 class PeripheralInterfaces(object):
 466     def __init__(self):
 467         pass
 468
 469     def slowimport(self, *args):
 470         ret = []
 471         for (name, count) in self.ifacecount:
 472             #print "slowimport", name, self.data[name].slowimport
 473             ret.append(self.data[name].slowimport())
 474         return '\n'.join(list(filter(None, ret)))
 475
 476     def slowifdecl(self, *args):
 477         ret = []
 478         for (name, count) in self.ifacecount:
 479             for i in range(count):
 480                 ret.append(self.data[name].slowifdecl().format(i, name))
 481         return '\n'.join(list(filter(None, ret)))
 482
 483     def axi_reg_def(self, *args):
 484         ret = []
 485         start = 0x00011100  # start of AXI peripherals address
 486         for (name, count) in self.ifacecount:
 487             for i in range(count):
 488                 x = self.data[name].axi_reg_def(start, i)
 489                 #print ("ifc", name, x)
 490                 (rdef, offs) = x
 491                 ret.append(rdef)
 492                 start += offs
 493         return '\n'.join(list(filter(None, ret)))
 494
 495     def axi_slave_idx(self, *args):
 496         ret = []
 497         start = 0
 498         for (name, count) in self.ifacecount:
 499             for i in range(count):
 500                 (rdef, offs) = self.data[name].axi_slave_idx(start, i)
 501                 #print ("ifc", name, rdef, offs)
 502                 ret.append(rdef)
 503                 start += offs
 504         ret.append("typedef %d LastGen_slave_num;" % (start - 1))
 505         decls = '\n'.join(list(filter(None, ret)))
 506         return axi_slave_declarations.format(decls)
 507
 508     def axi_addr_map(self, *args):
 509         ret = []
 510         for (name, count) in self.ifacecount:
 511             for i in range(count):
 512                 ret.append(self.data[name].axi_addr_map(i))
 513         return '\n'.join(list(filter(None, ret)))
 514
 515     def mkslow_peripheral(self, *args):
 516         ret = []
 517         for (name, count) in self.ifacecount:
 518             for i in range(count):
 519                 print "mkslow", name, count
 520                 x = self.data[name].mkslow_peripheral()
 521                 print name, count, x
 522                 suffix = self.data[name].mksuffix(name, i)
 523                 ret.append(x.format(suffix))
 524         return '\n'.join(list(filter(None, ret)))
 525
 526     def mk_connection(self, *args):
 527         ret = []
 528         for (name, count) in self.ifacecount:
 529             for i in range(count):
 530                 print "mk_conn", name, i
 531                 txt = self.data[name].mk_connection(i)
 532                 if name == 'gpioa':
 533                     print "txt", txt
 534                     print self.data[name].mk_connection
 535                 ret.append(txt)
 536         return '\n'.join(list(filter(None, ret)))
 537
 538     def mk_cellconn(self):
 539         ret = []
 540         cellcount = 0
 541         for (name, count) in self.ifacecount:
 542             for i in range(count):
 543                 res = self.data[name].mk_cellconn(cellcount, name, i)
 544                 if not res:
 545                     continue
 546                 (txt, cellcount) = res
 547                 ret.append(txt)
 548         ret = '\n'.join(list(filter(None, ret)))
 549         return pinmux_cellrule.format(ret)
 550
 551     def mk_pincon(self):
 552         ret = []
 553         for (name, count) in self.ifacecount:
 554             for i in range(count):
 555                 txt = self.data[name].mk_pincon(name, i)
 556                 ret.append(txt)
 557         return '\n'.join(list(filter(None, ret)))
 558
 559
 560 class PFactory(object):
 561     def getcls(self, name):
 562         for k, v in {'uart': uart,
 563                      'rs232': rs232,
 564                      'twi': twi,
 565                      'qspi': qspi,
 566                      'pwm': pwm,
 567                      'gpio': gpio
 568                      }.items():
 569             if name.startswith(k):
 570                 return v
 571         return None
 572
 573
 574 slowfactory = PFactory()
 575
 576 if __name__ == '__main__':
 577     p = uart('uart')
 578     print p.slowimport()
 579     print p.slowifdecl()
 580     i = PeripheralIface('uart')
 581     print i, i.slow
 582     i = PeripheralIface('gpioa')
 583     print i, i.slow