| #!/usr/bin/env python3 |
| # -*- coding: utf-8 -*- |
| # |
| # Copyright 2019-2021 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. |
| # |
| # This code is *alternatively* available under a BSD-3-Clause license, see |
| # details in the README.md at the top level and the license text at |
| # https://github.com/google/skywater-pdk-libs-sky130_bag3_pr/blob/master/LICENSE.alternative |
| # |
| # SPDX-License-Identifier: BSD-3-Clause OR Apache 2.0 |
| |
| |
| from typing import Tuple, FrozenSet, List, Mapping, Any, Union, Optional |
| |
| from dataclasses import dataclass |
| |
| from pybag.enum import Orient2D |
| from pybag.core import BBox |
| |
| from bag.layout.tech import TechInfo |
| from bag.layout.routing.grid import TrackSpec |
| from bag.util.immutable import ImmutableSortedDict, ImmutableList, Param |
| |
| from xbase.layout.enum import MOSType, MOSPortType, MOSCutMode, MOSAbutMode, DeviceType |
| from xbase.layout.data import LayoutInfoBuilder, ViaInfo, CornerLayInfo |
| from xbase.layout.exception import ODImplantEnclosureError |
| from xbase.layout.mos.tech import MOSTech |
| from xbase.layout.mos.data import ( |
| MOSRowSpecs, MOSRowInfo, BlkExtInfo, MOSEdgeInfo, MOSLayInfo, ExtWidthInfo, LayoutInfo, |
| ExtEndLayInfo, RowExtInfo |
| ) |
| from ..util import add_base, add_base_mos, get_arr_edge_dim |
| |
| MConnInfoType = Tuple[int, int, Orient2D, int, Tuple[str, str]] |
| |
| |
| @dataclass(eq=True, frozen=True) |
| class ConnInfo: |
| w: int |
| len_min: int |
| sp_le: int |
| orient: Orient2D |
| via_w: int |
| via_h: int |
| via_sp: int |
| via_bot_enc: int |
| via_top_enc: int |
| |
| def get_via_info(self, via_type: str, xc: int, yc: int, bot_w: int, ortho: bool = True, |
| num: int = 1, nx: int = 1, ny: int = 1, spx: int = 0, spy: int = 0) -> ViaInfo: |
| vw = self.via_w |
| vh = self.via_h |
| vsp = self.via_sp |
| |
| bot_orient = self.orient |
| if ortho: |
| bot_orient = bot_orient.perpendicular() |
| |
| if bot_orient is Orient2D.x: |
| bot_encx = self.via_bot_enc |
| bot_ency = (bot_w - vh) // 2 |
| else: |
| bot_encx = (bot_w - vw) // 2 |
| bot_ency = self.via_bot_enc |
| |
| if self.orient is Orient2D.x: |
| top_encx = self.via_top_enc |
| top_ency = (self.w - vh) // 2 |
| vnx = num |
| vny = 1 |
| else: |
| top_encx = (self.w - vw) // 2 |
| top_ency = self.via_top_enc |
| vnx = 1 |
| vny = num |
| |
| enc1 = (bot_encx, bot_encx, bot_ency, bot_ency) |
| enc2 = (top_encx, top_encx, top_ency, top_ency) |
| return ViaInfo(via_type, xc, yc, self.via_w, self.via_h, enc1, enc2, |
| vnx, vny, vsp, vsp, nx, ny, spx, spy) |
| |
| |
| class MOSTechSkywater130(MOSTech): |
| ignore_vm_sp_le_layers: FrozenSet[str] = frozenset(('li1',)) |
| |
| def __init__(self, tech_info: TechInfo, lch: int, arr_options: Mapping[str, Any]) -> None: |
| MOSTech.__init__(self, tech_info, lch, arr_options) |
| |
| @property |
| def can_draw_double_gate(self) -> bool: |
| return False |
| |
| @property |
| def has_double_guard_ring(self) -> bool: |
| return True |
| |
| @property |
| def blk_h_pitch(self) -> int: |
| return self.mos_config['blk_h_pitch'] |
| |
| @property |
| def end_h_min(self) -> int: |
| # return self.mos_config['imp_h_min'] // 2 |
| end_margin: int = self.mos_config['end_margin'] |
| return -(-end_margin//self.blk_h_pitch) * self.blk_h_pitch |
| |
| @property |
| def min_sep_col(self) -> int: |
| sd_pitch = self.sd_pitch |
| od_spx: int = self.mos_config['od_spx'] |
| imp_od_encx: int = self.mos_config['imp_od_encx'] |
| imp_sp: int = self.mos_config['imp_same_sp'] |
| od_sep = max(od_spx, imp_sp + 2 * imp_od_encx) |
| ans = -(-(od_sep + sd_pitch) // sd_pitch) |
| |
| return ans # This is not enforcing even col spacing for smallest possible spacing |
| |
| @property |
| def sub_sep_col(self) -> int: |
| sd_pitch = self.sd_pitch |
| od_spx: int = self.mos_config['od_spx'] |
| imp_od_encx: int = self.mos_config['imp_od_encx'] |
| imp_sp: int = self.mos_config['imp_diff_sp'] |
| od_sep = max(od_spx, imp_sp + 2 * imp_od_encx) |
| ans = -(-(od_sep + sd_pitch) // sd_pitch) |
| |
| return ans + (ans & 1) |
| |
| @property |
| def min_sub_col(self) -> int: |
| return self.min_od_col |
| |
| @property |
| def gr_edge_col(self) -> int: |
| return self.min_od_col |
| |
| @property |
| def min_od_col(self) -> int: |
| lch = self.lch |
| sd_pitch = self.sd_pitch |
| od_po_extx = self.od_po_extx |
| |
| od_w_min: int = self.mos_config['mos_w_range'][0] |
| return -(-max(0, od_w_min - 2 * od_po_extx - lch) // sd_pitch) + 1 |
| |
| @property |
| def abut_mode(self) -> MOSAbutMode: |
| return MOSAbutMode.NONE |
| |
| @property |
| def od_po_extx(self) -> int: |
| return self.mos_config['od_po_extx'] |
| |
| @property |
| def well_w_edge(self) -> int: |
| imp_od_encx: int = self.mos_config['imp_od_encx'] |
| nwell_imp: int = self.mos_config['nwell_imp'] |
| well_w_edge = -(self.sd_pitch - self.lch) // 2 + self.od_po_extx + nwell_imp + imp_od_encx |
| return -(-well_w_edge // self.sd_pitch) * self.sd_pitch |
| |
| def get_max_col_spacing_from_tap(self, pad_prox: bool = True) -> int: |
| """Gets maximum columns from nearest well tap rule. |
| |
| Parameters |
| ---------- |
| pad_prox: Union[str, int, bool] |
| Proximity to signal pad to determine appropriate rule. Default True. |
| If True, cell is assumed close to pad diffusion. If False, cell is |
| assumed far from pad diffusion. |
| """ |
| max_dist_tap_far = self.mos_config['latchup']['max_distance_from_tap__far'] |
| max_dist_tap_near = self.mos_config['latchup']['max_distance_from_tap__near'] |
| dist = max_dist_tap_near if pad_prox else max_dist_tap_far |
| col_dist = dist // self.sd_pitch |
| return col_dist |
| |
| def get_conn_info(self, conn_layer: int, is_gate: bool) -> ConnInfo: |
| mconf = self.mos_config |
| wire_info = mconf['g_wire_info' if is_gate else 'd_wire_info'] |
| |
| idx = conn_layer - wire_info['bot_layer'] |
| w, is_horiz, v_w, v_h, v_sp, v_bot_enc, v_top_enc = wire_info['info_list'][idx] |
| orient = Orient2D(int(is_horiz ^ 1)) |
| tech_info = self.tech_info |
| lay, purp = tech_info.get_lay_purp_list(conn_layer)[0] |
| # make sure minimum length satisfies via enclosure rule |
| cur_len = 2 * v_top_enc + (v_w if is_horiz else v_h) |
| len_min = tech_info.get_next_length(lay, purp, orient, w, cur_len, even=True) |
| sp_le = tech_info.get_min_line_end_space(lay, w, purpose=purp, even=True) |
| |
| return ConnInfo(w, len_min, sp_le, orient, v_w, v_h, v_sp, v_bot_enc, v_top_enc) |
| |
| # noinspection PyMethodMayBeStatic |
| def can_short_adj_tracks(self, conn_layer: int) -> bool: |
| return False |
| |
| def get_track_specs(self, conn_layer: int, top_layer: int) -> List[TrackSpec]: |
| assert conn_layer == 0, 'currently only work for conn_layer = 0' |
| |
| grid_info = self.mos_config['grid_info'] |
| |
| return [TrackSpec(layer=lay, direction=Orient2D.y, width=vm_w, |
| space=vm_sp, offset=(num_sd * (vm_w + vm_sp)) // 2) |
| for lay, vm_w, vm_sp, num_sd in grid_info if conn_layer <= lay <= top_layer] |
| |
| def get_edge_width(self, mos_arr_width: int, blk_pitch: int) -> int: |
| # w_edge_min = self.mos_config['imp_od_encx'] + self.sd_pitch // 2 |
| # return = get_arr_edge_dim(mos_arr_width, w_edge_min, blk_pitch) |
| edge_margin: int = self.mos_config['edge_margin'] |
| imp_od_encx: int = self.mos_config['imp_od_encx'] |
| od_extx = self.od_po_extx - (self.sd_pitch - self.lch) // 2 |
| num_sd = -(-(od_extx + imp_od_encx) // self.sd_pitch) |
| return -(-edge_margin // self.sd_pitch) * self.sd_pitch + num_sd * self.sd_pitch |
| |
| def get_mos_row_info(self, conn_layer: int, specs: MOSRowSpecs, bot_mos_type: MOSType, |
| top_mos_type: MOSType, global_options: Param) -> MOSRowInfo: |
| guard_ring: bool = specs.options.get('guard_ring', False) |
| guard_ring_col: bool = specs.options.get('guard_ring_col', False) |
| |
| assert conn_layer == 0, 'currently only work for conn_layer = 0' |
| |
| blk_p = self.blk_h_pitch |
| |
| w = specs.width |
| w_sub = specs.sub_width |
| mos_type = specs.mos_type |
| threshold = specs.threshold |
| |
| mconf = self.mos_config |
| po_spy: int = mconf['po_spy'] |
| od_spy: int = mconf['od_spy'] |
| po_h_gate: int = mconf['po_h_gate'] |
| po_od_exty: int = mconf['po_od_exty'] |
| mg_imp_spy: int = mconf['mg_imp_spy'] |
| imp_h_min: int = mconf['imp_h_min'] |
| imp_od_ency: int = mconf['imp_od_ency'] |
| po_spy2 = po_spy // 2 |
| imp_h_min2 = imp_h_min // 2 |
| |
| md_info = self.get_conn_info(0, False) |
| od_vency = md_info.via_bot_enc |
| md_top_vency = md_info.via_top_enc |
| md_vency = md_info.via_top_enc |
| md_spy = md_info.sp_le |
| md_h_min = md_info.len_min |
| v0_h = md_info.via_h |
| |
| if mos_type.is_substrate: |
| mg_h = 0 |
| else: |
| mg_info = self.get_conn_info(0, True) |
| mg_h = mg_info.w |
| |
| po_yl = po_spy2 |
| po_yh_gate = po_yl + po_h_gate |
| |
| if mos_type.is_substrate: |
| od_yl = po_spy2 + po_od_exty |
| else: |
| po_yc_gate = (po_yl + po_yh_gate) // 2 |
| gmd_yh = po_yc_gate + v0_h // 2 + md_vency |
| gmd_yl = min(po_yc_gate - v0_h // 2 - md_vency, gmd_yh - md_h_min) |
| # fix mg_imp spacing |
| imp_yl = max(imp_h_min2, po_yc_gate + mg_h // 2 + mg_imp_spy) |
| od_yl = imp_yl + imp_od_ency |
| |
| dmd_yl = gmd_yh + md_spy |
| dvc_yl = dmd_yl + md_top_vency |
| od_yl = max(od_yl, dvc_yl - od_vency) |
| |
| od_yh = od_yl + w |
| po_yh = od_yh + po_od_exty |
| blk_yh = max(od_yh + imp_od_ency + imp_h_min2, po_yh + po_spy2) |
| blk_yh = -(-blk_yh // blk_p) * blk_p |
| |
| dmd_yl, dmd_yh, _ = self._get_conn_params(md_info, od_yl, od_yh) |
| |
| if guard_ring: |
| dmd_yl = min(dmd_yl, od_yl) |
| dmd_yh = max(dmd_yh, od_yh) |
| |
| if mos_type.is_substrate: |
| gmd_yl, gmd_yh = dmd_yl, dmd_yh |
| |
| # return MOSRowInfo |
| top_einfo = RowExtInfo( |
| mos_type, threshold, |
| ImmutableSortedDict(dict( |
| mos_type=mos_type, |
| margins=dict( |
| od=(blk_yh - od_yh, od_spy), |
| po=(blk_yh - po_yh, po_spy), |
| md=(blk_yh - dmd_yh, md_spy), |
| ), |
| guard_ring=guard_ring, |
| guard_ring_col=guard_ring_col, |
| )), |
| ) |
| bot_einfo = RowExtInfo( |
| mos_type, threshold, |
| ImmutableSortedDict(dict( |
| mos_type=mos_type, |
| margins=dict( |
| od=(od_yl, od_spy), |
| po=(po_yl, po_spy), |
| md=(gmd_yl, md_spy), |
| ), |
| guard_ring=guard_ring, |
| guard_ring_col=guard_ring_col, |
| )), |
| ) |
| info = dict( |
| imp_y=(od_yl - imp_od_ency, od_yh + imp_od_ency), |
| od_y=(od_yl, od_yh), |
| po_y=(po_yh_gate, po_yh), |
| po_y_gate=(po_yl, po_yh_gate), |
| ) |
| |
| if mos_type.is_substrate: |
| g_y = ds_y = ds_g_y = sub_y = (dmd_yl, dmd_yh) |
| g_m_y = (0, po_yl) |
| ds_m_y = (po_yh, blk_yh) |
| else: |
| g_y = (gmd_yl, gmd_yh) |
| g_m_y = (0, po_yl) |
| ds_y = ds_g_y = sub_y = (dmd_yl, dmd_yh) |
| ds_m_y = (po_yh, blk_yh) |
| return MOSRowInfo(self.lch, w, w_sub, mos_type, specs.threshold, blk_yh, specs.flip, |
| top_einfo, bot_einfo, ImmutableSortedDict(info), g_y, g_m_y, ds_y, |
| ds_m_y, ds_g_y, sub_y, guard_ring=guard_ring, guard_ring_col=guard_ring_col) |
| |
| def get_ext_width_info(self, bot_row_ext_info: RowExtInfo, top_row_ext_info: RowExtInfo, |
| ignore_vm_sp_le: bool = False) -> ExtWidthInfo: |
| assert not ignore_vm_sp_le, 'ignore_vm_sp_le is not supported' |
| |
| blk_p = self.blk_h_pitch |
| |
| bot_margins = bot_row_ext_info['margins'] |
| top_margins = top_row_ext_info['margins'] |
| ext_h_min = 0 |
| for key, (bot_val, sp) in bot_margins.items(): |
| top_info = top_margins.get(key, None) |
| if top_info is not None: |
| top_val = top_info[0] |
| ext_h_min = max(ext_h_min, sp - (top_val + bot_val)) |
| w_min = -(-ext_h_min // blk_p) |
| |
| return ExtWidthInfo([], w_min) |
| |
| # noinspection PyMethodMayBeStatic |
| def get_extension_regions(self, bot_info: RowExtInfo, top_info: RowExtInfo, height: int |
| ) -> Tuple[MOSCutMode, int, int]: |
| bot_gr = bot_info.info['guard_ring'] or bot_info.info['guard_ring_col'] |
| top_gr = top_info.info['guard_ring'] or top_info.info['guard_ring_col'] |
| if bot_gr and top_gr: |
| cut_mode = MOSCutMode.BOTH |
| bot_exty = 0 |
| top_exty = 0 |
| elif _get_extend_bot_implant(bot_info, top_info): |
| # split at top |
| cut_mode = MOSCutMode.TOP |
| bot_exty = height |
| top_exty = 0 |
| else: |
| # split at bottom |
| cut_mode = MOSCutMode.BOT |
| bot_exty = 0 |
| top_exty = height |
| |
| return cut_mode, bot_exty, top_exty |
| |
| def get_mos_conn_info(self, row_info: MOSRowInfo, conn_layer: int, seg: int, w: int, stack: int, |
| g_on_s: bool, options: Param) -> MOSLayInfo: |
| assert conn_layer == 0, 'currently only work for conn_layer = 0' |
| |
| sep_g = options.get('sep_g', False) |
| export_mid = options.get('export_mid', False) |
| export_mid = export_mid and stack == 2 |
| |
| sd_pitch = self.sd_pitch |
| |
| height = row_info.height |
| row_type = row_info.row_type |
| imp_y: Tuple[int, int] = row_info['imp_y'] |
| po_y_gate: Tuple[int, int] = row_info['po_y_gate'] |
| |
| # compute gate wires location |
| fg = seg * stack |
| wire_pitch = stack * sd_pitch |
| conn_pitch = 2 * wire_pitch |
| num_s = seg // 2 + 1 |
| num_d = (seg + 1) // 2 |
| s_xc = 0 |
| d_xc = wire_pitch |
| |
| # get gate wires |
| g_pitch = 2 * sd_pitch |
| if g_on_s: |
| g_xc = 0 |
| num_g = fg // 2 + 1 |
| else: |
| g_xc = sd_pitch |
| num_g = (fg + 1) // 2 |
| |
| # draw device |
| builder = LayoutInfoBuilder() |
| od_y = self._add_mos_active(builder, row_info, 0, fg, w) |
| |
| # draw gate connection |
| self._draw_g_conn(builder, sep_g, g_xc, po_y_gate, fg, g_pitch, g_on_s) |
| |
| # draw drain/source connections |
| d0_info = self.get_conn_info(0, False) |
| md_yl, md_yh, num_vc = self._get_conn_params(d0_info, od_y[0], od_y[1]) |
| md_y = (md_yl, md_yh) |
| self._draw_ds_conn(builder, d0_info, od_y, md_y, num_vc, |
| d_xc, num_d, conn_pitch) |
| self._draw_ds_conn(builder, d0_info, od_y, md_y, num_vc, |
| s_xc, num_s, conn_pitch) |
| |
| if export_mid: |
| m_xc = sd_pitch |
| num_m = fg + 1 - num_s - num_d |
| m_info = (m_xc, num_m, wire_pitch) |
| self._draw_ds_conn(builder, d0_info, od_y, md_y, num_vc, |
| m_xc, num_m, wire_pitch) |
| else: |
| m_info = None |
| |
| bbox = BBox(0, 0, fg * sd_pitch, height) |
| |
| edge_info = MOSEdgeInfo(mos_type=row_type, imp_y=imp_y, has_od=True) |
| be = BlkExtInfo(row_type, row_info.threshold, False, ImmutableList([(fg, row_type)]), |
| ImmutableSortedDict()) |
| return MOSLayInfo(builder.get_info(bbox), edge_info, edge_info, be, be, |
| g_info=(g_xc, num_g, g_pitch), d_info=(d_xc, num_d, conn_pitch), |
| s_info=(s_xc, num_s, conn_pitch), m_info=m_info, |
| shorted_ports=ImmutableList([MOSPortType.G])) |
| |
| def _draw_g_conn(self, builder: LayoutInfoBuilder, sep_g: bool, g_xc: int, |
| po_y_gate: Tuple[int, int], fg: int, conn_pitch: int, g_on_s: bool) -> None: |
| lch = self.lch |
| sd_pitch = self.sd_pitch |
| mconf = self.mos_config |
| npc_w: int = mconf['npc_w'] |
| npc_h: int = mconf['npc_h'] |
| npc_w2 = npc_w // 2 |
| npc_h2 = npc_h // 2 |
| |
| g0_info = self.get_conn_info(0, True) |
| |
| po_lp = self.tech_info.config['mos_lay_table']['PO'] |
| |
| if g_on_s: |
| g_xc = 0 |
| num_g = fg // 2 + 1 |
| po_xl_even = g_xc |
| po_xh_even = g_xc + sd_pitch // 2 + lch // 2 |
| po_xl_odd = sd_pitch + sd_pitch // 2 - lch // 2 |
| po_xh_odd = 2 * sd_pitch |
| else: |
| g_xc = sd_pitch |
| num_g = (fg + 1) // 2 |
| po_xl_even = sd_pitch // 2 - lch // 2 |
| po_xh_even = sd_pitch |
| po_xl_odd = sd_pitch |
| po_xh_odd = sd_pitch + sd_pitch // 2 + lch // 2 |
| |
| builder.add_rect_arr(po_lp, BBox(po_xl_even, po_y_gate[0], po_xh_even, po_y_gate[1]), |
| nx=(fg - (fg // 2)), spx=conn_pitch) |
| builder.add_rect_arr(po_lp, BBox(po_xl_odd, po_y_gate[0], po_xh_odd, po_y_gate[1]), |
| nx=(fg // 2), spx=conn_pitch) |
| |
| po_yc_gate = (po_y_gate[0] + po_y_gate[1]) // 2 |
| po_h_gate = sd_pitch - lch |
| builder.add_via(g0_info.get_via_info('PYL1_C', g_xc, po_yc_gate, po_h_gate, |
| ortho=False, num=1, nx=num_g, spx=conn_pitch)) |
| # poly via draws npc layer wrong |
| npc_box = BBox(g_xc - npc_w2, po_yc_gate - npc_h2, g_xc + npc_w2, po_yc_gate + npc_h2) |
| builder.add_rect_arr(('npc', 'drawing'), npc_box, nx=num_g, spx=conn_pitch) |
| |
| po_w_min = g0_info.len_min |
| if sep_g: |
| mp_xl = g_xc - po_w_min // 2 |
| builder.add_rect_arr(po_lp, BBox(mp_xl, po_y_gate[0], mp_xl + po_w_min, po_y_gate[1]), |
| nx=num_g, spx=conn_pitch) |
| else: |
| mp_dx = g0_info.via_w |
| mp_xl = g_xc - mp_dx |
| mp_xh = g_xc + (num_g - 1) * conn_pitch + mp_dx |
| builder.add_rect_arr(po_lp, BBox(mp_xl, po_y_gate[0], mp_xh, po_y_gate[1])) |
| |
| def _draw_ds_conn(self, builder: LayoutInfoBuilder, d0_info: ConnInfo, |
| od_y: Tuple[int, int], md_y: Tuple[int, int], num_vc: int, |
| xc: int, nx: int, spx: int) -> None: |
| # connect to MD |
| md_w = d0_info.w |
| vc_w = d0_info.via_w |
| vc_h = d0_info.via_h |
| vc_sp = d0_info.via_sp |
| vc_p = vc_w + vc_sp |
| vc_w2 = vc_w // 2 |
| vc_h2 = vc_h // 2 |
| md_w2 = md_w // 2 |
| md_lp = self.tech_info.config['mos_lay_table']['MD'] |
| |
| od_yc = (od_y[0] + od_y[1]) // 2 |
| vc_h_arr = num_vc * vc_p - vc_sp |
| vc_yc_bot = od_yc + (vc_h - vc_h_arr) // 2 |
| vc_box = BBox(xc - vc_w2, vc_yc_bot - vc_h2, xc + vc_w2, vc_yc_bot + vc_h2) |
| md_box = BBox(xc - md_w2, md_y[0], xc + md_w2, md_y[1]) |
| builder.add_rect_arr(('licon1', 'drawing'), vc_box, nx=nx, spx=spx, ny=num_vc, spy=vc_p) |
| builder.add_rect_arr(md_lp, md_box, nx=nx, spx=spx) |
| |
| def get_mos_abut_info(self, row_info: MOSRowInfo, edgel: MOSEdgeInfo, edger: MOSEdgeInfo |
| ) -> LayoutInfo: |
| raise ValueError('This method is not supported in this technology.') |
| |
| def get_mos_tap_info(self, row_info: MOSRowInfo, conn_layer: int, seg: int, |
| options: Param) -> MOSLayInfo: |
| assert conn_layer == 0, 'currently only work for conn_layer = 0' |
| row_type = row_info.row_type |
| |
| guard_ring: bool = options.get('guard_ring', row_info.guard_ring) |
| guard_ring_col: bool = options.get('guard_ring_col', row_info.guard_ring_col) |
| gr = guard_ring or guard_ring_col |
| if gr: |
| sub_type: MOSType = options.get('sub_type', row_type.sub_type) |
| else: |
| sub_type: MOSType = row_type.sub_type |
| |
| sd_pitch: int = self.sd_pitch |
| |
| w: int = row_info.sub_width |
| height: int = row_info.height |
| imp_y: Tuple[int, int] = row_info['imp_y'] |
| |
| # draw device |
| builder = LayoutInfoBuilder() |
| # draws diffusion and tap |
| od_y = self._add_mos_active(builder, row_info, 0, seg, w, is_sub=True, sub_type=sub_type) |
| |
| # draw drain/source connections |
| d0_info = self.get_conn_info(0, False) |
| md_yl, md_yh, num_vc = self._get_conn_params(d0_info, od_y[0], od_y[1]) |
| md_y = (md_yl, md_yh) |
| if guard_ring: |
| md_y = row_info.ds_conn_y |
| |
| # draws in vias connecting tap cell to metal 1 |
| self._draw_ds_conn(builder, d0_info, od_y, md_y, num_vc, 0, seg + 1, sd_pitch) |
| |
| bbox = BBox(0, 0, seg * sd_pitch, height) |
| edge_info = MOSEdgeInfo(mos_type=sub_type, imp_y=imp_y, has_od=True) |
| be = BlkExtInfo(row_type, row_info.threshold, gr, ImmutableList([(seg, sub_type)]), |
| ImmutableSortedDict()) |
| wire_info = (0, seg + 1, sd_pitch) |
| return MOSLayInfo(builder.get_info(bbox), edge_info, edge_info, be, be, |
| g_info=wire_info, d_info=wire_info, s_info=wire_info, |
| shorted_ports=ImmutableList()) |
| |
| def get_mos_space_info(self, row_info: MOSRowInfo, num_cols: int, left_info: MOSEdgeInfo, |
| right_info: MOSEdgeInfo) -> MOSLayInfo: |
| lch = self.lch |
| sd_pitch = self.sd_pitch |
| od_po_extx = self.od_po_extx |
| |
| imp_od_encx: int = self.mos_config['imp_od_encx'] |
| |
| row_type = row_info.row_type |
| threshold = row_info.threshold |
| imp_y: Tuple[int, int] = row_info['imp_y'] |
| |
| blk_xh = num_cols * sd_pitch |
| blk_yh = row_info.height |
| bbox = BBox(0, 0, blk_xh, blk_yh) |
| |
| # get information from edge information dictionary |
| # if MOSEdgeInfo evaluates to False, that means this space block is on the boundary. |
| if left_info: |
| typel: MOSType = left_info['mos_type'] |
| if right_info: |
| typer: MOSType = right_info['mos_type'] |
| else: |
| typer = typel |
| elif right_info: |
| typer: MOSType = right_info['mos_type'] |
| typel = typer |
| else: |
| typel = typer = row_type |
| |
| guard_ring = row_info.guard_ring or row_info.guard_ring_col |
| |
| builder = LayoutInfoBuilder() |
| |
| # find dummy OD columns |
| od_extx = od_po_extx - (sd_pitch - lch) // 2 |
| delta_implant = od_extx + imp_od_encx |
| delta_implant = -(-delta_implant // sd_pitch) * sd_pitch |
| if typel == typer: |
| # same implant on left and right |
| if guard_ring and typel.is_substrate: |
| raise ValueError('Cannot have empty spaces between guard ring edges.') |
| |
| be = BlkExtInfo(row_type, threshold, False, ImmutableList([(num_cols, typel)]), |
| ImmutableSortedDict()) |
| add_base(builder, typel, threshold, imp_y, bbox) |
| edger = edgel = MOSEdgeInfo(mos_type=typel, imp_y=imp_y, has_od=False) |
| else: |
| # find implant split coordinate |
| # split closer to the side with the following priority: |
| # 1. is a opposite tap (i.e. ntap in nmos row) |
| # 2. is a substrate tap (i.e. ptap in nmos row) |
| if typel is not row_type: |
| if delta_implant > blk_xh: |
| raise ODImplantEnclosureError('Insufficient space to satisfy ' |
| 'implant-OD horizontal enclosure.') |
| add_base(builder, typel, threshold, imp_y, BBox(0, 0, delta_implant, blk_yh)) |
| xl = delta_implant |
| fgl = delta_implant // sd_pitch |
| else: |
| xl = 0 |
| fgl = 0 |
| |
| if typer is not row_type: |
| xr = blk_xh - delta_implant |
| if xr < xl: |
| raise ODImplantEnclosureError('Insufficient space to satisfy ' |
| 'implant-OD horizontal enclosure.') |
| add_base(builder, typer, threshold, imp_y, BBox(xr, 0, blk_xh, blk_yh)) |
| fgr = delta_implant // sd_pitch |
| else: |
| xr = blk_xh |
| fgr = 0 |
| |
| if xr > xl: |
| # draw implant in middle region |
| fgm = (xr - xl) // sd_pitch |
| if typel is row_type: |
| fgl += fgm |
| add_base(builder, typel, threshold, imp_y, BBox(xl, 0, xr, blk_yh)) |
| else: |
| fgr += fgm |
| add_base(builder, typer, threshold, imp_y, BBox(xl, 0, xr, blk_yh)) |
| |
| fg_dev_list = [] |
| if fgl > 0: |
| fg_dev_list.append((fgl, typel)) |
| if fgr > 0: |
| fg_dev_list.append((fgr, typer)) |
| |
| be = BlkExtInfo(row_type, threshold, guard_ring, ImmutableList(fg_dev_list), |
| ImmutableSortedDict()) |
| edgel = MOSEdgeInfo(mos_type=typel, imp_y=imp_y, has_od=False) |
| edger = edgel.copy_with(mos_type=typer) |
| |
| wire_info = (0, 0, 0) |
| return MOSLayInfo(builder.get_info(bbox), edgel, edger, be, be, g_info=wire_info, |
| d_info=wire_info, s_info=wire_info, shorted_ports=ImmutableList()) |
| |
| def get_mos_ext_info(self, num_cols: int, blk_h: int, bot_einfo: RowExtInfo, |
| top_einfo: RowExtInfo, gr_info: Tuple[int, int]) -> ExtEndLayInfo: |
| if _get_extend_bot_implant(bot_einfo, top_einfo): |
| row_type = bot_einfo.row_type |
| threshold = bot_einfo.threshold |
| else: |
| row_type = top_einfo.row_type |
| threshold = top_einfo.threshold |
| return self._get_mos_ext_info_helper(num_cols, blk_h, row_type, threshold) |
| |
| def get_mos_ext_gr_info(self, num_cols: int, edge_cols: int, blk_h: int, bot_einfo: RowExtInfo, |
| top_einfo: RowExtInfo, sub_type: MOSType, einfo: MOSEdgeInfo |
| ) -> ExtEndLayInfo: |
| if _get_extend_bot_implant(bot_einfo, top_einfo): |
| threshold = bot_einfo.threshold |
| else: |
| threshold = top_einfo.threshold |
| return self._get_mos_ext_info_helper(num_cols, blk_h, sub_type, threshold, guard_ring=True) |
| |
| def _get_mos_ext_info_helper(self, num_cols: int, blk_h: int, row_type: MOSType, threshold: str, |
| guard_ring: bool = False) -> ExtEndLayInfo: |
| sd_pitch = self.sd_pitch |
| |
| blk_w = num_cols * sd_pitch |
| blk_rect = BBox(0, 0, blk_w, blk_h) |
| |
| builder = LayoutInfoBuilder() |
| |
| if guard_ring: |
| md_info = self.get_conn_info(0, False) |
| v_w = md_info.via_w |
| od_tap_extx = self.mos_config['od_tap_extx'] # determines the amount to extend material from licon |
| od_sd_dx = od_tap_extx + v_w // 2 |
| |
| od_lp = self.tech_info.config['mos_lay_table']['OD']['sub'] |
| md_lp = self.tech_info.config['mos_lay_table']['MD'] |
| od_xl = - od_sd_dx |
| od_xr = sd_pitch * (num_cols - 1) + od_sd_dx |
| builder.add_rect_arr(od_lp, BBox(od_xl, 0, od_xr, blk_h)) |
| builder.add_rect_arr(md_lp, BBox(od_xl, 0, od_xr, blk_h)) |
| blk_xl = od_xl - (blk_w - od_xr) |
| blk_rect = BBox(blk_xl, 0, blk_w, blk_h) |
| imp_y = (0, blk_h) |
| imp_od_encx: int = self.mos_config['imp_od_encx'] |
| add_base_mos(builder, row_type, threshold, imp_y, blk_rect, |
| imp_x=(od_xl - imp_od_encx, od_xr + imp_od_encx), is_sub=row_type.is_substrate) |
| else: |
| imp_y = (0, 0) |
| add_base(builder, row_type, threshold, imp_y, blk_rect) |
| |
| edge_info = MOSEdgeInfo(blk_h=blk_h, row_type=row_type, mos_type=row_type, threshold=threshold, imp_y=imp_y) |
| return ExtEndLayInfo(builder.get_info(blk_rect), edge_info) |
| |
| def get_ext_geometries(self, re_bot: RowExtInfo, re_top: RowExtInfo, |
| be_bot: ImmutableList[BlkExtInfo], be_top: ImmutableList[BlkExtInfo], |
| cut_mode: MOSCutMode, bot_exty: int, top_exty: int, |
| dx: int, dy: int, w_edge: int) -> LayoutInfo: |
| sd_pitch = self.sd_pitch |
| well_w_edge = self.well_w_edge |
| |
| ymid = dy + bot_exty |
| ytop = ymid + top_exty |
| |
| # draw extensions |
| builder = LayoutInfoBuilder() |
| if bot_exty > 0: |
| xcur = dx |
| for info in be_bot: |
| xcur = _add_blk_ext_info(sd_pitch, builder, info, xcur, dy, ymid) |
| w_tot = xcur + w_edge |
| _add_blk_ext_edge(sd_pitch, builder, be_bot[0], dy, ymid, w_edge, 0, well_w_edge) |
| _add_blk_ext_edge(sd_pitch, builder, be_bot[-1], dy, ymid, w_edge, w_tot, well_w_edge) |
| if top_exty > 0: |
| xcur = dx |
| for info in be_top: |
| xcur = _add_blk_ext_info(sd_pitch, builder, info, xcur, ymid, ytop) |
| w_tot = xcur + w_edge |
| _add_blk_ext_edge(sd_pitch, builder, be_top[0], ymid, ytop, w_edge, 0, well_w_edge) |
| _add_blk_ext_edge(sd_pitch, builder, be_top[-1], ymid, ytop, w_edge, w_tot, well_w_edge) |
| |
| # Note: bbox not used, just pass in some value. |
| return builder.get_info(BBox(0, 0, 0, 0)) |
| |
| def get_mos_end_info(self, blk_h: int, num_cols: int, einfo: RowExtInfo) -> ExtEndLayInfo: |
| blk_rect = BBox(0, 0, num_cols * self.sd_pitch, blk_h) |
| builder = LayoutInfoBuilder() |
| row_type = einfo.row_type |
| threshold = einfo.threshold |
| imp_y = (blk_rect.yl, blk_rect.yl) |
| add_base(builder, row_type, threshold, imp_y, blk_rect) |
| edge_info = MOSEdgeInfo(row_type=row_type, imp_y=imp_y, threshold=threshold) |
| return ExtEndLayInfo(builder.get_info(blk_rect), edge_info) |
| |
| def get_mos_row_edge_info(self, blk_w: int, rinfo: MOSRowInfo, einfo: MOSEdgeInfo |
| ) -> LayoutInfo: |
| blk_h = rinfo.height |
| mos_type: MOSType = einfo['mos_type'] |
| return self._edge_info_helper(blk_w, blk_h, mos_type, rinfo.threshold, rinfo['imp_y']) |
| |
| def get_mos_ext_edge_info(self, blk_w: int, einfo: MOSEdgeInfo) -> LayoutInfo: |
| row_type: MOSType = einfo['row_type'] |
| threshold: str = einfo['threshold'] |
| blk_h: int = einfo['blk_h'] |
| imp_y: Tuple[int, int] = einfo['imp_y'] |
| return self._edge_info_helper(blk_w, blk_h, row_type, threshold, imp_y) |
| |
| def get_mos_corner_info(self, blk_w: int, blk_h: int, einfo: MOSEdgeInfo) -> CornerLayInfo: |
| lch = self.lch |
| sd_pitch = self.sd_pitch |
| well_w_edge = self.well_w_edge |
| |
| row_type: MOSType = einfo['row_type'] |
| threshold: str = einfo['threshold'] |
| |
| well_yl = 0 |
| blk_rect = BBox(blk_w - sd_pitch, well_yl, blk_w, blk_h) |
| builder = LayoutInfoBuilder() |
| |
| well_xl = blk_w - well_w_edge |
| add_base(builder, row_type, threshold, (blk_rect.yl, blk_rect.yl), blk_rect, |
| well_x=(well_xl, blk_w)) |
| |
| x_margins = dict(well=well_xl) |
| y_margins = dict(well=well_yl) |
| edgel = ImmutableSortedDict(dict(dev_type=DeviceType.MOS, lch=lch, margins=x_margins)) |
| edgeb = ImmutableSortedDict(dict(dev_type=DeviceType.MOS, lch=lch, margins=y_margins)) |
| return CornerLayInfo(builder.get_info(blk_rect), (0, 0), edgel, edgeb) |
| |
| @staticmethod |
| def _get_conn_params(info: ConnInfo, bot_cl: int, bot_ch: int) -> Tuple[int, int, int]: |
| v_dim = info.via_h if info.orient is Orient2D.y else info.via_w |
| v_sp = info.via_sp |
| v_bot_enc = info.via_bot_enc |
| v_top_enc = info.via_top_enc |
| v_pitch = v_dim + v_sp |
| |
| v_num = (bot_ch - bot_cl - v_bot_enc * 2 + v_sp) // v_pitch |
| v_dim_arr = v_num * v_pitch - v_sp |
| top_dim = max(info.len_min, v_dim_arr + 2 * v_top_enc) |
| top_cl = (bot_cl + bot_ch - top_dim) // 2 |
| top_ch = top_cl + top_dim |
| return top_cl, top_ch, v_num |
| |
| def _get_od_sep_col(self, spx: int) -> int: |
| lch = self.lch |
| sd_pitch = self.sd_pitch |
| od_po_extx = self.od_po_extx |
| |
| return -(-(spx + lch + 2 * od_po_extx) // sd_pitch) - 1 |
| |
| def _add_mos_active(self, builder: LayoutInfoBuilder, row_info: MOSRowInfo, |
| start: int, stop: int, w: int, is_sub: bool = False, sub_type: Optional[MOSType] = None |
| ) -> Tuple[int, int]: |
| po_yl: int = row_info['po_y'][0] |
| od_yl: int = row_info['od_y'][0] |
| guard_ring: bool = row_info.guard_ring |
| guard_ring_col: bool = row_info.guard_ring_col |
| blk_yh: int = row_info.height |
| |
| sd_pitch = self.sd_pitch |
| |
| mconf = self.mos_config |
| po_h_min: int = mconf['po_h_min'] |
| po_od_exty: int = mconf['po_od_exty'] |
| |
| md_info = self.get_conn_info(0, False) |
| v_w = md_info.via_w |
| |
| # draw PO |
| od_yh = od_yl + w |
| if is_sub: |
| od_lp = self.tech_info.config['mos_lay_table']['OD']['sub'] |
| od_tap_extx = mconf['od_tap_extx'] # determines the amount to extend material from licon |
| od_sd_dx = od_tap_extx + v_w // 2 |
| else: |
| od_lp = self.tech_info.config['mos_lay_table']['OD']['active'] |
| po_y = (po_yl, max(po_yl + po_h_min, od_yh + po_od_exty)) |
| self._add_po_array(builder, po_y, start, stop) |
| od_sd_dx = sd_pitch // 2 |
| |
| # draw OD |
| od_xl = start * sd_pitch - od_sd_dx |
| od_xh = stop * sd_pitch + od_sd_dx |
| builder.add_rect_arr(od_lp, BBox(od_xl, od_yl, od_xh, od_yh)) |
| imp_y = row_info['imp_y'] |
| if is_sub: |
| md_lp = self.tech_info.config['mos_lay_table']['MD'] |
| if guard_ring and stop - start > self.gr_edge_col: |
| if sub_type.is_n_plus: |
| imp_lp = ('nsdm', 'drawing') |
| else: |
| imp_lp = ('psdm', 'drawing') |
| imp_od_encx: int = mconf['imp_od_encx'] |
| md_y = row_info.ds_conn_y |
| # OD, implant, li1 for left small rectangle |
| od_xh2 = start * sd_pitch + self.gr_edge_col * sd_pitch + od_sd_dx |
| builder.add_rect_arr(od_lp, BBox(od_xl, od_yh, od_xh2, blk_yh)) |
| builder.add_rect_arr(imp_lp, BBox(od_xl - imp_od_encx, od_yh, od_xh2 + imp_od_encx, blk_yh)) |
| builder.add_rect_arr(md_lp, BBox(od_xl, od_yh, od_xh2, blk_yh)) |
| od_xl2 = stop * sd_pitch - self.gr_edge_col * sd_pitch - od_sd_dx |
| # OD, implant, li1 for right small rectangle |
| builder.add_rect_arr(od_lp, BBox(od_xl2, od_yh, od_xh, blk_yh)) |
| builder.add_rect_arr(imp_lp, BBox(od_xl2 - imp_od_encx, od_yh, od_xh + imp_od_encx, blk_yh)) |
| builder.add_rect_arr(md_lp, BBox(od_xl2, od_yh, od_xh, blk_yh)) |
| # li1 for main OD |
| builder.add_rect_arr(md_lp, BBox(od_xl, md_y[0], od_xh, md_y[1])) |
| if guard_ring_col and stop - start == self.gr_edge_col: |
| # OD, implant, li1 for entire height |
| builder.add_rect_arr(od_lp, BBox(od_xl, 0, od_xh, blk_yh)) |
| builder.add_rect_arr(md_lp, BBox(od_xl, 0, od_xh, blk_yh)) |
| imp_y = (0, blk_yh) |
| |
| # draw base |
| imp_od_encx: int = self.mos_config['imp_od_encx'] |
| bbox = BBox(od_xl-imp_od_encx, 0, od_xh+imp_od_encx, blk_yh) |
| |
| if is_sub: |
| mos_type = sub_type |
| else: |
| mos_type = row_info.row_type |
| add_base_mos(builder, mos_type, row_info.threshold, imp_y, bbox, is_sub=is_sub) |
| |
| return od_yl, od_yh |
| |
| def _add_po_array(self, builder: LayoutInfoBuilder, po_y: Tuple[int, int], start: int, |
| stop: int) -> None: |
| po_lp = self.tech_info.config['mos_lay_table']['PO'] |
| lch = self.lch |
| sd_pitch = self.sd_pitch |
| po_x0 = (sd_pitch - lch) // 2 + sd_pitch * start |
| fg = stop - start |
| if po_y[1] > po_y[0]: |
| builder.add_rect_arr(po_lp, BBox(po_x0, po_y[0], po_x0 + lch, po_y[1]), |
| nx=fg, spx=sd_pitch) |
| |
| def _edge_info_helper(self, blk_w: int, blk_h: int, row_type: MOSType, threshold: str, |
| imp_y: Tuple[int, int]) -> LayoutInfo: |
| sd_pitch = self.sd_pitch |
| well_w_edge = self.well_w_edge |
| |
| blk_rect = BBox(blk_w - sd_pitch, 0, blk_w, blk_h) |
| builder = LayoutInfoBuilder() |
| add_base(builder, row_type, threshold, imp_y, blk_rect, well_x=(blk_w - well_w_edge, blk_w)) |
| return builder.get_info(blk_rect) |
| |
| |
| def _get_extend_bot_implant(bot_info: RowExtInfo, top_info: RowExtInfo) -> bool: |
| # prefer n implant over p implant, prefer transistor over substrate |
| bot_row_type = bot_info.row_type |
| top_row_type = top_info.row_type |
| if bot_row_type.is_pwell: |
| return True |
| if top_row_type.is_pwell: |
| return False |
| if not bot_row_type.is_substrate and top_row_type.is_substrate: |
| return True |
| if not top_row_type.is_substrate and bot_row_type.is_substrate: |
| return False |
| return bot_info.threshold < top_info.threshold |
| |
| |
| def _add_blk_ext_edge(sd_pitch: int, builder: LayoutInfoBuilder, binfo: BlkExtInfo, |
| yl: int, yh: int, blk_w: int, w_tot: int, well_w_edge: int) -> None: |
| threshold = binfo.threshold |
| |
| if w_tot == 0: |
| blk_rect = BBox(blk_w - sd_pitch, yl, blk_w, yh) |
| mos_idx = 0 |
| well_x = (blk_w - well_w_edge, blk_w) |
| else: |
| xl = w_tot - blk_w |
| blk_rect = BBox(xl, yl, xl + sd_pitch, yh) |
| mos_idx = -1 |
| well_x = (xl, xl + well_w_edge) |
| |
| add_base(builder, binfo.fg_dev[mos_idx][1], threshold, (blk_rect.yl, blk_rect.yl), |
| blk_rect, well_x=well_x) |
| |
| |
| def _add_blk_ext_info(sd_pitch: int, builder: LayoutInfoBuilder, |
| info: BlkExtInfo, xl: int, yl: int, yh: int) -> int: |
| threshold = info.threshold |
| |
| # add base |
| xcur = xl |
| for fg, dev in info.fg_dev: |
| xh = xcur + fg * sd_pitch |
| add_base(builder, dev, threshold, (yl, yl), BBox(xcur, yl, xh, yh)) |
| xcur = xh |
| |
| return xcur |
