| #!/usr/bin/env python3 |
| # Copyright 2020 Efabless Corporation |
| # |
| # 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 |
| # |
| # http://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. |
| """ |
| Takes a pre-routed top-level layout and creates the pg connections |
| from the power/ground pads to the *core ring* |
| """ |
| |
| import sys |
| import argparse |
| import odb |
| |
| parser = argparse.ArgumentParser( |
| description="Produces a DEF file with VDD and GND special nets\ |
| where the power pads are connected to the core ring" |
| ) |
| |
| parser.add_argument( |
| "--input-def", "-d", required=True, help="DEF view of the design pre-routing" |
| ) |
| |
| parser.add_argument( |
| "--input-lef", |
| "-l", |
| required=True, |
| help="LEF file needed to have a proper view of the DEF", |
| ) |
| |
| parser.add_argument( |
| "--core-vdd-pin", |
| "-cvdd", |
| required=True, |
| help="Name of the power pin of core macro (exposed as its core ring)", |
| ) |
| |
| parser.add_argument( |
| "--core-gnd-pin", |
| "-cgnd", |
| required=True, |
| help="Name of the ground pin of core macro (exposed as its core ring)", |
| ) |
| |
| |
| parser.add_argument( |
| "--output-def", |
| "-o", |
| required=True, |
| default="output.def", |
| help="Output power-routed DEF", |
| ) |
| |
| parser.add_argument( |
| "--vdd-pad-pin-map", |
| "-vmap", |
| action="append", |
| nargs=2, |
| required=False, |
| default=None, |
| help="Mappings to mark PAD-pin pairs as part of the VDD net. Defaults to sky130 settings.", |
| ) |
| |
| parser.add_argument( |
| "--gnd-pad-pin-map", |
| "-gmap", |
| action="append", |
| nargs=2, |
| required=False, |
| default=None, |
| help="Mappings to mark PAD-pin pairs as part of the GND net. Defaults to sky130 settings.", |
| ) |
| |
| |
| args = parser.parse_args() |
| |
| def_file_name = args.input_def |
| lef_file_name = args.input_lef |
| output_def_file_name = args.output_def |
| core_vdd_pin = args.core_vdd_pin |
| core_gnd_pin = args.core_gnd_pin |
| vdd_pad_pin_map = args.vdd_pad_pin_map |
| gnd_pad_pin_map = args.gnd_pad_pin_map |
| |
| |
| # TODO: expose through arguments |
| ORIENT_LOC_MAP = {"R0": "N", "R90": "W", "R180": "S", "R270": "E"} |
| |
| # TODO: allow control |
| VDD_NET_NAME = "VDD" |
| GND_NET_NAME = "GND" |
| |
| # SKY130 DEFAULT |
| SPECIAL_NETS = { |
| VDD_NET_NAME: {"core_pin": core_vdd_pin, "covered": False, "map": []}, |
| GND_NET_NAME: {"core_pin": core_gnd_pin, "covered": False, "map": []}, |
| } |
| |
| if vdd_pad_pin_map is None: |
| vdd_pad_pin_map = [{"pad_pin": "vccd", "pad_name_substr": "vccd"}] |
| else: |
| vdd_pad_pin_map = [ |
| {"pad_pin": mapping[0], "pad_name_substr": mapping[1]} |
| for mapping in vdd_pad_pin_map |
| ] |
| |
| if gnd_pad_pin_map is None: |
| gnd_pad_pin_map = [ |
| {"pad_pin": "vssd", "pad_name_substr": "vssd"}, |
| {"pad_pin": "vssa", "pad_name_substr": "vssa"}, |
| {"pad_pin": "vssio", "pad_name_substr": "vssio"}, |
| ] |
| else: |
| gnd_pad_pin_map = [ |
| {"pad_pin": mapping[0], "pad_name_substr": mapping[1]} |
| for mapping in gnd_pad_pin_map |
| ] |
| |
| SPECIAL_NETS[VDD_NET_NAME]["map"] = vdd_pad_pin_map |
| SPECIAL_NETS[GND_NET_NAME]["map"] = gnd_pad_pin_map |
| |
| |
| ################## |
| |
| db_top = odb.dbDatabase.create() |
| odb.read_lef(db_top, lef_file_name) |
| odb.read_def(db_top, def_file_name) |
| |
| chip_top = db_top.getChip() |
| block_top = chip_top.getBlock() |
| top_design_name = block_top.getName() |
| tech = db_top.getTech() |
| |
| via_rules = tech.getViaGenerateRules() |
| print("Found", len(via_rules), "VIA GENERATE rules") |
| |
| # build dictionary of basic custom vias (ROW = COL = 1) |
| custom_vias = {} |
| for rule in via_rules: |
| lower_rules = rule.getViaLayerRule(0) |
| upper_rules = rule.getViaLayerRule(1) |
| cut_rules = rule.getViaLayerRule(2) |
| |
| lower_layer = lower_rules.getLayer() |
| upper_layer = upper_rules.getLayer() |
| cut_layer = cut_rules.getLayer() |
| |
| if lower_layer.getName() in custom_vias: |
| print("Skipping", rule.getName()) |
| continue |
| |
| via_params = odb.dbViaParams() |
| |
| via_params.setBottomLayer(lower_layer) |
| via_params.setTopLayer(upper_layer) |
| via_params.setCutLayer(cut_layer) |
| |
| cut_rect = cut_rules.getRect() |
| via_params.setXCutSize(cut_rect.dx()) |
| via_params.setYCutSize(cut_rect.dy()) |
| |
| cut_spacing = cut_rules.getSpacing() |
| via_params.setXCutSpacing(cut_spacing[0] - cut_rect.dx()) |
| via_params.setYCutSpacing(cut_spacing[1] - cut_rect.dy()) |
| |
| lower_enclosure = lower_rules.getEnclosure() |
| upper_enclosure = upper_rules.getEnclosure() |
| if "M1M2" in rule.getName(): |
| print(lower_enclosure) |
| via_params.setXBottomEnclosure(lower_enclosure[0]) |
| via_params.setYBottomEnclosure(lower_enclosure[1]) |
| via_params.setXTopEnclosure(upper_enclosure[0]) |
| via_params.setYTopEnclosure(upper_enclosure[1]) |
| |
| custom_vias[lower_layer.getName()] = {} |
| custom_vias[lower_layer.getName()][upper_layer.getName()] = { |
| "rule": rule, |
| "params": via_params, |
| } |
| print("Added", rule.getName()) |
| |
| |
| def create_custom_via(layer1, layer2, width, height, reorient="R0"): |
| assert width > 0 and height > 0 |
| |
| if layer1.getRoutingLevel() < layer2.getRoutingLevel(): |
| lower_layer_name = layer1.getName() |
| upper_layer_name = layer2.getName() |
| elif layer1.getRoutingLevel() > layer2.getRoutingLevel(): |
| lower_layer_name = layer2.getName() |
| upper_layer_name = layer1.getName() |
| else: |
| raise Exception("Cannot create a custom via between two identical layers") |
| |
| if reorient in ["R90", "R270"]: |
| width, height = height, width |
| |
| via_name = "via_%s_%s_%dx%d" % (lower_layer_name, upper_layer_name, width, height) |
| |
| custom_via = block_top.findVia(via_name) |
| if not custom_via: |
| print("Creating", via_name) |
| |
| via_params = custom_vias[lower_layer_name][upper_layer_name]["params"] |
| via_rule = custom_vias[lower_layer_name][upper_layer_name]["rule"] |
| |
| cut_width = via_params.getXCutSize() |
| cut_height = via_params.getYCutSize() |
| cut_spacing_x = via_params.getXCutSpacing() |
| cut_spacing_y = via_params.getXCutSpacing() |
| lower_enclosure_x = via_params.getXBottomEnclosure() |
| lower_enclosure_y = via_params.getYBottomEnclosure() |
| upper_enclosure_x = via_params.getXTopEnclosure() |
| upper_enclosure_y = via_params.getYTopEnclosure() |
| |
| custom_via = odb.dbVia_create(block_top, via_name) |
| custom_via.setViaGenerateRule(via_rule) |
| |
| array_width = width - 2 * max(lower_enclosure_x, upper_enclosure_x) |
| array_height = height - 2 * max(lower_enclosure_y, upper_enclosure_y) |
| |
| # set ROWCOL |
| rows = 1 + (array_height - cut_height) // (cut_spacing_y + cut_height) |
| cols = 1 + (array_width - cut_width) // (cut_spacing_x + cut_width) |
| via_params.setNumCutRows(rows) |
| via_params.setNumCutCols(cols) |
| |
| custom_via.setViaParams(via_params) |
| |
| return custom_via |
| |
| |
| def boxes2Rects(boxes, transform): |
| rects = [] |
| for box in boxes: |
| ur = odb.Point(box.xMin(), box.yMin()) |
| ll = odb.Point(box.xMax(), box.yMax()) |
| transform.apply(ll) |
| transform.apply(ur) |
| pin_layer = box.getTechLayer() |
| |
| rects.append({"layer": pin_layer, "rect": odb.Rect(ll, ur)}) |
| return rects |
| |
| |
| def getInstObs(inst): |
| master = inst.getMaster() |
| master_ox, master_oy = master.getOrigin() |
| inst_ox, inst_oy = inst.getOrigin() |
| px, py = master_ox + inst_ox, master_oy + inst_oy |
| orient = inst.getOrient() |
| transform = odb.dbTransform(orient, odb.Point(px, py)) |
| |
| obstructions = master.getObstructions() |
| rects = boxes2Rects(obstructions, transform) |
| for rect in rects: |
| rect["type"] = "obstruction" |
| return rects |
| |
| |
| def getITermBoxes(iterm): |
| iterm_boxes = [] |
| inst = iterm.getInst() |
| mterm = iterm.getMTerm() |
| master_ox, master_oy = inst.getMaster().getOrigin() |
| inst_ox, inst_oy = inst.getOrigin() |
| px, py = master_ox + inst_ox, master_oy + inst_oy |
| orient = inst.getOrient() |
| transform = odb.dbTransform(orient, odb.Point(px, py)) |
| mpins = mterm.getMPins() |
| if len(mpins) > 1: |
| print( |
| "Warning:", len(mpins), "mpins for iterm", inst.getName(), mterm.getName() |
| ) |
| for i in range(len(mpins)): |
| mpin = mpins[i] |
| boxes = mpin.getGeometry() |
| iterm_boxes += boxes2Rects(boxes, transform) |
| |
| # filter duplications |
| # TODO: OpenDB bug? duplicate mpins for some reason |
| iterm_boxes_set = set() |
| iterm_boxes_uniq = [] |
| for box in iterm_boxes: |
| rect = box["rect"] |
| llx, lly = rect.ll() |
| urx, ury = rect.ur() |
| set_item = (box["layer"].getName(), llx, lly, urx, ury) |
| if set_item not in iterm_boxes_set: |
| iterm_boxes_set.add(set_item) |
| iterm_boxes_uniq.append(box) |
| |
| return iterm_boxes_uniq |
| |
| |
| def getBiggestBoxAndIndex(boxes): |
| biggest_area = -1 |
| biggest_box = None |
| biggest_i = -1 |
| for i in range(len(boxes)): |
| box = boxes[i] |
| rect = box["rect"] |
| area = rect.area() |
| if area > biggest_area: |
| biggest_area = area |
| biggest_box = box |
| biggest_i = i |
| |
| return biggest_box, biggest_i |
| |
| |
| def rectOverlaps(rect1, rect2): |
| return not ( |
| rect1.xMax() <= rect2.xMin() |
| or rect1.xMin() >= rect2.xMax() |
| or rect1.yMax() <= rect2.yMin() |
| or rect1.yMin() >= rect2.yMax() |
| ) |
| |
| |
| def rectMerge(rect1, rect2): |
| rect = odb.Rect( |
| min(rect1.xMin(), rect2.xMin()), |
| min(rect1.yMin(), rect2.yMin()), |
| max(rect1.xMax(), rect2.xMax()), |
| max(rect1.yMax(), rect2.yMax()), |
| ) |
| |
| return rect |
| |
| |
| def getShapesOverlappingBBox(llx, lly, urx, ury, layers=[], ext_orient="R0"): |
| shapes_overlapping = [] |
| rect_bbox = odb.Rect(llx, lly, urx, ury) |
| |
| for box in ALL_BOXES: |
| box_layer = box["layer"] |
| ignore_box = len(layers) != 0 |
| for layer in layers: |
| if equalLayers(layer, box_layer): |
| ignore_box = False |
| break |
| if not ignore_box: |
| rect_box = transformRect(box["rect"], ext_orient) |
| if rectOverlaps(rect_box, rect_bbox): |
| shapes_overlapping.append(box) |
| |
| return shapes_overlapping |
| |
| |
| def rectIntersection(rect1, rect2): |
| rect = odb.Rect() |
| if rectOverlaps(rect1, rect2): |
| rect.set_xlo(max(rect1.xMin(), rect2.xMin())) |
| rect.set_ylo(max(rect1.yMin(), rect2.yMin())) |
| rect.set_xhi(min(rect1.xMax(), rect2.xMax())) |
| rect.set_yhi(min(rect1.yMax(), rect2.yMax())) |
| |
| return rect |
| |
| |
| def manhattanDistance(x1, y1, x2, y2): |
| return odb.Point.manhattanDistance(odb.Point(x1, y1), odb.Point(x2, y2)) |
| |
| |
| def center(x1, y1, x2, y2): |
| return (x1 + x2) // 2, (y1 + y2) // 2 |
| |
| |
| def gridify(rect): |
| x1, y1 = rect.ll() |
| x2, y2 = rect.ur() |
| if (x2 - x1) % 2 != 0: |
| x1 += 5 # 0.005 microns ! |
| return odb.Rect(x1, y1, x2, y2) |
| |
| |
| def forward(point, orient, distance): |
| x, y = point.x(), point.y() |
| if orient == "R0": |
| point_forward = odb.Point(x, y - distance) |
| elif orient == "R90": |
| point_forward = odb.Point(x + distance, y) |
| elif orient == "R180": |
| point_forward = odb.Point(x, y + distance) |
| elif orient == "R270": |
| point_forward = odb.Point(x - distance, y) |
| else: |
| print("Unknown orientation") |
| sys.exit(1) |
| return point_forward |
| |
| |
| def transformRect(rect, orient): |
| transform = odb.dbTransform(orient) |
| rect_ll = odb.Point(*rect.ll()) |
| rect_ur = odb.Point(*rect.ur()) |
| transform.apply(rect_ll) |
| transform.apply(rect_ur) |
| rect = odb.Rect(rect_ll, rect_ur) |
| return rect |
| |
| |
| def isObstruction(box): |
| return box["type"] == "obstruction" |
| |
| |
| def isCorePin(box): |
| return box["type"] == "core_pin" |
| |
| |
| def isStripe(box): |
| return isCorePin(box) and box["stripe_flag"] |
| |
| |
| def isPadPin(box): |
| return box["type"] == "pad_pin" |
| |
| |
| def isHighestRoutingLayer(layer): |
| return layer.getRoutingLevel() == tech.getRoutingLayerCount() |
| |
| |
| def isLowestRoutingLayer(layer): |
| return layer.getRoutingLevel() == 1 |
| |
| |
| def isRoutingLayer(layer): |
| return isinstance(layer, odb.dbTechLayer) and layer.getRoutingLevel() != 0 |
| |
| |
| def getUpperRoutingLayer(layer): |
| if not isRoutingLayer(layer): |
| raise Exception("Attempting to get upper routing layer of a non-routing layer") |
| |
| if isHighestRoutingLayer(layer): |
| raise Exception( |
| "Attempting to get upper routing layer of the highest routing layer" |
| ) |
| |
| return layer.getUpperLayer().getUpperLayer() |
| |
| |
| def getLowerRoutingLayer(layer): |
| if not isRoutingLayer(layer): |
| raise Exception("Attempting to get lower routing layer of a non-routing layer") |
| |
| if isLowestRoutingLayer(layer): |
| raise Exception( |
| "Attempting to get lower routing layer of the lowest routing layer" |
| ) |
| |
| return layer.getLowerLayer().getLowerLayer() |
| |
| |
| def equalLayers(layer1, layer2): |
| return layer1.getName() == layer2.getName() |
| |
| |
| def layersBetween(layer1, layer2): |
| # Inclusive |
| layers_between = [layer1] |
| |
| if not equalLayers(layer1, layer2): |
| if layer1.getRoutingLevel() < layer2.getRoutingLevel(): |
| layer1 = getUpperRoutingLayer(layer1) |
| while not equalLayers(layer1, layer2): |
| layers_between.append(layer1) |
| layer1 = getUpperRoutingLayer(layer1) |
| else: |
| layer1 = getLowerRoutingLayer(layer1) |
| while not equalLayers(layer1, layer2): |
| layers_between.append(layer1) |
| layer1 = getLowerRoutingLayer(layer1) |
| layers_between.append(layer2) |
| |
| return layers_between |
| |
| |
| def createWireBox(rect_width, rect_height, rect_x, rect_y, layer, net, reorient="R0"): |
| rect = odb.Rect(0, 0, rect_width, rect_height) |
| rect.moveTo(rect_x, rect_y) |
| rect = transformRect(rect, reorient) |
| |
| box = {"rect": rect, "layer": layer, "net": net} |
| |
| return box |
| |
| |
| def getTechMaxSpacing(layers=tech.getLayers()): |
| max_spacing = -1 |
| for layer in layers: |
| max_spacing = max(max_spacing, layer.getSpacing()) |
| # print("Max spacing for", layers, "is", max_spacing) |
| return max_spacing |
| |
| |
| print("Top-level design name:", top_design_name) |
| |
| # create special nets |
| for special_net_name in SPECIAL_NETS: |
| net = odb.dbNet_create(block_top, special_net_name) |
| net.setSpecial() |
| net.setWildConnected() |
| |
| wire = odb.dbSWire_create(net, "ROUTED") |
| |
| SPECIAL_NETS[special_net_name]["net"] = net |
| SPECIAL_NETS[special_net_name]["wire"] = wire |
| |
| ALL_BOXES = [] |
| |
| # disconnect all iterms from anywhere else !!! (is this even needed?) |
| for inst in block_top.getInsts(): |
| iterms = inst.getITerms() |
| ALL_BOXES += getInstObs(inst) |
| for iterm in iterms: |
| master_name = inst.getMaster().getName() |
| pin_name = iterm.getMTerm().getName() |
| matched_special_net_name = None |
| for special_net_name in SPECIAL_NETS: |
| net = SPECIAL_NETS[special_net_name]["net"] |
| |
| for mapping in SPECIAL_NETS[special_net_name]["map"]: |
| core_pin = SPECIAL_NETS[special_net_name]["core_pin"] |
| pad_pin = mapping["pad_pin"] |
| pad_name_substr = mapping["pad_name_substr"] |
| |
| if pin_name == pad_pin and pad_name_substr in master_name: # pad pin |
| matched_special_net_name = special_net_name |
| print(inst.getName(), "connected to", net.getName()) |
| # iterm.connect(net) |
| # iterm.setSpecial() |
| |
| # get the pin shapes |
| iterm_boxes = getITermBoxes(iterm) |
| pad_orient = iterm.getInst().getOrient() |
| for box in iterm_boxes: |
| box["net"] = special_net_name |
| box["type"] = "pad_pin" |
| box["orient"] = pad_orient |
| ALL_BOXES += iterm_boxes |
| elif pin_name == core_pin: # macro ring |
| matched_special_net_name = special_net_name |
| print( |
| inst.getName(), |
| "will be connected to", |
| master_name, |
| "/", |
| pin_name, |
| ) |
| # iterm.connect(net) |
| # iterm.setSpecial() |
| |
| iterm_boxes = getITermBoxes(iterm) |
| for box in iterm_boxes: |
| box["net"] = special_net_name |
| box["type"] = "core_pin" |
| box["stripe_flag"] = False |
| |
| h_stripes = [] |
| v_stripes = [] |
| for i in range(4): # ASSUMPTION: 4 CORE RING-STRIPES |
| biggest_pin_box, biggest_pin_box_i = getBiggestBoxAndIndex( |
| iterm_boxes |
| ) |
| if biggest_pin_box is None: |
| continue |
| |
| del iterm_boxes[biggest_pin_box_i] |
| |
| biggest_pin_box["stripe_flag"] = True |
| |
| rect = biggest_pin_box["rect"] |
| if rect.dx() > rect.dy(): # horizontal stripe |
| biggest_pin_box["orient"] = "R90" |
| h_stripes.append(biggest_pin_box) |
| else: |
| biggest_pin_box["orient"] = "R0" |
| v_stripes.append(biggest_pin_box) |
| |
| if len(h_stripes) >= 2: |
| if h_stripes[0]["rect"].yMin() < h_stripes[1]["rect"].yMin(): |
| h_stripes[0]["side"] = "S" |
| h_stripes[1]["side"] = "N" |
| else: |
| h_stripes[0]["side"] = "N" |
| h_stripes[1]["side"] = "S" |
| elif len(h_stripes) == 1: |
| print("Warning: only one horizontal stripe found for", core_pin) |
| if ( |
| block_top.getBBox().yMax() - h_stripes[0]["rect"].yMin() |
| > block_top.getBBox().yMin() - h_stripes[0]["rect"].yMin() |
| ): |
| h_stripes[0]["side"] = "S" |
| else: |
| h_stripes[0]["side"] = "N" |
| else: |
| print("Warning: No horizontal stripes in the design!") |
| |
| if len(v_stripes) >= 2: |
| if v_stripes[0]["rect"].xMin() < v_stripes[1]["rect"].xMin(): |
| v_stripes[0]["side"] = "W" |
| v_stripes[1]["side"] = "E" |
| else: |
| v_stripes[0]["side"] = "E" |
| v_stripes[1]["side"] = "W" |
| elif len(v_stripes) == 1: |
| print("Warning: only one vertical stripe found for", core_pin) |
| if ( |
| block_top.getBBox().xMax() - v_stripes[0]["rect"].xMin() |
| > block_top.getBBox().xMin() - v_stripes[0]["rect"].xMin() |
| ): |
| v_stripes[0]["side"] = "W" |
| else: |
| v_stripes[0]["side"] = "E" |
| else: |
| print("Warning: No vertical stripes in the design!") |
| |
| ALL_BOXES += iterm_boxes + v_stripes + h_stripes |
| if ( |
| matched_special_net_name is None |
| ): # other pins are obstructions for our purposes |
| new_obstructions = getITermBoxes(iterm) |
| for obs in new_obstructions: |
| obs["type"] = "obstruction" |
| ALL_BOXES += new_obstructions |
| |
| # only types are: obstruction, core_pin, pad_pin |
| assert len({box["type"]: None for box in ALL_BOXES}) == 3 |
| |
| wire_boxes = [] |
| |
| PAD_PINS = [box for box in ALL_BOXES if isPadPin(box)] |
| CORE_STRIPES = [box for box in ALL_BOXES if isStripe(box)] |
| |
| # Go over power pad pins, find the nearest ring-stripe, |
| # check how to connect to it |
| connections_count = 0 |
| for box in PAD_PINS: |
| pad_pin_orient = box["orient"] |
| pad_pin_layer = box["layer"] |
| pad_pin_rect = box["rect"] |
| |
| ## |
| # if connections_count > 29: |
| # pprint(wire_boxes) |
| # break |
| ## |
| |
| nearest_stripe_box = None |
| for stripe in CORE_STRIPES: |
| if ( |
| box["net"] == stripe["net"] |
| and stripe["side"] == ORIENT_LOC_MAP[pad_pin_orient] |
| ): |
| nearest_stripe_box = stripe |
| |
| if nearest_stripe_box is None: |
| print( |
| "Pad pin at", |
| box["rect"].ll(), |
| box["rect"].ur(), |
| "doesn't have a facing stripe. Skipping.", |
| ) |
| continue |
| |
| stripe_rect = nearest_stripe_box["rect"] |
| |
| # TRANSFORM TO R0 ORIENTATION |
| pad_pin_orient_inv = "R" + str((360 - int(pad_pin_orient[1:])) % 360) |
| assert pad_pin_orient_inv in ORIENT_LOC_MAP |
| |
| pad_pin_rect = transformRect(pad_pin_rect, pad_pin_orient_inv) |
| stripe_rect = transformRect(stripe_rect, pad_pin_orient_inv) |
| |
| pad_pin_width = pad_pin_rect.dx() |
| |
| projection_x_min, projection_x_max = max( |
| pad_pin_rect.xMin(), stripe_rect.xMin() |
| ), min(stripe_rect.xMax(), pad_pin_rect.xMax()) |
| |
| MIN_WIDTH = 5000 |
| if projection_x_max - projection_x_min < MIN_WIDTH: |
| continue |
| |
| # account for obstructions |
| |
| from_layer = box["layer"] |
| to_layer = nearest_stripe_box["layer"] |
| |
| # prefer the highest possible connecting layer (antenna reasons) |
| connecting_layer = from_layer |
| if not isHighestRoutingLayer(to_layer): |
| connecting_layer = getUpperRoutingLayer(to_layer) |
| elif not isLowestRoutingLayer(to_layer): |
| connecting_layer = getLowerRoutingLayer(to_layer) |
| |
| print("Connecting with", connecting_layer.getName(), "to", to_layer.getName()) |
| |
| wire_rect = odb.Rect( |
| projection_x_min, pad_pin_rect.yMin(), projection_x_max, stripe_rect.yMin() |
| ) |
| |
| # adjust width |
| MAX_SPACING = getTechMaxSpacing( |
| ( |
| set(layersBetween(from_layer, connecting_layer)).union( |
| layersBetween(connecting_layer, to_layer) |
| ) |
| ) |
| ) |
| # note that the box is move away from the pad to evade interactions with |
| # nearby pads |
| overlapping_boxes = getShapesOverlappingBBox( |
| wire_rect.xMin() - MAX_SPACING, |
| wire_rect.yMin(), |
| wire_rect.xMax() + MAX_SPACING, |
| wire_rect.yMax() - MAX_SPACING, |
| ext_orient=pad_pin_orient_inv, |
| layers=list(set(layersBetween(connecting_layer, to_layer)) - set([to_layer])), |
| ) |
| |
| # find the new possible wire_rect width after subtracting the obstructions |
| skip = False |
| obs_boundaries = [] |
| for ov_box in overlapping_boxes: |
| obs_rect = transformRect(ov_box["rect"], pad_pin_orient_inv) |
| # if it is completely contained in an obstruction |
| |
| if obs_rect.xMin() <= wire_rect.xMin() < wire_rect.xMax() <= obs_rect.xMax(): |
| skip = True |
| break |
| |
| if ( |
| wire_rect.xMin() - MAX_SPACING |
| <= obs_rect.xMin() |
| <= wire_rect.xMax() + MAX_SPACING |
| ): |
| obs_boundaries.append(obs_rect.xMin()) |
| |
| if ( |
| wire_rect.xMin() - MAX_SPACING |
| <= obs_rect.xMax() |
| <= wire_rect.xMax() + MAX_SPACING |
| ): |
| obs_boundaries.append(obs_rect.xMax()) |
| |
| obs_boundaries.sort() |
| |
| if len(obs_boundaries) > 0: |
| obs_min_x = obs_boundaries[0] |
| obs_max_x = obs_boundaries[-1] |
| |
| print("Adjusting", wire_rect.ll(), wire_rect.ur()) |
| print(obs_max_x - obs_min_x) |
| print(obs_min_x, obs_max_x) |
| if ( |
| obs_min_x - (wire_rect.xMin() - MAX_SPACING) |
| > (wire_rect.xMax() + MAX_SPACING) - obs_max_x |
| ): |
| wire_rect.set_xhi(obs_min_x - MAX_SPACING) |
| else: |
| wire_rect.set_xlo(obs_max_x + MAX_SPACING) |
| print("To", wire_rect.ll(), wire_rect.ur()) |
| |
| # leave some space for routing |
| from_layer_space = 2 * from_layer.getSpacing() + from_layer.getWidth() |
| wire_width = wire_rect.dx() - from_layer_space |
| wire_x = wire_rect.xMin() + from_layer_space |
| wire_y = wire_rect.yMax() |
| |
| if wire_width < MIN_WIDTH: |
| skip = True |
| |
| if skip: |
| continue |
| |
| basic_rect = rectIntersection(wire_rect, stripe_rect) |
| |
| # 1. extend outside by half of the size of the "basic rectangle" |
| wire_y -= basic_rect.dy() // 2 |
| wire_boxes.append( |
| createWireBox( |
| wire_width, |
| basic_rect.dy() // 2, |
| wire_x, |
| wire_y, |
| from_layer, |
| box["net"], |
| reorient=pad_pin_orient, |
| ) |
| ) |
| |
| # 2. vias up till the connecting_layer on the next basic rect |
| wire_y -= basic_rect.dy() |
| prev_layer = None |
| for layer in layersBetween(from_layer, connecting_layer): |
| if prev_layer is not None: |
| via = create_custom_via( |
| prev_layer, layer, wire_width, basic_rect.dy(), reorient=pad_pin_orient |
| ) |
| |
| wire_boxes.append( |
| createWireBox( |
| wire_width, |
| basic_rect.dy(), |
| wire_x, |
| wire_y, |
| via, |
| box["net"], |
| reorient=pad_pin_orient, |
| ) |
| ) |
| |
| wire_boxes.append( |
| createWireBox( |
| wire_width, |
| basic_rect.dy(), |
| wire_x, |
| wire_y, |
| layer, |
| box["net"], |
| reorient=pad_pin_orient, |
| ) |
| ) |
| prev_layer = layer |
| |
| # 3. use the connecting layer to connect to the stripe |
| wire_height = wire_y - wire_rect.yMin() |
| wire_y = wire_rect.yMin() |
| wire_boxes.append( |
| createWireBox( |
| wire_width, |
| wire_height, |
| wire_x, |
| wire_y, |
| connecting_layer, |
| box["net"], |
| reorient=pad_pin_orient, |
| ) |
| ) |
| |
| # 4. vias down from the connecting_layer to the to_layer (stripe layer) |
| prev_layer = None |
| for layer in layersBetween(connecting_layer, to_layer): |
| if prev_layer is not None: |
| via = create_custom_via( |
| prev_layer, layer, wire_width, basic_rect.dy(), reorient=pad_pin_orient |
| ) |
| |
| wire_boxes.append( |
| createWireBox( |
| wire_width, |
| basic_rect.dy(), |
| wire_x, |
| wire_y, |
| via, |
| box["net"], |
| reorient=pad_pin_orient, |
| ) |
| ) |
| wire_boxes.append( |
| createWireBox( |
| wire_width, |
| basic_rect.dy(), |
| wire_x, |
| wire_y, |
| layer, |
| box["net"], |
| reorient=pad_pin_orient, |
| ) |
| ) |
| prev_layer = layer |
| connections_count += 1 |
| |
| # ROUTING |
| print("creating", len(wire_boxes), "wires") |
| for box in wire_boxes: |
| net_name = box["net"] |
| print(net_name, ": drawing a special wire on layer", box["layer"].getName()) |
| rect = gridify(box["rect"]) |
| if isRoutingLayer(box["layer"]): |
| odb.dbSBox_create( |
| SPECIAL_NETS[net_name]["wire"], |
| box["layer"], |
| *rect.ll(), |
| *rect.ur(), |
| "COREWIRE", |
| odb.dbSBox.UNDEFINED |
| ) |
| else: |
| odb.dbSBox_create( |
| SPECIAL_NETS[net_name]["wire"], |
| box["layer"], |
| (rect.xMin() + rect.xMax()) // 2, |
| (rect.yMin() + rect.yMax()) // 2, |
| "COREWIRE", |
| ) |
| |
| SPECIAL_NETS[net_name]["covered"] = True |
| |
| uncovered_nets = [ |
| net_name for net_name in SPECIAL_NETS if not SPECIAL_NETS[net_name]["covered"] |
| ] |
| if len(uncovered_nets) > 0: |
| print("No routes created on the following nets:") |
| print(uncovered_nets) |
| print("Make sure the pads to be connected are facing the core rings") |
| sys.exit(1) |
| |
| |
| # OUTPUT |
| odb.write_def(block_top, output_def_file_name) |
| |
| odb.write_lef(odb.dbLib_getLib(db_top, 1), output_def_file_name + ".lef") |
| |
| print("Done") |
