src/spec/interfaces.py

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