| #!/usr/bin/env python3 |
| # -*- coding: utf-8 -*- |
| # |
| # Copyright 2020 The SkyWater PDK Authors. |
| # |
| # Use of this source code is governed by the Apache 2.0 |
| # license that can be found in the LICENSE file or at |
| # https://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # SPDX-License-Identifier: Apache-2.0 |
| |
| |
| import json |
| import os |
| import pprint |
| import re |
| import sys |
| import textwrap |
| |
| from collections import defaultdict |
| |
| |
| copyright_header = """\ |
| /** |
| * Copyright 2020 The SkyWater PDK Authors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| """ |
| |
| from skywater_pdk.utils import OrderedEnum |
| |
| class PortGroup(OrderedEnum): |
| DATA_IN_CHAR = 10 # A, A1, D, etc |
| DATA_IN_WORD = 11 # IN |
| |
| DATA_OUT_CHAR = 20 # X, Y, Q |
| DATA_OUT_WORD = 21 # OUT |
| |
| DATA_IO_CHAR = 30 # Inout? |
| DATA_IO_WORD = 31 # Inout? |
| |
| DATA_CONTROL = 40 # SET / RESET / etc |
| |
| SCAN_CHAIN = 44 # SCD, SCE, etc |
| |
| CLOCK = 50 # Clock |
| CLOCK_CONTROL = 51 # Clock enable |
| |
| POWER_CONTROL = 78 # SLEEP |
| POWER_OTHER = 79 # KAPWR |
| POWER_POSITIVE = 80 # VPWR |
| POWER_NEGATIVE = 81 # VGND |
| |
| @property |
| def type(self): |
| pg = self |
| if pg in (self.DATA_IN_CHAR, self.DATA_IN_WORD, |
| self.DATA_OUT_CHAR, self.DATA_OUT_WORD, |
| self.DATA_IO_CHAR, self.DATA_IO_WORD,): |
| return 'data' |
| if pg in (self.DATA_CONTROL,): |
| return 'control' |
| if pg in (self.CLOCK, self.CLOCK_CONTROL,): |
| return 'clocks' |
| if pg in (self.SCAN_CHAIN,): |
| return 'scanchain' |
| if pg in (self.POWER_CONTROL, self.POWER_OTHER, |
| self.POWER_POSITIVE, self.POWER_NEGATIVE,): |
| return 'power' |
| assert False, self |
| |
| @property |
| def desc(self): |
| pg = self |
| if pg in (self.DATA_IN_CHAR, self.DATA_IN_WORD, |
| self.DATA_OUT_CHAR, self.DATA_OUT_WORD, |
| self.DATA_IO_CHAR, self.DATA_IO_WORD,): |
| return 'Data Signals' |
| if pg in (self.DATA_CONTROL,): |
| return 'Control Signals' |
| if pg in (self.SCAN_CHAIN,): |
| return 'Scan Chain' |
| if pg in (self.CLOCK, self.CLOCK_CONTROL,): |
| return 'Clocking' |
| if pg in (self.POWER_CONTROL, self.POWER_OTHER, |
| self.POWER_POSITIVE, self.POWER_NEGATIVE,): |
| return 'Power' |
| assert False, self |
| |
| |
| @classmethod |
| def classify(cls, name, modname=None): |
| """ |
| |
| Data Input Signals |
| ++++++++++++++++++ |
| |
| >>> PortGroup.classify('A') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('A1') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('A1_N') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('A_N') |
| <PortGroup.DATA_IN_CHAR: 10> |
| |
| >>> PortGroup.classify('B') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('B1') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('B1_N') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('B_N') |
| <PortGroup.DATA_IN_CHAR: 10> |
| |
| >>> PortGroup.classify('C') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('C1') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('C1_N') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('C_N') |
| <PortGroup.DATA_IN_CHAR: 10> |
| |
| >>> PortGroup.classify('J') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('K') |
| <PortGroup.DATA_IN_CHAR: 10> |
| |
| >>> PortGroup.classify('IN') |
| <PortGroup.DATA_IN_WORD: 11> |
| |
| >>> PortGroup.classify('D') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('D_N') |
| <PortGroup.DATA_IN_CHAR: 10> |
| |
| >>> PortGroup.classify('P0') |
| <PortGroup.DATA_IN_CHAR: 10> |
| >>> PortGroup.classify('N1') |
| <PortGroup.DATA_IN_CHAR: 10> |
| |
| >>> PortGroup.classify('CI') |
| <PortGroup.DATA_IN_WORD: 11> |
| >>> PortGroup.classify('CIN') |
| <PortGroup.DATA_IN_WORD: 11> |
| |
| SCD |
| Scan Chain Data |
| >>> PortGroup.classify('SCD') |
| <PortGroup.SCAN_CHAIN: 44> |
| |
| SCE |
| Scan Chain Enable |
| >>> PortGroup.classify('SCE') |
| <PortGroup.SCAN_CHAIN: 44> |
| |
| Data Output Signals |
| +++++++++++++++++++ |
| |
| >>> PortGroup.classify('X') |
| <PortGroup.DATA_OUT_CHAR: 20> |
| >>> PortGroup.classify('X_N') |
| <PortGroup.DATA_OUT_CHAR: 20> |
| |
| >>> PortGroup.classify('Y') |
| <PortGroup.DATA_OUT_CHAR: 20> |
| >>> PortGroup.classify('Y_N') |
| <PortGroup.DATA_OUT_CHAR: 20> |
| |
| >>> PortGroup.classify('Z') |
| <PortGroup.DATA_OUT_CHAR: 20> |
| >>> PortGroup.classify('Z_N') |
| <PortGroup.DATA_OUT_CHAR: 20> |
| |
| >>> PortGroup.classify('Q') |
| <PortGroup.DATA_OUT_CHAR: 20> |
| |
| >>> PortGroup.classify('OUT') |
| <PortGroup.DATA_OUT_WORD: 21> |
| |
| >>> PortGroup.classify('HI') |
| <PortGroup.DATA_OUT_WORD: 21> |
| >>> PortGroup.classify('LO') |
| <PortGroup.DATA_OUT_WORD: 21> |
| |
| >>> PortGroup.classify('COUT') |
| <PortGroup.DATA_OUT_WORD: 21> |
| |
| >>> PortGroup.classify('SUM') |
| <PortGroup.DATA_OUT_WORD: 21> |
| |
| Data Control Signals |
| ++++++++++++++++++++ |
| |
| >>> PortGroup.classify('SET') |
| <PortGroup.DATA_CONTROL: 40> |
| >>> PortGroup.classify('SET_N') |
| <PortGroup.DATA_CONTROL: 40> |
| >>> PortGroup.classify('SET_B') |
| <PortGroup.DATA_CONTROL: 40> |
| |
| >>> PortGroup.classify('S') |
| <PortGroup.DATA_CONTROL: 40> |
| >>> PortGroup.classify('S_N') |
| <PortGroup.DATA_CONTROL: 40> |
| >>> PortGroup.classify('S_B') |
| <PortGroup.DATA_CONTROL: 40> |
| |
| >>> PortGroup.classify('R') |
| <PortGroup.DATA_CONTROL: 40> |
| >>> PortGroup.classify('R_N') |
| <PortGroup.DATA_CONTROL: 40> |
| >>> PortGroup.classify('R_B') |
| <PortGroup.DATA_CONTROL: 40> |
| |
| >>> PortGroup.classify('RESET') |
| <PortGroup.DATA_CONTROL: 40> |
| >>> PortGroup.classify('RESET_N') |
| <PortGroup.DATA_CONTROL: 40> |
| >>> PortGroup.classify('RESET_B') |
| <PortGroup.DATA_CONTROL: 40> |
| |
| >>> PortGroup.classify('RESET') |
| <PortGroup.DATA_CONTROL: 40> |
| >>> PortGroup.classify('RESET_N') |
| <PortGroup.DATA_CONTROL: 40> |
| >>> PortGroup.classify('RESET_B') |
| <PortGroup.DATA_CONTROL: 40> |
| |
| Data Enable |
| >>> PortGroup.classify('DE') |
| <PortGroup.DATA_CONTROL: 40> |
| |
| Tristate Enable |
| >>> PortGroup.classify('TE_B') |
| <PortGroup.DATA_CONTROL: 40> |
| |
| Select lines on muxes |
| >>> PortGroup.classify('S0') |
| <PortGroup.DATA_CONTROL: 40> |
| >>> PortGroup.classify('S4') |
| <PortGroup.DATA_CONTROL: 40> |
| |
| Clock Signals |
| +++++++++++++ |
| |
| #>>> PortGroup.classify('C') |
| #<PortGroup.CLOCK: 50> |
| |
| #>>> PortGroup.classify('CN') |
| #<PortGroup.CLOCK: 50> |
| |
| #>>> PortGroup.classify('C_N') |
| #<PortGroup.CLOCK: 50> |
| |
| >>> PortGroup.classify('CLK') |
| <PortGroup.CLOCK: 50> |
| |
| >>> PortGroup.classify('GCLK') |
| <PortGroup.CLOCK: 50> |
| |
| >>> PortGroup.classify('CLK_N') |
| <PortGroup.CLOCK: 50> |
| |
| >>> PortGroup.classify('G') |
| <PortGroup.CLOCK: 50> |
| |
| >>> PortGroup.classify('GN') |
| <PortGroup.CLOCK: 50> |
| |
| >>> PortGroup.classify('G_N') |
| <PortGroup.CLOCK: 50> |
| |
| >>> PortGroup.classify('GATE') |
| <PortGroup.CLOCK: 50> |
| |
| >>> PortGroup.classify('GATE_N') |
| <PortGroup.CLOCK: 50> |
| |
| |
| Clock Control Signals |
| +++++++++++++++++++++ |
| |
| >>> PortGroup.classify('CLK_EN') |
| <PortGroup.CLOCK_CONTROL: 51> |
| |
| >>> PortGroup.classify('CE') |
| <PortGroup.CLOCK_CONTROL: 51> |
| |
| >>> PortGroup.classify('CEN') |
| <PortGroup.CLOCK_CONTROL: 51> |
| |
| >>> PortGroup.classify('GATE_EN') |
| <PortGroup.CLOCK_CONTROL: 51> |
| |
| >>> PortGroup.classify('GEN') |
| <PortGroup.CLOCK_CONTROL: 51> |
| |
| >>> PortGroup.classify('GE') |
| <PortGroup.CLOCK_CONTROL: 51> |
| |
| Positive Power Supplies |
| +++++++++++++++++++++++ |
| |
| >>> PortGroup.classify('VPWR') |
| <PortGroup.POWER_POSITIVE: 80> |
| |
| >>> PortGroup.classify('VPB') |
| <PortGroup.POWER_POSITIVE: 80> |
| |
| Negative Power Supplies |
| +++++++++++++++++++++++ |
| |
| >>> PortGroup.classify('VGND') |
| <PortGroup.POWER_NEGATIVE: 81> |
| |
| >>> PortGroup.classify('VNB') |
| <PortGroup.POWER_NEGATIVE: 81> |
| |
| >>> PortGroup.classify('DEST') |
| <PortGroup.POWER_OTHER: 79> |
| |
| Power Control Signals |
| +++++++++++++++++++++ |
| |
| >>> PortGroup.classify('SLEEP') |
| <PortGroup.POWER_CONTROL: 78> |
| |
| >>> PortGroup.classify('SLEEP_B') |
| <PortGroup.POWER_CONTROL: 78> |
| |
| >>> PortGroup.classify('SLEEP_N') |
| <PortGroup.POWER_CONTROL: 78> |
| |
| Other Power Suppliers |
| +++++++++++++++++++++ |
| |
| >>> PortGroup.classify('KAPWR') |
| <PortGroup.POWER_OTHER: 79> |
| |
| >>> PortGroup.classify('KAGND') |
| <PortGroup.POWER_OTHER: 79> |
| |
| >>> PortGroup.classify('DIODE') |
| <PortGroup.POWER_OTHER: 79> |
| |
| >>> PortGroup.classify('LOWLVPWRA') |
| <PortGroup.POWER_OTHER: 79> |
| |
| """ |
| # Override for csw module |
| if modname and 'csw' in modname: |
| if name == 'VPB': |
| return cls.POWER_POSITIVE |
| elif name == 'VNB': |
| return cls.POWER_NEGATIVE |
| elif name in ('S', 'D', 'GN', 'GP'): |
| return cls.POWER_OTHER |
| |
| name = name.upper() |
| if re.search('^[A-FJKPN][0-9]?(_[NB])?$', name): |
| return cls.DATA_IN_CHAR |
| |
| if re.search('^[XYZQ][0-9]?(_[NB])?$', name): |
| return cls.DATA_OUT_CHAR |
| |
| if re.search('^IN[0-9]?_?', name): |
| return cls.DATA_IN_WORD |
| if re.search('^CI[0-9]?_?', name): |
| return cls.DATA_IN_WORD |
| if re.search('^CIN[0-9]?_?', name): |
| return cls.DATA_IN_WORD |
| if re.search('^OUT[0-9]?_?', name): |
| return cls.DATA_OUT_WORD |
| if re.search('^COUT[0-9]?_?', name): |
| return cls.DATA_OUT_WORD |
| if re.search('^SUM[0-9]?_?', name): |
| return cls.DATA_OUT_WORD |
| if name in ('HI', 'LO'): |
| return cls.DATA_OUT_WORD |
| |
| if re.search('^S[0-9]+$', name): |
| return cls.DATA_CONTROL |
| |
| if re.search('^((SET)|(RESET)|[SR])(_[NB])?$', name): |
| return cls.DATA_CONTROL |
| |
| if re.search('^((T)|(TE))(_[NB])?$', name): |
| return cls.DATA_CONTROL |
| |
| if re.search('^(DE)(_[NB])?$', name): |
| return cls.DATA_CONTROL |
| |
| if re.search('^((CLK)|(GCLK)|(GATE))_EN$', name): |
| return cls.CLOCK_CONTROL |
| if re.search('^[CG]EN$', name): |
| return cls.CLOCK_CONTROL |
| if re.search('^[CG]E$', name): |
| return cls.CLOCK_CONTROL |
| if re.search('^((CLK)|(GCLK)|(GATE))$', name): |
| return cls.CLOCK |
| if re.search('^((CLK)|(GCLK)|(GATE))_N$', name): |
| return cls.CLOCK |
| if re.search('^[G]_?N?$', name): |
| return cls.CLOCK |
| |
| if re.search('^SLEEP(_[NB])?$', name): |
| return cls.POWER_CONTROL |
| |
| if re.search('^VPWR', name): |
| return cls.POWER_POSITIVE |
| if re.search('^VPB$', name): |
| return cls.POWER_POSITIVE |
| if re.search('^VGND', name): |
| return cls.POWER_NEGATIVE |
| if re.search('^VNB$', name): |
| return cls.POWER_NEGATIVE |
| if name.startswith('DEST'): |
| return cls.POWER_OTHER |
| if 'DIODE' in name: |
| return cls.POWER_OTHER |
| if 'PWR' in name: |
| return cls.POWER_OTHER |
| if 'GND' in name: |
| return cls.POWER_OTHER |
| if 'SHORT' in name: |
| return cls.POWER_OTHER |
| |
| if 'MET' in name: |
| return cls.POWER_OTHER |
| if re.search('^[M][0-1]$', name): |
| return cls.POWER_OTHER |
| if 'SRC' == name: |
| return cls.DATA_IN_WORD |
| if 'DST' == name: |
| return cls.DATA_OUT_WORD |
| if 'NETA' == name: |
| return cls.DATA_IN_WORD |
| if 'NETB' == name: |
| return cls.DATA_OUT_WORD |
| |
| if name.startswith('SC'): |
| return cls.SCAN_CHAIN |
| if name.startswith('ASYNC'): |
| return cls.SCAN_CHAIN |
| |
| |
| |
| def write_verilog(define_data, outfile, drive=None): |
| with open(outfile, 'w') as f: |
| f.write(copyright_header) |
| f.write('\n') |
| f.write(include_header.format(define_data['fullname'])) |
| f.write('\n') |
| if not drive: |
| return |
| drive_name, drive_value = drive |
| |
| if not 'ports' in define_data: |
| return |
| |
| module_signal_defports = [] |
| module_signal_ports = [] |
| for pname, ptype in define_data['ports']['signal']: |
| module_signal_defports.append("{} {}, ".format(ptype, pname)) |
| module_signal_ports.append(pname) |
| |
| module_signal_defports = "".join(module_signal_defports) |
| assert module_signal_defports.endswith(", "), module_signal_defports |
| module_signal_defports = module_signal_defports[:-2] |
| module_signal_ports = ", ".join(module_signal_ports) |
| |
| module_power_defports = [] |
| module_power_ports = [] |
| for pname, ptype in define_data['ports']['power']: |
| module_power_defports.append(", {} {}".format('input', pname)) |
| module_power_ports.append(", {}".format(pname)) |
| module_power_defports = "".join(module_power_defports) |
| module_power_ports = "".join(module_power_ports) |
| |
| library_name = "{} {}".format( |
| define_data['library']['name'].upper(), define_data['library']['type']) |
| |
| f.write(module_header.format( |
| module_base_name = define_data['fullname'], |
| cell_name = define_data['name'], |
| library_name = library_name, |
| drive_name = drive_name, |
| drive_value = drive_value, |
| description = define_data.get('description', ''), |
| module_signal_defports = module_signal_defports, |
| module_signal_ports = module_signal_ports, |
| module_power_defports = module_power_defports, |
| module_power_ports = module_power_ports, |
| )) |
| |
| |
| def echo_file(fname): |
| with open(fname) as f: |
| sys.stdout.write('\n') |
| sys.stdout.write('File: ') |
| sys.stdout.write(fname) |
| sys.stdout.write('\n') |
| sys.stdout.write('------\n') |
| sys.stdout.write(f.read()) |
| sys.stdout.write('------\n') |
| sys.stdout.flush() |
| |
| |
| |
| def seek_backwards(f): |
| start_pos = f.tell() |
| current_pos = f.tell()-1 |
| while True: |
| f.seek(current_pos) |
| d = f.read(1) |
| if d not in '\n ,': |
| break |
| current_pos -= 1 |
| f.seek(current_pos+1) |
| |
| |
| def drive_strengths(basename, cellpath): |
| drives = [] |
| for f in os.listdir(cellpath): |
| if not f.endswith('.gds'): |
| continue |
| f = f.split('.', 1)[0] |
| |
| libname, modname = f.split('__', 1) |
| drive = modname.replace(basename, '') |
| if not drive: |
| continue |
| assert drive.startswith('_'), drive |
| drives.append(drive[1:]) |
| return drives |
| |
| def wrap(s): |
| return "\n".join(textwrap.wrap(s, initial_indent=' * ', subsequent_indent=' * ')) |
| |
| |
| warning = """\ |
| WARNING: This file is autogenerated, do not modify directly! |
| """ |
| |
| |
| def file_guard(fname): |
| fname = re.sub('[^A-Za-z_0-9]', '_', fname) |
| return fname.upper() |
| |
| |
| def write_verilog_header(f, desc, define_data): |
| assert f.name, f |
| guard = file_guard(os.path.basename(f.name)) |
| f.write(copyright_header) |
| f.write('\n') |
| f.write(f'`ifndef {guard}\n') |
| f.write(f'`define {guard}\n') |
| f.write('\n') |
| f.write(f"/**\n") |
| f.write(wrap(f"{define_data['name']}: {define_data['description']}")) |
| f.write('\n') |
| f.write(f" *\n") |
| f.write(wrap(desc)) |
| f.write('\n') |
| f.write(f" *\n") |
| f.write(wrap(warning)) |
| f.write('\n') |
| f.write(f" */\n") |
| f.write('\n') |
| f.write('`timescale 1ns / 1ps\n') |
| f.write('\n') |
| |
| |
| def write_verilog_footer(f): |
| assert f.name, f |
| guard = file_guard(os.path.basename(f.name)) |
| f.write('\n') |
| f.write(f'`endif // {guard}\n') |
| f.close() |
| |
| |
| |
| def write_module_header(f, define_data): |
| f.write('(* blackbox *)\n') |
| f.write(f"module {define_data['library']}__{define_data['name']} (") |
| |
| |
| def write_verilog_parameters(f, define_data): |
| maxlen = {} |
| maxlen['pname'] = max([0]+[len(p[0]) for p in define_data['parameters']]) |
| maxlen['ptype'] = max([0]+[len(p[1]) for p in define_data['parameters']]) |
| if maxlen['pname']: |
| f.write('\n // Parameters\n') |
| for pname, ptype in define_data['parameters']: |
| pname = pname.ljust(maxlen['pname']) |
| if maxlen['ptype']: |
| ptype = ptype.ljust(maxlen['ptype'])+ ' ' |
| else: |
| ptype = '' |
| f.write(f' parameter {ptype}{pname};\n') |
| |
| |
| def write_verilog_supplies(f, define_data): |
| maxlen = {} |
| maxlen['pname'] = max([0]+[len(p[1]) for p in define_data['ports'] if p[0] == 'power']) |
| maxlen['ptype'] = max([0]+[len(p[3]) for p in define_data['ports'] if p[0] == 'power']) |
| if maxlen['pname']: |
| f.write('\n // Voltage supply signals\n') |
| for pclass, pname, pdir, ptype in define_data['ports']: |
| if pclass != 'power': |
| continue |
| assert ptype, (pclass, pname, pdir, ptype) |
| |
| pname = pname.ljust(maxlen['pname']) |
| ptype = ptype.ljust(maxlen['ptype']) |
| |
| f.write(f' {ptype} {pname};\n') |
| f.write('\n') |
| |
| |
| def write_verilog_ports(f, ports): |
| maxlen = {} |
| maxlen['pname'] = max([0]+[len(p[1]) for p in ports]) |
| maxlen['pdir'] = max([0]+[len(p[2]) for p in ports]) |
| maxlen['ptype'] = max([0]+[len(p[3]) for p in ports if p[0] != 'power']) |
| |
| for pclass, pname, pdir, ptype in ports: |
| pname = pname.ljust(maxlen['pname']) |
| |
| if maxlen['pdir']: |
| pdir = pdir.ljust(maxlen['pdir'])+' ' |
| else: |
| pdir = '' |
| |
| if maxlen['ptype']: |
| ptype = ptype.ljust(maxlen['ptype'])+ ' ' |
| else: |
| ptype = '' |
| |
| f.write(f"\n {pdir}{ptype}{pname},") |
| seek_backwards(f) |
| if ports: |
| f.write("\n") |
| f.write(");\n") |
| |
| |
| def write_verilog_symbol_ports(f, pports): |
| maxlen = {} |
| maxlen['pname'] = max([0]+[len(p[2]) for p in pports if p]) |
| maxlen['pdir'] = max([0]+[len(p[3]) for p in pports if p]) |
| maxlen['ptype'] = max([0]+[len(p[4]) for p in pports if p and p[1] != 'power']) |
| |
| for i, p in enumerate(pports): |
| if not p: |
| np = pports[i+1] |
| if i > 0: |
| f.write('\n') |
| f.write('\n //# {{'+np[0].type+'|'+np[0].desc+'}}') |
| continue |
| pg, pclass, pname, pdir, ptype = p |
| if pclass == 'power': |
| ptype = '' |
| |
| pname = pname.ljust(maxlen['pname']) |
| |
| if maxlen['pdir']: |
| pdir = pdir.ljust(maxlen['pdir'])+' ' |
| else: |
| pdir = '' |
| |
| if maxlen['ptype']: |
| ptype = ptype.ljust(maxlen['ptype'])+ ' ' |
| else: |
| ptype = '' |
| |
| f.write(f"\n {pdir}{ptype}{pname},") |
| seek_backwards(f) |
| if pports: |
| f.write("\n") |
| f.write(");\n") |
| |
| |
| def nonpp_ports(define_data): |
| ports = [] |
| for pclass, pname, pdir, ptype in define_data['ports']: |
| if pclass != 'signal': |
| continue |
| ports.append((pclass, pname, pdir, ptype)) |
| return ports |
| |
| |
| def pp_ports(define_data): |
| ports = [] |
| for pclass, pname, pdir, ptype in define_data['ports']: |
| if pclass == 'power': |
| ptype = '' |
| ports.append((pclass, pname, pdir, ptype)) |
| return ports |
| |
| |
| def write_blackbox(cellpath, define_data): |
| outpath = os.path.join(cellpath, f"{define_data['library']}__{define_data['name']}.blackbox.v") |
| assert not os.path.exists(outpath), outpath |
| print("Creating", outpath) |
| with open(outpath, "w+") as f: |
| write_verilog_header( |
| f, |
| "Verilog stub definition (black box without power pins).", |
| define_data) |
| write_module_header(f, define_data) |
| write_verilog_ports(f, nonpp_ports(define_data)) |
| write_verilog_parameters(f, define_data) |
| write_verilog_supplies(f, define_data) |
| f.write('endmodule\n') |
| write_verilog_footer(f) |
| |
| |
| def write_blackbox_pp(cellpath, define_data): |
| outpath = os.path.join(cellpath, f"{define_data['library']}__{define_data['name']}.pp.blackbox.v") |
| assert not os.path.exists(outpath), outpath |
| print("Creating", outpath) |
| with open(outpath, "w+") as f: |
| write_verilog_header( |
| f, |
| "Verilog stub definition (black box with power pins).", |
| define_data) |
| write_module_header(f, define_data) |
| write_verilog_ports(f, pp_ports(define_data)) |
| write_verilog_parameters(f, define_data) |
| f.write('endmodule\n') |
| write_verilog_footer(f) |
| |
| |
| def group_ports_for_symbol(define_data, only): |
| ports = [] |
| for pclass, pname, pdir, ptype in define_data['ports']: |
| if pclass not in only: |
| continue |
| pg = PortGroup.classify(pname, define_data['name']) |
| ports.append((pg, pclass, pname, pdir, ptype)) |
| |
| ports.sort() |
| |
| pports = [None,] |
| while len(ports) > 0: |
| if pports[-1] and pports[-1][0].type != ports[0][0].type: |
| pports.append(None) |
| pports.append(ports.pop(0)) |
| |
| if len(pports) == 1: |
| return [] |
| |
| return pports |
| |
| |
| def write_symbol(cellpath, define_data): |
| outpath = os.path.join(cellpath, f"{define_data['library']}__{define_data['name']}.symbol.v") |
| assert not os.path.exists(outpath), outpath |
| print("Creating", outpath) |
| |
| # Group the ports to make a nice symbol |
| pports = group_ports_for_symbol(define_data, ['signal']) |
| |
| with open(outpath, "w+") as f: |
| write_verilog_header( |
| f, |
| "Verilog stub (without power pins) for graphical symbol definition generation.", |
| define_data) |
| write_module_header(f, define_data) |
| write_verilog_symbol_ports(f, pports) |
| write_verilog_parameters(f, define_data) |
| write_verilog_supplies(f, define_data) |
| f.write('endmodule\n') |
| write_verilog_footer(f) |
| |
| |
| def write_symbol_pp(cellpath, define_data): |
| outpath = os.path.join(cellpath, f"{define_data['library']}__{define_data['name']}.pp.symbol.v") |
| assert not os.path.exists(outpath), outpath |
| print("Creating", outpath) |
| |
| # Group the ports to make a nice symbol |
| pports = group_ports_for_symbol(define_data, ['signal', 'power']) |
| |
| with open(outpath, "w+") as f: |
| write_verilog_header( |
| f, |
| "Verilog stub (with power pins) for graphical symbol definition generation.", |
| define_data) |
| write_module_header(f, define_data) |
| write_verilog_symbol_ports(f, pports) |
| write_verilog_parameters(f, define_data) |
| f.write('endmodule\n') |
| write_verilog_footer(f) |
| |
| |
| def write_verilog_wrapper(f, extra, supplies, ports, define_data): |
| f.write('\n') |
| f.write('`celldefine\n') |
| f.write(f"module {define_data['library']}__{define_data['name']}{extra} (") |
| write_verilog_ports(f, pp_ports(define_data)) |
| write_verilog_parameters(f, define_data) |
| if supplies: |
| write_verilog_supplies(f, define_data) |
| |
| param_str = '' |
| if define_data['parameters']: |
| param_str += '#(' |
| param_str += " ".join('.{0}({0})'.format(p[0]) for p in define_data['parameters']) |
| param_str += ') ' |
| |
| ports_str = '' |
| if ports: |
| ports_str += ",\n ".join('.{0}({0})'.format(p[1]) for p in ports); |
| |
| f.write(f" {define_data['library']}__{define_data['name']} cell ") |
| f.write(param_str) |
| f.write('(\n ') |
| f.write(ports_str) |
| seek_backwards(f) |
| if ports: |
| f.write("\n );\n") |
| else: |
| f.write(");\n") |
| f.write('\n') |
| f.write('endmodule\n') |
| f.write('`endcelldefine\n') |
| f.write('\n') |
| |
| |
| def write_drive_wrapper(drive, cellpath, define_data): |
| outpath = os.path.join(cellpath, f"{define_data['library']}__{define_data['name']}_{drive}.v") |
| basefile = f"{define_data['library']}__{define_data['name']}" |
| assert not os.path.exists(outpath), outpath |
| print("Creating", outpath) |
| |
| with open(outpath, "w+") as f: |
| write_verilog_header( |
| f, |
| f"Verilog wrapper for {define_data['name']} drive {drive}.", |
| define_data) |
| f.write(f'`include "{basefile}.v"\n') |
| f.write('\n') |
| f.write('`ifdef USE_POWER_PINS\n') |
| f.write('/*********************************************************/\n') |
| write_verilog_wrapper(f, '_'+drive, False, pp_ports(define_data), define_data) |
| f.write('/*********************************************************/\n') |
| f.write('`else // If not USE_POWER_PINS\n') |
| f.write('/*********************************************************/\n') |
| write_verilog_wrapper(f, '_'+drive, True, nonpp_ports(define_data), define_data) |
| f.write('/*********************************************************/\n') |
| f.write('`endif // USE_POWER_PINS\n') |
| write_verilog_footer(f) |
| |
| |
| |
| def process(cellpath): |
| print() |
| print(cellpath) |
| define_json = os.path.join(cellpath, 'definition.json') |
| if not os.path.exists(define_json): |
| print("No definition.json in", cellpath) |
| return |
| assert os.path.exists(define_json), define_json |
| define_data = json.load(open(define_json)) |
| |
| write_blackbox(cellpath, define_data) |
| write_blackbox_pp(cellpath, define_data) |
| |
| write_symbol(cellpath, define_data) |
| write_symbol_pp(cellpath, define_data) |
| |
| for d in drive_strengths(define_data['name'], cellpath): |
| write_drive_wrapper(d, cellpath, define_data) |
| |
| return |
| |
| |
| def main(args): |
| for a in args: |
| process(a) |
| |
| |
| |
| if __name__ == "__main__": |
| import doctest |
| fails, _ = doctest.testmod() |
| if fails>0: |
| sys.exit() |
| sys.exit(main(sys.argv[1:])) |
