src/spec/interfaces.py

   1 #!/usr/bin/env python
   2
   3 from copy import deepcopy
   4
   5 class Pinouts(object):
   6     def __init__(self):
   7         self.pins = {}
   8         self.fnspec = {}
   9
  10     def has_key(self, k):
  11         return self.pins.has_key(k)
  12
  13     def add_spec(self, k, v):
  14         self.fnspec[k] = v
  15
  16     def update(self, pinidx, v):
  17         if not self.pins.has_key(pinidx):
  18             self.pins[pinidx] = v
  19         else:
  20             self.pins[pinidx].update(v)
  21
  22     def keys(self):
  23         return self.pins.keys()
  24
  25     def items(self):
  26         return self.pins.items()
  27
  28     def get(self, k):
  29         return self.pins[k]
  30
  31     def __len__(self):
  32         return len(self.pins)
  33
  34     def __delitem__(self, k):
  35         del self.pins[k]
  36
  37
  38 class Pins(object):
  39
  40     def __init__(self, fname, pingroup, bankspec, suffix, offs, bank, mux,
  41              spec=None, limit=None, origsuffix=None):
  42         self.fname = fname
  43         self.pingroup = pingroup
  44         self.bankspec = bankspec
  45         self.suffix = suffix
  46         self.origsuffix = origsuffix or suffix
  47         self.bank = bank
  48         self.mux = mux
  49
  50         res = {}
  51         names = {}
  52         idx = 0
  53         for name in pingroup[:limit]:
  54             if suffix:
  55                 name_ = "%s_%s" % (name, suffix)
  56             else:
  57                 name_ = name
  58             if spec and spec.has_key(name):
  59                 continue
  60             pin = {mux: (name_, bank)}
  61             offs_bank, offs_ = offs
  62             idx_ = offs_ + idx
  63             idx += 1
  64             idx_ += bankspec[bank]
  65             res[idx_] = pin
  66             names[name] = idx_
  67         for name in pingroup:
  68             if suffix:
  69                 name_ = "%s_%s" % (name, suffix)
  70             else:
  71                 name_ = name
  72             if not spec:
  73                 continue
  74             if not spec.has_key(name):
  75                 continue
  76             idx_, mux_, bank_ = spec[name]
  77             idx_ = names[idx_]
  78             #idx_ += bankspec[bank_]
  79             pin = {mux_: (name_, bank_)}
  80             if res.has_key(idx_):
  81                 res[idx_].update(pin)
  82             else:
  83                 res[idx_] = pin
  84
  85         self.pins = res
  86
  87
  88 def i2s(bankspec, suffix, offs, bank, mux=1, spec=None, limit=None):
  89     i2spins = ['IISMCK', 'IISBCK', 'IISLRCK', 'IISDI']
  90     for i in range(4):
  91         i2spins.append("IISDO%d" % i)
  92     return Pins('IIS', i2spins, bankspec, suffix, offs, bank, mux, spec, limit,
  93                 origsuffix=suffix)
  94
  95 def emmc(bankspec, suffix, offs, bank, mux=1, spec=None):
  96     emmcpins = ['MMCCMD', 'MMCCLK']
  97     for i in range(8):
  98         emmcpins.append("MMCD%d" % i)
  99     return Pins('MMC', emmcpins, bankspec, suffix, offs, bank, mux, spec,
 100                 origsuffix=suffix)
 101
 102 def sdmmc(bankspec, suffix, offs, bank, mux=1, spec=None,
 103                 start=None, limit=None):
 104     sdmmcpins = ['CMD', 'CLK']
 105     for i in range(4):
 106         sdmmcpins.append("D%d" % i)
 107     sdmmcpins = sdmmcpins[start:limit]
 108     sdmmcpins = namesuffix('SD', suffix, sdmmcpins)
 109     return Pins('SD', sdmmcpins, bankspec, '', offs, bank, mux, spec,
 110                 origsuffix=suffix)
 111
 112 def spi(bankspec, suffix, offs, bank, mux=1, spec=None):
 113     spipins = namesuffix('SPI', suffix,
 114                 ['CLK', 'NSS', 'MOSI', 'MISO', 'NSS'])
 115     return Pins('SPI', spipins, bankspec, '', offs, bank, mux, spec,
 116                 origsuffix=suffix)
 117
 118 def quadspi(bankspec, suffix, offs, bank, mux=1, spec=None, limit=None):
 119     spipins = namesuffix('QSPI', suffix,
 120                 ['CK', 'NSS', 'IO0', 'IO1', 'IO2', 'IO3'])
 121     return Pins('QSPI', spipins, bankspec, '', offs, bank, mux, spec, limit,
 122                 origsuffix=suffix)
 123
 124 def i2c(bankspec, suffix, offs, bank, mux=1, spec=None):
 125     spipins = namesuffix('TWI', suffix,
 126                 ['SDA', 'SCL'])
 127     return Pins('TWI', spipins, bankspec, '', offs, bank, mux, spec,
 128                 origsuffix=suffix)
 129
 130 def jtag(bankspec, suffix, offs, bank, mux=1, spec=None):
 131     uartpins = namesuffix('JTAG', suffix, ['MS', 'DI', 'DO', 'CK'])
 132     return Pins('JTAG', uartpins, bankspec, '', offs, bank, mux, spec,
 133                 origsuffix=suffix)
 134
 135 def uart(bankspec, suffix, offs, bank, mux=1, spec=None):
 136     uartpins = namesuffix('UART', suffix, ['TX', 'RX'])
 137     return Pins('UART', uartpins, bankspec, '', offs, bank, mux, spec,
 138                 origsuffix=suffix)
 139
 140 def namesuffix(name, suffix, namelist):
 141     names = []
 142     for n in namelist:
 143         names.append("%s%s_%s" % (name, suffix, n))
 144     return names
 145
 146 def ulpi(bankspec, suffix, offs, bank, mux=1, spec=None):
 147     ulpipins = namesuffix('ULPI', suffix, ['CK', 'DIR', 'STP', 'NXT'])
 148     for i in range(8):
 149         ulpipins.append('ULPI%s_D%d' % (suffix, i))
 150     return Pins('ULPI', ulpipins, bankspec, "", offs, bank, mux, spec,
 151                 origsuffix=suffix)
 152
 153 def uartfull(bankspec, suffix, offs, bank, mux=1, spec=None):
 154     uartpins = namesuffix('UART', suffix, ['TX', 'RX', 'CTS', 'RTS'])
 155     return Pins('UART', uartpins, bankspec, '', offs, bank, mux, spec,
 156                 origsuffix=suffix)
 157
 158 def rgbttl(bankspec, suffix, offs, bank, mux=1, spec=None):
 159     ttlpins = ['LCDCK', 'LCDDE', 'LCDHS', 'LCDVS']
 160     for i in range(24):
 161         ttlpins.append("LCD%d" % i)
 162     return Pins('LCD', ttlpins, bankspec, suffix, offs, bank, mux, spec,
 163                 origsuffix=suffix)
 164
 165 def rgmii(bankspec, suffix, offs, bank, mux=1, spec=None):
 166     buspins = []
 167     for i in range(4):
 168         buspins.append("ERXD%d" % i)
 169     for i in range(4):
 170         buspins.append("ETXD%d" % i)
 171     buspins += ['ERXCK', 'ERXERR', 'ERXDV',
 172                 'EMDC', 'EMDIO',
 173                 'ETXEN', 'ETXCK', 'ECRS',
 174                 'ECOL', 'ETXERR']
 175     buspins = namesuffix('RG', suffix, buspins)
 176     return Pins('RG', buspins, bankspec, '', offs, bank, mux, spec,
 177                 origsuffix=suffix)
 178
 179 def flexbus1(bankspec, suffix, offs, bank, mux=1, spec=None, limit=None):
 180     buspins = []
 181     for i in range(8):
 182         buspins.append("AD%d" % i)
 183     for i in range(2):
 184         buspins.append("CS%d" % i)
 185     buspins += ['ALE', 'OE', 'RW', 'TA', 'CLK',
 186                 'A0', 'A1', 'TS', 'TBST',
 187                 'TSIZ0', 'TSIZ1']
 188     for i in range(4):
 189         buspins.append("BWE%d" % i)
 190     for i in range(2,6):
 191         buspins.append("CS%d" % i)
 192     buspins = namesuffix('FB', suffix, buspins)
 193     return Pins('FB', buspins, bankspec, "", offs, bank, mux, spec, limit,
 194                 origsuffix=suffix)
 195
 196 def flexbus2(bankspec, suffix, offs, bank, mux=1, spec=None, limit=None):
 197     buspins = []
 198     for i in range(8,32):
 199         buspins.append("AD%d" % i)
 200     buspins = namesuffix('FB', suffix, buspins)
 201     return Pins('FB', buspins, bankspec, '', offs, bank, mux, spec, limit,
 202                 origsuffix=suffix)
 203
 204 def sdram1(bankspec, suffix, offs, bank, mux=1, spec=None):
 205     buspins = []
 206     for i in range(16):
 207         buspins.append("SDRDQM%d" % i)
 208     for i in range(12):
 209         buspins.append("SDRAD%d" % i)
 210     for i in range(8):
 211         buspins.append("SDRDQ%d" % i)
 212     for i in range(3):
 213         buspins.append("SDRCS%d#" % i)
 214     for i in range(2):
 215         buspins.append("SDRDQ%d" % i)
 216     for i in range(2):
 217         buspins.append("SDRBA%d" % i)
 218     buspins += ['SDRCKE', 'SDRRAS#', 'SDRCAS#', 'SDRWE#',
 219                 'SDRRST']
 220     return Pins('SDR', buspins, bankspec, suffix, offs, bank, mux, spec,
 221                 origsuffix=suffix)
 222
 223 def sdram2(bankspec, suffix, offs, bank, mux=1, spec=None, limit=None):
 224     buspins = []
 225     for i in range(3,6):
 226         buspins.append("SDRCS%d#" % i)
 227     for i in range(8,32):
 228         buspins.append("SDRDQ%d" % i)
 229     return Pins('SDR', buspins, bankspec, suffix, offs, bank, mux, spec, limit,
 230                 origsuffix=suffix)
 231
 232 def mcu8080(bankspec, suffix, offs, bank, mux=1, spec=None):
 233     buspins = []
 234     for i in range(8):
 235         buspins.append("MCUD%d" % i)
 236     for i in range(8):
 237         buspins.append("MCUAD%d" % (i+8))
 238     for i in range(6):
 239         buspins.append("MCUCS%d" % i)
 240     for i in range(2):
 241         buspins.append("MCUNRB%d" % i)
 242     buspins += ['MCUCD', 'MCURD', 'MCUWR', 'MCUCLE', 'MCUALE',
 243                 'MCURST']
 244     return Pins('MCU', buspins, bankspec, suffix, offs, bank, mux, spec,
 245                 origsuffix=suffix)
 246
 247 def _pinbank(bankspec, prefix, suffix, offs, bank, gpiooffs, gpionum=1, mux=1,
 248              spec=None):
 249     gpiopins = []
 250     for i in range(gpiooffs, gpiooffs+gpionum):
 251         gpiopins.append("%s%s%d" % (prefix, bank, i))
 252     return Pins('GPIO', gpiopins, bankspec, suffix, offs, bank, mux, spec,
 253                 origsuffix=suffix)
 254
 255 def eint(bankspec, suffix, offs, bank, gpiooffs, gpionum=1, mux=1, spec=None):
 256     gpiopins = []
 257     for i in range(gpiooffs, gpiooffs+gpionum):
 258         gpiopins.append("EINT%d" % (i))
 259     return Pins('EINT', gpiopins, bankspec, suffix, offs, bank, mux, spec,
 260                 origsuffix=suffix)
 261
 262 def pwm(bankspec, suffix, offs, bank, mux=1, spec=None):
 263     return Pins('PWM', ['PWM', ], bankspec, suffix, offs, bank, mux, spec,
 264                 origsuffix=suffix)
 265
 266 def gpio(bankspec, suffix, offs, bank, gpiooffs, gpionum=1, mux=1, spec=None):
 267     return _pinbank(bankspec, "GPIO", suffix, offs, bank, gpiooffs,
 268                               gpionum, mux=0, spec=None)
 269
 270 def display(pins):
 271     print "| Pin | Mux0        | Mux1        | Mux2        | Mux3        |"
 272     print "| --- | ----------- | ----------- | ----------- | ----------- |"
 273     pinidx = pins.keys()
 274     pinidx.sort()
 275     for pin in pinidx:
 276         pdata = pins.get(pin)
 277         res = '| %3d |' % pin
 278         for mux in range(4):
 279             if not pdata.has_key(mux):
 280                 res += "             |"
 281                 continue
 282             name, bank = pdata[mux]
 283             res += " %s %-9s |" % (bank, name)
 284         print res
 285
 286 def fnsplit(f):
 287     a = ''
 288     n = 0
 289     if not f.startswith('FB_'):
 290         f2 = f.split('_')
 291         if len(f2) == 2:
 292             if f2[1].isdigit():
 293                 return f2[0], int(f2[1])
 294             return f2[0], f2[1]
 295     #print f
 296     while f and not f[0].isdigit():
 297         a += f[0]
 298         f = f[1:]
 299     return a, int(f) if f else None
 300
 301 def fnsort(f1, f2):
 302     a1, n1 = fnsplit(f1)
 303     a2, n2 = fnsplit(f2)
 304     x = cmp(a1, a2)
 305     if x != 0:
 306         return x
 307     return cmp(n1, n2)
 308
 309 def find_fn(fname, names):
 310     for n in names:
 311         if fname.startswith(n):
 312             return n
 313
 314 def display_fns(bankspec, pins, function_names):
 315     fn_names = function_names.keys()
 316     fns = {}
 317     for (pin, pdata) in pins.items():
 318         for mux in range(1,4): # skip GPIO for now
 319             if not pdata.has_key(mux):
 320                 continue
 321             name, bank = pdata[mux]
 322             if not fns.has_key(name):
 323                 fns[name] = []
 324             fns[name].append((pin-bankspec[bank], mux, bank))
 325
 326     fnidx = fns.keys()
 327     fnidx.sort(fnsort)
 328     current_fn = None
 329     for fname in fnidx:
 330         fnbase = find_fn(fname, fn_names)
 331         #print "name", fname
 332         if fnbase != current_fn:
 333             if current_fn is not None:
 334                 print
 335             print "## %s" % fnbase
 336             print
 337             print function_names[fnbase]
 338             print
 339             current_fn = fnbase
 340         print "* %-9s :" % fname,
 341         for (pin, mux, bank) in fns[fname]:
 342             print "%s%d/%d" % (bank, pin, mux),
 343         print
 344
 345     return fns
 346
 347 def check_functions(title, bankspec, fns, pins, required, eint, pwm,
 348                     descriptions=None):
 349     fns = deepcopy(fns)
 350     pins = deepcopy(pins)
 351     if descriptions is None:
 352         descriptions = {}
 353
 354     print "# Pinmap for %s" % title
 355     print
 356
 357
 358     for name in required:
 359         print "## %s" % name
 360         print
 361         if descriptions and descriptions.has_key(name):
 362             print descriptions[name]
 363             print
 364
 365         name = name.split(':')
 366         if len(name) == 2:
 367             findbank = name[0][0]
 368             findmux = int(name[0][1:])
 369             name = name[1]
 370         else:
 371             name = name[0]
 372             findbank = None
 373             findmux = None
 374         name = name.split('/')
 375         if len(name) == 2:
 376             count = int(name[1])
 377         else:
 378             count = 100000
 379         name = name[0]
 380         found = set()
 381         fnidx = fns.keys()
 382         #fnidx.sort(fnsort)
 383         pinfound = {}
 384         for fname in fnidx:
 385             if not fname.startswith(name):
 386                 continue
 387             for pin, mux, bank in fns[fname]:
 388                 if findbank is not None:
 389                     if findbank != bank:
 390                         continue
 391                     if findmux != mux:
 392                         continue
 393                 pin_ = pin + bankspec[bank]
 394                 if pins.has_key(pin_):
 395                     pinfound[pin_] = (fname, pin_, bank, pin, mux)
 396
 397         pinidx = pinfound.keys()
 398         pinidx.sort()
 399
 400         for pin_ in pinidx:
 401             fname, pin_, bank, pin, mux = pinfound[pin_]
 402             if fname in found:
 403                 continue
 404             found.add(fname)
 405             if len(found) > count:
 406                 continue
 407             del pins[pin_]
 408             print "* %s %d %s%d/%d" % (fname, pin_, bank, pin, mux)
 409
 410         print
 411
 412     # gpios
 413     gpios = []
 414     for name in descriptions.keys():
 415         if not name.startswith('GPIO'):
 416             continue
 417         if name == 'GPIO':
 418             continue
 419         gpios.append(name)
 420     gpios.sort()
 421
 422     if gpios:
 423         print "## GPIO"
 424         print
 425
 426         for fname in gpios:
 427             if fname in found:
 428                 continue
 429             desc = ''
 430             if descriptions and descriptions.has_key(fname):
 431                 desc = ': %s' % descriptions[fname]
 432             bank = fname[4]
 433             pin = int(fname[5:])
 434             pin_ = pin + bankspec[bank]
 435             if not pins.has_key(pin_):
 436                 continue
 437             del pins[pin_]
 438             found.add(fname)
 439             print "* %-8s %d %s%-2d %s" % (fname, pin_, bank, pin, desc)
 440         print
 441
 442     if eint:
 443         display_group(bankspec, "EINT", eint, fns, pins, descriptions)
 444     if pwm:
 445         display_group(bankspec, "PWM", pwm, fns, pins, descriptions)
 446
 447     print "## Unused Pinouts (spare as GPIO) for '%s'" % title
 448     print
 449     if descriptions and descriptions.has_key('GPIO'):
 450         print descriptions['GPIO']
 451         print
 452     display(pins)
 453     print
 454
 455     return pins # unused
 456
 457 def display_group(bankspec, title, todisplay, fns, pins, descriptions):
 458     print "## %s" % title
 459     print
 460
 461     found = set()
 462     for fname in todisplay:
 463         desc = ''
 464         if descriptions and descriptions.has_key(fname):
 465             desc = ': %s' % descriptions[fname]
 466         fname = fname.split(':')
 467         if len(fname) == 2:
 468             findbank = fname[0][0]
 469             findmux = int(fname[0][1:])
 470             fname = fname[1]
 471         else:
 472             fname = fname[0]
 473             findbank = None
 474             findmux = None
 475         for (pin, mux, bank) in fns[fname]:
 476             if findbank is not None:
 477                 if findbank != bank:
 478                     continue
 479                 if findmux != mux:
 480                     continue
 481             if fname in found:
 482                 continue
 483             pin_ = pin + bankspec[bank]
 484             if not pins.has_key(pin_):
 485                 continue
 486             del pins[pin_]
 487             found.add(fname)
 488             print "* %s %d %s%d/%d %s" % (fname, pin_, bank, pin, mux, desc)
 489     print
 490
 491 def pinmerge(pins, fn):
 492     # hack, store the function specs in the pins dict
 493     fname = fn.fname
 494     suffix = fn.origsuffix
 495     bank = fn.bank
 496
 497     if not hasattr(pins, 'fnspec'):
 498         pins.fnspec = pins
 499     if fname == 'GPIO':
 500         fname = fname + bank
 501     assert not pins.has_key('EINT')
 502     if not pins.fnspec.has_key(fname):
 503         pins.add_spec(fname, {})
 504     print "fname bank suffix", fname, bank, suffix
 505     if suffix or fname == 'EINT' or fname == 'PWM':
 506         specname = fname + suffix
 507     else:
 508         specname = fname + bank
 509     pins.fnspec[fname][specname] = fn
 510
 511
 512     # merge actual pins
 513     for (pinidx, v) in fn.pins.items():
 514         print "pinidx", pinidx
 515         pins.update(pinidx, v)
 516
 517 def display_fixed(fixed, offs):
 518
 519     fkeys = fixed.keys()
 520     fkeys.sort()
 521     pin_ = offs
 522     for pin, k in enumerate(fkeys):
 523         print "## %s" % k
 524         print
 525         prevname = ''
 526         linecount = 0
 527         for name in fixed[k]:
 528             if linecount == 4:
 529                 linecount = 0
 530                 print
 531             if prevname[:2] == name[:2] and linecount != 0:
 532                 print name,
 533                 linecount += 1
 534             else:
 535                 if linecount != 0:
 536                     print
 537                 print "* %d: %d %s" % (pin_, pin, name),
 538                 linecount = 1
 539             prevname = name
 540             pin_ += 1
 541         if linecount != 0:
 542             print
 543         print
 544