lambdapdk 0.1.37__py3-none-any.whl → 0.1.39__py3-none-any.whl

lambdapdk/__init__.py

@@ -1,7 +1,7 @@
 import siliconcompiler.package as sc_package
 
 
-__version__ = "0.1.37"
+__version__ = "0.1.39"
 
 
 def register_data_source(chip):
@@ -20,10 +20,10 @@ def get_pdks():
     Returns a list of pdk names in lambdapdk
     '''
 
-    from lambdapdk import asap7, freepdk45, sky130, gf180, ihp130
+    from lambdapdk import asap7, freepdk45, sky130, gf180, ihp130, interposer
 
     all_pdks = []
-    for pdk_mod in [asap7, freepdk45, sky130, gf180, ihp130]:
+    for pdk_mod in [asap7, freepdk45, sky130, gf180, ihp130, interposer]:
         pdks = pdk_mod.setup()
         if not isinstance(pdks, (list, tuple)):
             pdks = [pdks]
@@ -43,6 +43,7 @@ def get_libs():
     from lambdapdk.sky130.libs import sky130sc, sky130io, sky130sram
     from lambdapdk.gf180.libs import gf180mcu, gf180io, gf180sram
     from lambdapdk.ihp130.libs import sg13g2_stdcell, sg13g2_sram
+    from lambdapdk.interposer.libs import bumps as interposer_bumps
 
     all_libs = []
     for lib_mod in [
@@ -50,7 +51,8 @@ def get_libs():
             nangate45, fakeram45,
             sky130sc, sky130io, sky130sram,
             gf180mcu, gf180io, gf180sram,
-            sg13g2_stdcell, sg13g2_sram]:
+            sg13g2_stdcell, sg13g2_sram,
+            interposer_bumps]:
         libs = lib_mod.setup()
         if not isinstance(libs, (list, tuple)):
             libs = [libs]

lambdapdk/asap7/__init__.py

@@ -111,6 +111,10 @@ def setup():
     pdk.set('pdk', process, 'pexmodel', 'openroad-openrcx', stackup, 'typical',
             pdkdir + '/pex/openroad/typical.rules')
 
+    # Relaxed routing rules
+    pdk.set('pdk', process, 'file', 'openroad', 'relax_routing_rules', stackup,
+            pdkdir + '/apr/openroad_relaxed_rules.tcl')
+
     # Hide the DIEAREA layer 235/*.
     pdk.add('pdk', process, 'var', 'klayout', 'hide_layers', stackup, '235/0')
     pdk.add('pdk', process, 'var', 'klayout', 'hide_layers', stackup, '235/5')

lambdapdk/asap7/libs/asap7sc7p5t.py

@@ -46,16 +46,13 @@ def _setup_lib(libname, suffix):
     # site name
     lib.set('asic', 'site', libtype, 'asap7sc7p5t')
 
-    # clock buffers
-    lib.add('asic', 'cells', 'clkbuf', f"BUFx2_ASAP7_75t_{suffix}")
+    # clock buffers - remove once openroad driver supports it
+    lib.add('asic', 'cells', 'clkbuf', f"BUFx4_ASAP7_75t_{suffix}")
 
     # tie cells
     lib.add('asic', 'cells', 'tie', [f"TIEHIx1_ASAP7_75t_{suffix}",
                                      f"TIELOx1_ASAP7_75t_{suffix}"])
 
-    # hold cells
-    lib.add('asic', 'cells', 'hold', f"BUFx2_ASAP7_75t_{suffix}")
-
     # filler
     lib.add('asic', 'cells', 'filler', [f"FILLER_ASAP7_75t_{suffix}",
                                         f"FILLERxp5_ASAP7_75t_{suffix}"])
@@ -92,7 +89,6 @@ def _setup_lib(libname, suffix):
     lib.set('option', 'var', 'openroad_macro_place_halo', ['10', '10'])
     lib.set('option', 'var', 'openroad_macro_place_channel', ['12', '12'])
 
-    lib.set('option', 'var', 'openroad_cts_clock_buffer', f"BUFx4_ASAP7_75t_{suffix}")
     lib.set('option', 'var', 'openroad_cts_distance_between_buffers', "60")
 
     lib.set('option', 'var', 'yosys_abc_clock_multiplier', "1")  # convert from ps -> ps

lambdapdk/freepdk45/libs/nangate45.py

@@ -45,15 +45,14 @@ def setup():
     lib.add('output', stackup, 'cdl', libdir + '/cdl/NangateOpenCellLibrary.cdl')
 
     # clock buffers
-    lib.add('asic', 'cells', 'clkbuf', "BUF_X4")
+    lib.set('asic', 'cells', 'clkbuf', ["CLKBUF_X1",
+                                        "CLKBUF_X2",
+                                        "CLKBUF_X3"])
 
     # tie cells
     lib.add('asic', 'cells', 'tie', ["LOGIC1_X1",
                                      "LOGIC0_X1"])
 
-    # hold cells
-    lib.add('asic', 'cells', 'hold', "BUF_X1")
-
     # filler
     lib.add('asic', 'cells', 'filler', ["FILLCELL_X1",
                                         "FILLCELL_X2",

lambdapdk/gf180/libs/gf180mcu.py

@@ -108,8 +108,6 @@ def setup():
         lib.set('option', 'file', 'openroad_tapcells',
                 libdir + '/apr/openroad/tapcell.tcl')
 
-        lib.set('option', 'var', 'openroad_cts_clock_buffer',
-                f"gf180mcu_fd_sc_mcu{libtype}5v0__clkbuf_8")
         lib.set('option', 'var', 'openroad_cts_distance_between_buffers', "100")
 
         lib.set('option', 'var', 'yosys_abc_clock_multiplier', "1000")  # convert from ns -> ps

lambdapdk/ihp130/libs/sg13g2_sram.py

@@ -15,7 +15,7 @@ def setup():
         path_base = 'ihp-sg13g2/libs.ref/sg13g2_sram'
         lib.add('output', stackup, 'lef', f'{path_base}/lef/{mem_name}.lef')
         lib.add('output', stackup, 'gds', f'{path_base}/gds/{mem_name}.gds')
-        lib.add('output', stackup, 'cdl', f'{path_base}/spice/{mem_name}.cdl')
+        lib.add('output', stackup, 'cdl', f'{path_base}/cdl/{mem_name}.cdl')
 
         lib.add('output', 'typ', 'nldm', f'{path_base}/lib/{mem_name}_typ_1p20V_25C.lib')
         lib.add('output', 'slow', 'nldm', f'{path_base}/lib/{mem_name}_slow_1p08V_125C.lib')

lambdapdk/ihp130/libs/sg13g2_stdcell.py

@@ -56,7 +56,7 @@ def setup():
     lib.add('output', 'rtl', 'verilog',
             'ihp-sg13g2/libs.ref/sg13g2_stdcell/verilog/sg13g2_stdcell.v')
 
-    # clock buffers
+    # clock buffers - remove once openroad driver supports it
     lib.add('asic', 'cells', 'clkbuf', ["sg13g2_buf_2",
                                         "sg13g2_buf_4"])
 
@@ -65,8 +65,9 @@ def setup():
                                      "LOGIC0_X1"])
 
     # hold cells
-    lib.add('asic', 'cells', 'hold', ["sg13g2_buf_1",
-                                      "sg13g2_buf_4"])
+    lib.add('asic', 'cells', 'hold', ["sg13g2_dlygate4sd1_1",
+                                      "sg13g2_dlygate4sd2_1",
+                                      "sg13g2_dlygate4sd3_1"])
 
     # filler
     lib.add('asic', 'cells', 'filler', ["sg13g2_fill_1",
@@ -81,9 +82,8 @@ def setup():
     # antenna
     lib.add('asic', 'cells', 'antenna', ["sg13g2_antennanp"])
 
-    # Stupid small cells
-    lib.add('asic', 'cells', 'dontuse', ["sg13g2_antennanp",
-                                         "sg13g2_lgcp_1",
+    # Dont use
+    lib.add('asic', 'cells', 'dontuse', ["sg13g2_lgcp_1",
                                          "sg13g2_sighold",
                                          "sg13g2_slgcp_1",
                                          "sg13g2_dfrbp_2"])

lambdapdk/interposer/__init__.py

@@ -0,0 +1,111 @@
+import os
+import siliconcompiler
+from lambdapdk import register_data_source
+
+
+stackups = []
+for m in ("3ML", "4ML", "5ML"):
+    for w in ("0400", "0800", "2000", "0400_2000"):
+        stackups.append(f'{m}_{w}')
+
+
+####################################################
+# PDK Setup
+####################################################
+def setup():
+    '''
+    The interposer PDK is a passive technology with a number of
+    simulated stackups. The PDK contains enablement for place and
+    route tools and design rule signoff.
+    Note that this process design kit is provided as an academic
+    and research aid only and the resulting designs are not manufacturable.
+    '''
+
+    foundry = 'virtual'
+    process = 'interposer'
+
+    libtype = 'none'
+
+    node = 130
+    # TODO: dummy numbers, only matter for cost estimation
+    wafersize = 300
+    hscribe = 0.1
+    vscribe = 0.1
+    edgemargin = 2
+
+    pdkdir = os.path.join('lambdapdk', 'interposer', 'base')
+
+    pdk = siliconcompiler.PDK(process, package='lambdapdk')
+    register_data_source(pdk)
+
+    # process name
+    pdk.set('pdk', process, 'foundry', foundry)
+    pdk.set('pdk', process, 'node', node)
+    pdk.set('pdk', process, 'version', 'v0.0.1')
+    pdk.set('pdk', process, 'stackup', stackups)
+    pdk.set('pdk', process, 'wafersize', wafersize)
+    pdk.set('pdk', process, 'edgemargin', edgemargin)
+    pdk.set('pdk', process, 'scribe', (hscribe, vscribe))
+
+    # APR Setup
+    for stackup in stackups:
+        for tool in ('openroad', 'klayout', 'magic'):
+            pdk.set('pdk', process, 'aprtech', tool, stackup, libtype, 'lef',
+                    pdkdir + f'/apr/{stackup}.lef')
+
+        pdk.set('pdk', process, 'minlayer', stackup, 'metal1')
+        pdk.set('pdk', process, 'maxlayer', stackup, 'topmetal')
+
+        # DRC Runsets
+        pdk.set('pdk', process, 'drc', 'runset', 'klayout', stackup, 'drc',
+                pdkdir + f'/setup/klayout/{stackup}.drc')
+
+        key = 'drc_params:drc'
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'input=<input>')
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'topcell=<topcell>')
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'report=<report>')
+        pdk.add('pdk', process, 'var', 'klayout', stackup, key, 'threads=<threads>')
+
+        # Layer map and display file
+        pdk.set('pdk', process, 'layermap', 'klayout', 'def', 'gds', stackup,
+                pdkdir + f'/apr/{stackup}.layermap')
+        pdk.set('pdk', process, 'display', 'klayout', stackup,
+                pdkdir + f'/setup/klayout/{stackup}.lyp')
+
+        pdk.set('pdk', process, 'aprtech', 'openroad', stackup, libtype, 'fill',
+                pdkdir + f'/dfm/openroad/{stackup}.fill.json')
+
+        # Openroad global routing grid derating
+        openroad_layer_adjustments = {
+            'metal1': 0.20,
+            'metal2': 0.20,
+            'metal3': 0.20,
+            'metal4': 0.20,
+            'metal5': 0.20,
+            'metal6': 0.20,
+            'topmetal': 0.20
+        }
+        for layer, adj in openroad_layer_adjustments.items():
+            if layer != 'topmetal' and int(layer[-1]) >= int(stackup[0]):
+                continue
+            pdk.set('pdk', process, 'var', 'openroad', f'{layer}_adjustment', stackup, adj)
+
+        pdk.set('pdk', process, 'var', 'openroad', 'rclayer_signal', stackup, 'metal2')
+        pdk.set('pdk', process, 'var', 'openroad', 'rclayer_clock', stackup, 'metal2')
+
+        pdk.set('pdk', process, 'var', 'openroad', 'pin_layer_vertical', stackup, 'metal2')
+        pdk.set('pdk', process, 'var', 'openroad', 'pin_layer_horizontal', stackup, 'metal3')
+
+        # PEX
+        for corner in ["minimum", "typical", "maximum"]:
+            pdk.set('pdk', process, 'pexmodel', 'openroad', stackup, corner,
+                    pdkdir + '/pex/openroad/' + stackup + '.' + corner + '.tcl')
+
+    return pdk
+
+
+#########################
+if __name__ == "__main__":
+    pdk = setup()
+    pdk.write_manifest(f'{pdk.top()}.json')
+    pdk.check_filepaths()

lambdapdk/interposer/_generator.py

@@ -0,0 +1,533 @@
+import json
+import os
+
+from jinja2 import Environment, FileSystemLoader
+import xml.etree.ElementTree as ET
+import xml.dom.minidom
+
+template_dir = os.path.join(os.path.dirname(__file__), 'base', 'templates')
+jinja2_env = Environment(loader=FileSystemLoader(template_dir))
+
+
+LICENSE = '''Copyright 2024 ZeroASIC Corp
+
+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.
+'''
+
+
+def __get_gds_type_name(gds_type):
+    if gds_type == 0:
+        return ""
+    if gds_type == 10:
+        return "pin"
+    if gds_type == 20:
+        return "text"
+    if gds_type == 30:
+        return "fill"
+
+    raise ValueError(str(gds_type))
+
+
+def make_metal_layer(
+        name,
+        gds_mapping,
+        direction,
+        min_width,
+        min_spacing,
+        resistance_per_um,
+        capacitance_per_um,
+        max_width=None):
+
+    layer = {
+        "name": name,
+        "type": "ROUTING",
+        "direction": direction,
+        "gds": gds_mapping,
+        "width": {
+            "min": min_width
+        },
+        "spacing": {
+            "min": min_spacing
+        },
+        "parasitic": {
+            "resistance": resistance_per_um,
+            "capacitance": capacitance_per_um
+        }
+    }
+
+    if max_width:
+        layer["width"]["max"] = max_width
+
+    return layer
+
+
+def make_cut_layer(
+        name,
+        gds_mapping,
+        width,
+        min_spacing,
+        enclosure_bot,
+        enclosure_top,
+        resistance_per_cut):
+
+    layer = {
+        "name": name,
+        "type": "CUT",
+        "gds": gds_mapping,
+        "width": {
+            "min": width
+        },
+        "spacing": {
+            "min": min_spacing
+        },
+        "enclosure": {
+            "bottom": enclosure_bot,
+            "top": enclosure_top
+        },
+        "parasitic": {
+            "resistance": resistance_per_cut
+        }
+    }
+
+    return layer
+
+
+def build_tech(layer_count, name=None, width=None):
+    if not isinstance(width, (tuple, list)):
+        width = layer_count * [width]
+
+    layers = []
+    gds_layer = 1
+    for n in range(layer_count):
+        layeridx = n + 1
+
+        metal_name = f"metal{layeridx}"
+        max_width = 5.0
+        if layeridx == layer_count:
+            metal_name = "topmetal"
+            gds_layer = 100
+            max_width = None
+
+        layers.append(
+            make_metal_layer(
+                metal_name,
+                {
+                    "number": gds_layer,
+                    "types": {
+                        "NET": 0,
+                        "SPNET": 0,
+                        "PIN": 10,
+                        "LEFPIN": 10,
+                        "FILL": 30
+                    },
+                    "name": {
+                        "PIN": 20,
+                        "SPNET": 20,
+                        "TEXT": 20
+                    }
+                },
+                "HORIZONTAL" if layeridx % 2 == 1 else "VERTICAL",
+                min_width=width[n],
+                min_spacing=width[n],
+                resistance_per_um=1.5000e-03,
+                capacitance_per_um=1.0000E-01,
+                max_width=max_width
+            ))
+
+        if layeridx != layer_count:
+            layers.append(
+                make_cut_layer(
+                    f"via{layeridx}",
+                    {
+                        "number": gds_layer + 1,
+                        "types": {
+                            "NET": 0,
+                            "SPNET": 0,
+                            "PIN": 10,
+                            "LEFPIN": 10,
+                            "FILL": 30
+                        },
+                        "name": {
+                            "PIN": 20,
+                            "SPNET": 20,
+                            "TEXT": 20
+                        }
+                    },
+                    width[n] / 2,
+                    width[n] / 2,
+                    width[n] / 2,
+                    width[n] / 2,
+                    resistance_per_cut=10e-3
+                ))
+        gds_layer += 2
+
+    if not name:
+        name = f"{layer_count}ML"
+
+    tech = {
+        "name": name,
+        "grid": 0.005,
+        "layers": layers,
+        "outline": (0, 0)
+    }
+
+    return tech
+
+
+def build_layermap(tech, path):
+    layermap = []
+    for layer in tech["layers"]:
+        name = layer["name"]
+        gds_number = layer["gds"]["number"]
+
+        for map_type, gds_type in layer["gds"]["types"].items():
+            layermap.append((
+                name,
+                map_type,
+                str(gds_number),
+                str(gds_type)
+            ))
+
+        for map_type, gds_type in layer["gds"]["name"].items():
+            layermap.append((
+                "NAME",
+                f"{name}/{map_type}",
+                str(gds_number),
+                str(gds_type)
+            ))
+
+    layermap.append((
+        "DIEAREA",
+        "ALL",
+        str(tech["outline"][0]),
+        str(tech["outline"][1])
+    ))
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.layermap', 'w') as f:
+        f.write(
+            jinja2_env.get_template('layermap.j2').render(
+                license=LICENSE,
+                layers=layermap
+            )
+        )
+        f.write('\n')
+
+
+def build_openroad_pex(tech, path):
+    corners = {
+        "maximum": 0.3,
+        "typical": 0.0,
+        "minimum": -0.3
+    }
+
+    for corner, adjustment in corners.items():
+        metals = []
+        vias = []
+        for layer in tech["layers"]:
+            name = layer["name"]
+
+            if layer["type"] == "ROUTING":
+                metals.append((
+                    name,
+                    layer["parasitic"]["resistance"]*(1+adjustment),
+                    layer["parasitic"]["capacitance"]*(1+adjustment)
+                ))
+            else:
+                vias.append((
+                    name,
+                    layer["parasitic"]["resistance"]*(1+adjustment)
+                ))
+
+        os.makedirs(path, exist_ok=True)
+        with open(f'{path}/{tech["name"]}.{corner}.tcl', 'w') as f:
+            f.write(
+                jinja2_env.get_template('pex.tcl.j2').render(
+                    license=LICENSE,
+                    metals=metals,
+                    vias=vias
+                )
+            )
+            f.write('\n')
+
+
+def build_klayout_drc(tech, path):
+    layers = []
+
+    for n, layer in enumerate(tech["layers"]):
+        layer_nm = {
+            "name": layer["name"],
+            "type": layer["type"],
+            "width": {
+                "min": int(layer["width"]["min"] * 1000)
+            },
+            "spacing": {
+                "min": int(layer["spacing"]["min"] * 1000)
+            }
+        }
+
+        if "max" in layer["width"]:
+            layer_nm["width"]["max"] = int(layer["width"]["max"] * 1000)
+
+        if layer["type"] == "CUT":
+            layer_nm["enclosure"] = {
+                "bottom": (
+                    tech["layers"][n - 1]["name"],
+                    int(layer["enclosure"]["bottom"] * 1000)
+                ),
+                "top": (
+                    tech["layers"][n + 1]["name"],
+                    int(layer["enclosure"]["top"] * 1000)
+                )
+            }
+
+        gds_types = sorted(set(layer["gds"]["types"].values()))
+        layer_nm["gds"] = [
+            (layer["gds"]["number"], gds_type) for gds_type in gds_types
+        ]
+
+        layers.append(layer_nm)
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.drc', 'w') as f:
+        f.write(
+            jinja2_env.get_template('drc.j2').render(
+                license=LICENSE,
+                grid=int(tech["grid"] * 1000),
+                layers=layers,
+                outline={"number": tech["outline"][0], "type": tech["outline"][1]}
+            )
+        )
+        f.write('\n')
+
+
+def build_klayout_layer_properties(tech, path):
+    colors = [
+        "#ffc280",
+        "#ff9d9d",
+        "#ff80a8",
+        "#c080ff",
+        "#9580ff",
+        "#8086ff",
+        "#80a8ff",
+        "#ff0000",
+        "#ff0080",
+        "#ff00ff",
+        "#8000ff",
+        "#91ff00",
+        "#008000",
+        "#508000",
+        "#808000",
+        "#805000"
+    ]
+    patterns = [
+        "I5",
+        "I9"
+    ]
+
+    layeridx = 0
+
+    def make_layer(name, gds):
+        prop = ET.Element("properties")
+
+        color = colors[layeridx % len(colors)]
+        pattern = patterns[layeridx % len(patterns)]
+
+        for tag, value in [
+                ("frame-color", color),
+                ("frame-brightness", "0"),
+                ("fill-color", color),
+                ("fill-brightness", "0"),
+                ("dither-pattern", pattern),
+                ("line-style", None),
+                ("value", "true"),
+                ("visible", "true"),
+                ("transparent", "false"),
+                ("width", "1"),
+                ("marked", "false"),
+                ("xfill", "false"),
+                ("animation", "0"),
+                ("name", name),
+                ("source", f"{name} {gds[0]}/{gds[1]}@1")
+                ]:
+            el = ET.Element(tag)
+
+            if value is not None:
+                el.text = value
+            prop.append(el)
+
+        return prop
+
+    props = ET.Element("layer-properties")
+    props.append(make_layer("outline", (tech["outline"][0], tech["outline"][1])))
+    layeridx += 1
+    for layer in tech["layers"]:
+        gds_types = sorted(set([*layer["gds"]["types"].values(), *layer["gds"]["name"].values()]))
+        for gds_type in gds_types:
+            name = layer["name"]
+            gds_name = __get_gds_type_name(gds_type)
+            if gds_type:
+                name += "." + gds_name
+            props.append(make_layer(name, (layer["gds"]["number"], gds_type)))
+
+            layeridx += 1
+
+    props.insert(0, ET.Comment(f"\n{LICENSE}"))
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.lyp', 'w') as f:
+        f.write(
+            xml.dom.minidom.parseString(
+                ET.tostring(props)).toprettyxml(indent="  "))
+
+
+def build_lef(tech, path):
+    vias = []
+    for n, layer in enumerate(tech["layers"]):
+        if layer["type"] == "ROUTING":
+            continue
+        bottom_layer = tech["layers"][n - 1]
+        top_layer = tech["layers"][n + 1]
+
+        name = layer["name"].upper() + "_1"
+
+        cut_egde = layer["width"]["min"]
+        cut = (-cut_egde / 2, -cut_egde / 2, cut_egde / 2, cut_egde / 2)
+        bot = (cut[0] - layer["enclosure"]['bottom'], cut[1] - layer["enclosure"]['bottom'],
+               cut[2] + layer["enclosure"]['bottom'], cut[3] + layer["enclosure"]['bottom'])
+        top = (cut[0] - layer["enclosure"]['top'], cut[1] - layer["enclosure"]['top'],
+               cut[2] + layer["enclosure"]['top'], cut[3] + layer["enclosure"]['top'])
+
+        vias.append({
+            "name": name,
+            "layers": [
+                (layer["name"], [f"{v:.3f}" for v in cut]),
+                (bottom_layer["name"], [f"{v:.3f}" for v in bot]),
+                (top_layer["name"], [f"{v:.3f}" for v in top])
+            ]})
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.lef', 'w') as f:
+        f.write(
+            jinja2_env.get_template('lef.j2').render(
+                license=LICENSE,
+                grid=tech["grid"],
+                layers=tech["layers"],
+                vias=vias
+            )
+        )
+
+
+def build_openroad_fill(tech, path):
+    fill = {"layers": {}}
+
+    for layer in tech["layers"]:
+        if layer["type"] == "CUT":
+            continue
+
+        max_spacing = 5 * layer["spacing"]["min"]
+
+        max_width = 10 * layer["width"]["min"]
+        if "max" in layer["width"]:
+            max_width = layer["width"]["max"]
+
+        shapes = []
+        for ratio in (1.0, 0.75, 0.5, 0.25, 0.0):
+            width = layer["width"]["min"] + ratio * (max_width - layer["width"]["min"])
+            width = tech["grid"] * round(width / tech["grid"])
+
+            shapes.append(width)
+
+        fill["layers"][layer["name"]] = {
+            "name": layer["name"],
+            "layer": layer["gds"]["number"],
+            "datatype": layer["gds"]["types"]["NET"],
+            "space_to_outline": max_spacing,
+            "non-opc": {
+                "datatype": layer["gds"]["types"]["FILL"],
+                "width": shapes,
+                "height": shapes,
+                "space_to_fill": layer["spacing"]["min"],
+                "space_to_non_fill": max_spacing
+            }
+        }
+
+    os.makedirs(path, exist_ok=True)
+    with open(f'{path}/{tech["name"]}.fill.json', 'w') as f:
+        json.dump(fill, f, indent=2)
+
+
+def build_readme(stackups):
+    from lambdapdk import interposer
+
+    for stackup in stackups:
+        metals = []
+        for layer in stackup["tech"]["layers"]:
+            if layer["type"] == "ROUTING":
+                metals.append((
+                    layer["name"],
+                    f'{int(layer["width"]["min"] * 1000)}nm',
+                    f'{int(layer["spacing"]["min"] * 1000)}nm'
+                ))
+        stackup["metalstack"] = reversed(metals)
+
+    with open('README.md', 'w') as f:
+        f.write(
+            jinja2_env.get_template('README.md.j2').render(
+                desc=interposer.setup.__doc__,
+                license=LICENSE,
+                stackups=stackups
+            )
+        )
+
+
+if __name__ == "__main__":
+    def tapered_metal(layer_count):
+        mid = int(layer_count // 2)
+        widths = mid * [0.4]
+        if layer_count % 2 != 0:
+            widths += [0.8]
+        widths += mid * [2.0]
+        return widths
+
+    tech_specs = {
+        "0400": 0.4,
+        "0800": 0.8,
+        "2000": 2.0,
+        "0400_2000": tapered_metal
+    }
+
+    stackups = []
+
+    for name, width in tech_specs.items():
+        for layer_count in range(3, 6):
+            tech_name = f"{layer_count}ML_{name}"
+
+            widths = width
+            if not isinstance(widths, (int, float, list, tuple)):
+                widths = widths(layer_count)
+
+            tech = build_tech(layer_count, name=tech_name, width=widths)
+            stackups.append({
+                "name": tech_name,
+                "tech": tech
+            })
+
+            build_lef(tech, 'base/apr')
+            build_layermap(tech, 'base/apr')
+            build_klayout_layer_properties(tech, 'base/setup/klayout')
+            build_klayout_drc(tech, 'base/setup/klayout')
+            build_openroad_pex(tech, 'base/pex/openroad')
+            build_openroad_fill(tech, 'base/dfm/openroad')
+
+    build_readme(stackups)

lambdapdk/interposer/libs/bumps.py

@@ -0,0 +1,31 @@
+import os
+import siliconcompiler
+from lambdapdk import register_data_source
+from lambdapdk.interposer import stackups
+
+
+def setup():
+    '''
+    Interposer bump library
+    '''
+    libdir = "lambdapdk/interposer/libs/bumps/"
+
+    lib = siliconcompiler.Library('interposer_bumps', package='lambdapdk')
+    register_data_source(lib)
+
+    # pdk
+    lib.set('option', 'pdk', 'interposer')
+
+    for stackup in stackups:
+        lib.set('output', stackup, 'lef',
+                os.path.join(libdir, 'lef/bumps.lef'))
+        lib.add('output', stackup, 'gds',
+                os.path.join(libdir, 'gds/bumps.gds'))
+
+    return lib
+
+
+#########################
+if __name__ == "__main__":
+    lib = setup(siliconcompiler.Chip('<lib>'))
+    lib.write_manifest(f'{lib.top()}.json')

lambdapdk/sky130/libs/sky130sc.py

@@ -104,19 +104,20 @@ def setup():
         lib.add('asic', 'cells', 'clkbuf', [f'sky130_fd_sc_{libtype}__clkbuf_1',
                                             f'sky130_fd_sc_{libtype}__clkbuf_2',
                                             f'sky130_fd_sc_{libtype}__clkbuf_4',
-                                            f'sky130_fd_sc_{libtype}__clkbuf_6',
                                             f'sky130_fd_sc_{libtype}__clkbuf_8',
-                                            f'sky130_fd_sc_{libtype}__clkbuf_12',
                                             f'sky130_fd_sc_{libtype}__clkbuf_16'])
+        if libtype == "hdll":
+            lib.add('asic', 'cells', 'clkbuf', [f'sky130_fd_sc_{libtype}__clkbuf_6',
+                                                f'sky130_fd_sc_{libtype}__clkbuf_12'])
 
         # hold cells
-        lib.add('asic', 'cells', 'hold', [f'sky130_fd_sc_{libtype}__buf_1',
-                                          f'sky130_fd_sc_{libtype}__buf_2',
-                                          f'sky130_fd_sc_{libtype}__buf_4',
-                                          f'sky130_fd_sc_{libtype}__buf_6',
-                                          f'sky130_fd_sc_{libtype}__buf_8',
-                                          f'sky130_fd_sc_{libtype}__buf_12',
-                                          f'sky130_fd_sc_{libtype}__buf_16'])
+        lib.add('asic', 'cells', 'hold', [f'sky130_fd_sc_{libtype}__dlygate4sd1_1',
+                                          f'sky130_fd_sc_{libtype}__dlygate4sd2_1',
+                                          f'sky130_fd_sc_{libtype}__dlygate4sd3_1'])
+        if libtype == "hd":
+            lib.add('asic', 'cells', 'hold', [f'sky130_fd_sc_{libtype}__dlymetal6s2s_1',
+                                              f'sky130_fd_sc_{libtype}__dlymetal6s4s_1',
+                                              f'sky130_fd_sc_{libtype}__dlymetal6s6s_1'])
 
         # filler
         lib.add('asic', 'cells', 'filler', [f'sky130_fd_sc_{libtype}__fill_1',
@@ -160,8 +161,6 @@ def setup():
         lib.set('option', 'file', 'openroad_tapcells',
                 libdir + '/apr/openroad/tapcell.tcl')
 
-        lib.set('option', 'var', 'openroad_cts_clock_buffer', f"sky130_fd_sc_{libtype}__clkbuf_4")
-
         lib.set('option', 'var', 'yosys_abc_clock_multiplier', "1000")  # convert from ns -> ps
 
         cap_table = {

{lambdapdk-0.1.37.dist-info → lambdapdk-0.1.39.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: lambdapdk
-Version: 0.1.37
+Version: 0.1.39
 Summary: Library of open source Process Design Kits
 Author: Zero ASIC
-License: Apache License
+License:                                  Apache License
                                    Version 2.0, January 2004
                                 http://www.apache.org/licenses/
         
@@ -198,14 +198,15 @@ Project-URL: Homepage, https://github.com/siliconcompiler/lambdapdk
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: siliconcompiler >=0.27.0
+Requires-Dist: siliconcompiler>=0.27.0
 Provides-Extra: test
-Requires-Dist: flake8 ==7.1.1 ; extra == 'test'
-Requires-Dist: pytest ==8.3.3 ; extra == 'test'
-Requires-Dist: pytest-timeout ==2.3.1 ; extra == 'test'
-Requires-Dist: tclint ==0.4.2 ; extra == 'test'
-Requires-Dist: lambdalib ==0.3.0 ; extra == 'test'
-Requires-Dist: sc-leflib ==0.4.0 ; extra == 'test'
+Requires-Dist: flake8==7.1.1; extra == "test"
+Requires-Dist: pytest==8.3.4; extra == "test"
+Requires-Dist: pytest-timeout==2.3.1; extra == "test"
+Requires-Dist: tclint==0.5.0; extra == "test"
+Requires-Dist: lambdalib==0.3.2; extra == "test"
+Requires-Dist: sc-leflib==0.4.0; extra == "test"
+Requires-Dist: Jinja2==3.1.4; extra == "test"
 
 # Lambdapdk Introduction
 
@@ -221,6 +222,7 @@ Supported PDKs:
 * [Skywater130](lambdapdk/sky130/base/README.md)
 * [Global Foundries 180](lambdapdk/gf180/README.md)
 * [IHP 180](https://github.com/IHP-GmbH/IHP-Open-PDK)
+* [interposer](lambdapdk/interposer/README.md)
 
 # License
 

lambdapdk-0.1.39.dist-info/RECORD

@@ -0,0 +1,27 @@
+lambdapdk/__init__.py,sha256=Ub57VU23usHGYzywXktgCbnaRoi8-HQUBwdyfDlkzfI,1771
+lambdapdk/asap7/__init__.py,sha256=RrRTx_dFEsHnTWCGwzNUVmY8-2lOAd2EcWs7w8KwRPI,4736
+lambdapdk/asap7/libs/asap7sc7p5t.py,sha256=YCj1yCYLylF72EMJx2zY9KX1ZIkGsHuMDsCGrq9ud4E,6030
+lambdapdk/asap7/libs/fakeio7.py,sha256=t4OQ7uljg4jh14bf3o4wsnI5gNkLEVpMs1drispc7LE,978
+lambdapdk/asap7/libs/fakeram7.py,sha256=thOHy0XyV2-pakoxrttGL3qU9C2OeL1-MVtlrSiTMu8,1112
+lambdapdk/freepdk45/__init__.py,sha256=5lbmMi3tGM1mJoM1wOGG0GhjKaFc2Qi3x-tRO8kKSDs,3673
+lambdapdk/freepdk45/libs/fakeram45.py,sha256=CqX9YTFLQFlmGn4IZDjEI1OXv43mg3aWdbVfMrBKNSU,1091
+lambdapdk/freepdk45/libs/nangate45.py,sha256=vh_OsCzTKInpAVt1oC6QOyPjEuxFzYRGY3Ngopffh-o,4638
+lambdapdk/gf180/__init__.py,sha256=fbJ4z0kXBftIHAsgyqJmbpZfpWf9PWuxXgoQoG3IhQ0,7963
+lambdapdk/gf180/libs/gf180io.py,sha256=6WgsALOaKWYG6RfNFz6sg36zmfZZFl2HnsDWOWYy1UM,2751
+lambdapdk/gf180/libs/gf180mcu.py,sha256=g8s6xpH8Glj6m7aIubX2EmyG2eLXbVsZOSWKYhaujQ8,6604
+lambdapdk/gf180/libs/gf180sram.py,sha256=uNtf4JOaT6wlD7D6hN5XwCoIOPmAXkVxSJXQuqNdY6k,2140
+lambdapdk/ihp130/__init__.py,sha256=dSXwH5rYOrJc9C3FTe9bxCJw9VZaK0fnRBMWaWT9NY8,5500
+lambdapdk/ihp130/libs/sg13g2_sram.py,sha256=oFg89-kKvuBBI9IsdGkuTsG9Q8i4gzImF66MXMXY4Fk,1885
+lambdapdk/ihp130/libs/sg13g2_stdcell.py,sha256=un7-NQBTYCMWJOjLMgw1BcBdy1kjEX_kjoRY1QpDmXI,5134
+lambdapdk/interposer/__init__.py,sha256=UEAxcCLo-0OheGNCOTLpwnF05HFAz3agStFBTdcgS58,4039
+lambdapdk/interposer/_generator.py,sha256=Uf9i7gfjgntUpLmxsRmOfzfgh26iQ3nfZmrdIx59UtA,15016
+lambdapdk/interposer/libs/bumps.py,sha256=-b3cNOUBKhzzxoWI1Y047g9Ev3a_mXBMLKO3BaHo1sI,771
+lambdapdk/sky130/__init__.py,sha256=PXJEa-siz7HStlvDTCI794evU8qbHl472gHckSrZFWc,4124
+lambdapdk/sky130/libs/sky130io.py,sha256=wFmN9RC98f6OFM5E5acCUgPe35tVTKciJzIcUBlmumo,2029
+lambdapdk/sky130/libs/sky130sc.py,sha256=GSgYjyPQPFzEKByP2P9VJVOIr1hqMe_glow6TSszIx4,9399
+lambdapdk/sky130/libs/sky130sram.py,sha256=ILjAjbgDdvfiWqmjmj8mmHvU7YiYGZVHGO7jmyajnaY,1489
+lambdapdk-0.1.39.dist-info/LICENSE,sha256=2TIhku7H905BsYloYoCwat2JsdkGYc_qsnvU-p7P-IQ,10766
+lambdapdk-0.1.39.dist-info/METADATA,sha256=d2bajU8KNRguQHB5k40TTeM8APUAc9igQeLVHx25F1o,13947
+lambdapdk-0.1.39.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+lambdapdk-0.1.39.dist-info/top_level.txt,sha256=5wk8psZwCcQgSjOlWTihBeDkSIViGn8I3j5yALbs59s,10
+lambdapdk-0.1.39.dist-info/RECORD,,

{lambdapdk-0.1.37.dist-info → lambdapdk-0.1.39.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

lambdapdk-0.1.37.dist-info/RECORD

@@ -1,24 +0,0 @@
-lambdapdk/__init__.py,sha256=P2gEp_UXfnGsDxtCuMoUtIVg9WZPgxAVz7FoInH56pY,1649
-lambdapdk/asap7/__init__.py,sha256=Tb3du7LEisL_YoXVzVZgy9NqC835F79a9zqlV0MwBO0,4571
-lambdapdk/asap7/libs/asap7sc7p5t.py,sha256=mKymeYPmNTHgxfwyIShxUN5hO1iAzgx2MWoBbfPkChU,6159
-lambdapdk/asap7/libs/fakeio7.py,sha256=t4OQ7uljg4jh14bf3o4wsnI5gNkLEVpMs1drispc7LE,978
-lambdapdk/asap7/libs/fakeram7.py,sha256=thOHy0XyV2-pakoxrttGL3qU9C2OeL1-MVtlrSiTMu8,1112
-lambdapdk/freepdk45/__init__.py,sha256=5lbmMi3tGM1mJoM1wOGG0GhjKaFc2Qi3x-tRO8kKSDs,3673
-lambdapdk/freepdk45/libs/fakeram45.py,sha256=CqX9YTFLQFlmGn4IZDjEI1OXv43mg3aWdbVfMrBKNSU,1091
-lambdapdk/freepdk45/libs/nangate45.py,sha256=z319EBburWngwe_WYMHfksiFvfgJ0h4zLCEeWkcHTVs,4592
-lambdapdk/gf180/__init__.py,sha256=fbJ4z0kXBftIHAsgyqJmbpZfpWf9PWuxXgoQoG3IhQ0,7963
-lambdapdk/gf180/libs/gf180io.py,sha256=6WgsALOaKWYG6RfNFz6sg36zmfZZFl2HnsDWOWYy1UM,2751
-lambdapdk/gf180/libs/gf180mcu.py,sha256=NPwcviynLMXRlkvAdwNrp8sJxHzT78PE0Iwy-DNpgzA,6727
-lambdapdk/gf180/libs/gf180sram.py,sha256=uNtf4JOaT6wlD7D6hN5XwCoIOPmAXkVxSJXQuqNdY6k,2140
-lambdapdk/ihp130/__init__.py,sha256=dSXwH5rYOrJc9C3FTe9bxCJw9VZaK0fnRBMWaWT9NY8,5500
-lambdapdk/ihp130/libs/sg13g2_sram.py,sha256=3D5MKweUeOpWTHmtESbt8AyddjAvcpw9SeSbz4cfFG4,1887
-lambdapdk/ihp130/libs/sg13g2_stdcell.py,sha256=i92vJvo2bur2lL9YKtyrZ2kDP8QiqmbTqWnSQeSiKhE,5085
-lambdapdk/sky130/__init__.py,sha256=PXJEa-siz7HStlvDTCI794evU8qbHl472gHckSrZFWc,4124
-lambdapdk/sky130/libs/sky130io.py,sha256=wFmN9RC98f6OFM5E5acCUgPe35tVTKciJzIcUBlmumo,2029
-lambdapdk/sky130/libs/sky130sc.py,sha256=wW6sAaPpuqqCDqUD2cdJZJXqQz6KRLz9xztQ-hLNaC8,9446
-lambdapdk/sky130/libs/sky130sram.py,sha256=ILjAjbgDdvfiWqmjmj8mmHvU7YiYGZVHGO7jmyajnaY,1489
-lambdapdk-0.1.37.dist-info/LICENSE,sha256=2TIhku7H905BsYloYoCwat2JsdkGYc_qsnvU-p7P-IQ,10766
-lambdapdk-0.1.37.dist-info/METADATA,sha256=uZccfzu6ySZkmLcy3u4H-NKr5f70z4bdq4W2jqRRNyg,13834
-lambdapdk-0.1.37.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-lambdapdk-0.1.37.dist-info/top_level.txt,sha256=5wk8psZwCcQgSjOlWTihBeDkSIViGn8I3j5yALbs59s,10
-lambdapdk-0.1.37.dist-info/RECORD,,