SXNMos.mesa
Copyright © 1984, 1987 by Xerox Corporation. All rights reserved.
Written by Shand, September 12, 1983 11:40 pm
Last Edited by: Shand, March 12, 1985 4:23:50 pm PST
Last Edited by: Spreitzer, January 14, 1985 10:35:35 pm PST
Last Edited by: Jacobi, December 18, 1984 4:49:59 pm PST
Last edited by: Christian Jacobi, April 20, 1987 8:36:46 pm PDT
Bowers, September 13, 1985 3:03:18 pm PDT
Last edited by: gbb March 26, 1986 2:52:33 pm PST
DIRECTORY
CD USING [Instance, InstanceRep, Layer, Number, Position, Rect],
CDBasics,
CDProperties USING [GetInstanceProp],
CDSimpleRules USING [MinSpace, MinWidth],
IO USING [char, int, Put, PutF, PutRope, rope],
NMos USING [lambda, nmos, dif, pol, met, ovg, cut],
NMosContacts USING [ContactPtr],
NMosTransistors USING [enhancement, strongDepletion, TransistorPtr, weakDepletion, zeroTresh],
Rope USING [Cat, ROPE],
SX USING [AddBox, AddRect, AdjustNode, AttachedNode, Circuit, CircuitNode, Constraint, ConstraintArray, ConstraintIndex, ConstraintResolution, ConversionProc, CreateLinkage, GeometricRule, IllegalConstruct, LinkageAttach, MapRec, MergeNode, nodeIndex, NodeLinkage, spaceIndex, SpinifexLayerIndex, techCIndexBase, TechHandle, violateIndex],
SXOutput USING [LinkageHousekeeper, LinkagePrintProc],
SXOutputPrivate USING [GetANaming, NameTransType, Naming, PrintNaming, PrintRoseInstantiationTransformation, UnNameTransType],
SXQuadTree USING [RectDelta],
SXTechnology USING [ESWGrow, NESGrow, PerDrawRectProc, ProcessMosTransistor, RegisterSpinifexObjectProcs, RegisterTechnologyHandle, ReportDifProc, ResolutionTable, SetUpResolution, SWNGrow, WNEGrow],
TerminalIO USING [PutRope];
SXNMos: CEDAR PROGRAM
IMPORTS CDBasics, CDProperties, CDSimpleRules, IO, NMos, Rope, SX, SXOutputPrivate, SXTechnology, TerminalIO =
BEGIN
l: CD.Number ~ NMos.lambda;
Basic rules not provided by CDSimpleRules
polOverDif: CD.Number = NMos.lambda;
These numbers are halved (sorry about any confusion this may cause)
difToPolExtSep: CD.Number = 0;
polSep: CD.Number = NMos.lambda;
difToPolSep: CD.Number = difToPolExtSep + polSep; -- not halved!
contactWidth: CD.Number = 4 * NMos.lambda;
New Regime Transistor converters (IE the Shand unified xstr representaion)
ConvertNMosTransistor: SX.ConversionProc ~ {
p: NMosTransistors.TransistorPtr = NARROW[ob.specific];
size: CD.Position ← CDBasics.SizeOfRect[ob.bbox];
xstr: REF SX.NodeLinkage;
gateNode, sourceNode, drainNode, metNode: REF SX.CircuitNode;
polExt: CD.Number ~ IF p.pullup THEN MIN[ (size.x-contactWidth)/2, p.wExt] ELSE p.wExt;
IF p.bendList = NIL THEN { -- Oh this is easy!
IF ~ p.angle THEN { -- Oh this is easy!
Add poly boxes
gateNode ← cir.AddBox[ spinifexLayer~polSpinifex, dim~[0, p.lExt, polExt, p.lExt+p.length], trans~trans, interestBloat~SXTechnology.SWNGrow[(CDSimpleRules.MinSpace[$NMosA, NMos.pol, NMos.pol]/2)]];
[] ← cir.AddBox[ spinifexLayer~polSpinifex, dim~[polExt, p.lExt, size.x-polExt, p.lExt+p.length], trans~trans, value~gateNode];
[] ← cir.AddBox[ spinifexLayer~polSpinifex, dim~[size.x-polExt, p.lExt, size.x, p.lExt+p.length], trans~trans, interestBloat~SXTechnology.NESGrow[(CDSimpleRules.MinSpace[$NMosA, NMos.pol, NMos.pol]/2)], value~gateNode];
Add rects for poly exclusion
IF p.lExt-difToPolSep > 0 THEN {
At the top
[] ← cir.AddBox[ spinifexLayer~polSpinifex, dim~[polExt, p.lExt+p.length+difToPolSep, size.x-polExt, size.y], trans~trans,
interestBloat~SXTechnology.WNEGrow[difToPolExtSep],
value~pCnstr[pExcl]];
... and the bottom
[] ← cir.AddBox[ spinifexLayer~polSpinifex, dim~[p.wExt, 0, size.x-p.wExt, p.lExt-difToPolSep], trans~trans, interestBloat~SXTechnology.ESWGrow[difToPolExtSep],
value~pCnstr[pExcl]]
};
Add rects for channel lead-in.
At the top
[] ← cir.AddBox[ spinifexLayer~polSpinifex, dim~[polExt, p.lExt+p.length, size.x-polExt, p.lExt+p.length+difToPolSep], trans~trans, value~pCnstr[pChE]];
... and the bottom
[] ← cir.AddBox[ spinifexLayer~polSpinifex, dim~[p.wExt, p.lExt-difToPolSep, size.x-p.wExt, p.lExt], trans~trans, value~pCnstr[pChE]];
Fill channel gap
[] ← cir.AddBox[ spinifexLayer~difSpinifex, dim~[p.wExt, p.lExt, size.x-p.wExt, p.lExt+p.length], trans~trans, interestBloat~[dx1~ (CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2), dy1~ 0, dx2~ (CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2), dy2~ 0], value~dCnstr[dCh]];
IF polExt < p.wExt THEN [] ← cir.AddBox[ spinifexLayer~difSpinifex, dim~[polExt, p.lExt+p.length-l, size.x-polExt, p.lExt+p.length], trans~trans, interestBloat~[dx1~ (CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2), dy1~ 0, dx2~ (CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2), dy2~ (CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2)], value~dCnstr[dCh]];
Add rects for diff width spacing and connection
sourceNode ← cir.AddBox[ spinifexLayer~difSpinifex, dim~[polExt, p.lExt+p.length, size.x-polExt, size.y], trans~trans, interestBloat~SXTechnology.WNEGrow[(CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2)]];
drainNode ← cir.AddBox[ spinifexLayer~difSpinifex, dim~[p.wExt, 0, size.x-p.wExt, p.lExt], trans~trans, interestBloat~SXTechnology.ESWGrow[(CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2)]];
IF p.pullup THEN {
metNode ← cir.AddRect [lev~NMos.met, dim~[(size.x-contactWidth)/2, size.y-6*l, (size.x+contactWidth)/2, size.y], trans~trans];
}
ELSE metNode ← NIL
}
ELSE { -- Oh no not a bent transistor yetcchh!
sourceDrainList: LIST OF REF SX.CircuitNode;
sourceDrainCount: INTEGER;
sourceHint: REF SX.CircuitNode ← NIL;
NoteSourceHint: SXTechnology.ReportDifProc ~ {
sourceHint ← difNode
};
[gateNode, sourceDrainList, sourceDrainCount] ← SXTechnology.ProcessMosTransistor[ob, trans, cir, difSpinifex, polSpinifex, dCnstr[dCh], pCnstr[pChE], (CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2), difToPolSep, MapMaterial, cir, NoteSourceHint];
IF sourceDrainCount = 2 THEN {
sourceNode ← sourceDrainList.first;
drainNode ← sourceDrainList.rest.first;
IF p.pullup THEN {
SELECT sourceHint FROM
sourceNode => NULL;
drainNode => {
drainNode ← sourceNode;
sourceNode ← sourceHint
};
ENDCASE => ERROR -- Including case when sourceHint = NIL
}
}
ELSE {
TerminalIO.PutRope[ Rope.Cat["Xstr with ", (SELECT sourceDrainCount FROM 0 => "no", 1 => "only 1", ENDCASE => "more than 2"), " sources/drains not included in circuit description\n"]];
RETURN
}
};
Add Linkages for transistor.
xstr ← cir.CreateLinkage[NEW[CD.InstanceRep←[ob: ob]], p.length, p.width];
We're a lot smarter than this program, so let's adjust the area and perim values its got.
SX.AdjustNode[ gateNode, polSpinifex, size.y*p.length, (size.y+p.length)*2, absolute];
SX.AdjustNode[ sourceNode, difSpinifex, (size.y-(p.lExt+p.length))*(size.x-2*polExt), (size.y-(p.lExt+p.length))*2 + size.x-2*polExt, absolute]; -- Ignore perim leading into channel.
SX.AdjustNode[ drainNode, difSpinifex, p.lExt*p.width, 2*p.lExt + p.width, absolute]; -- Ignore perim leading into channel.
IF p.pullup THEN {
cir.MergeNode[ gateNode, sourceNode]; sourceNode ← gateNode;
cir.MergeNode[ gateNode, metNode]; metNode ← gateNode;
};
SX.LinkageAttach[link~xstr, attachType~$Gate, node~gateNode];
SX.LinkageAttach[link~xstr, attachType~$Source, node~sourceNode];
SX.LinkageAttach[link~xstr, attachType~$Drain, node~drainNode];
};
Material mapping
MapMaterial: SXTechnology.PerDrawRectProc ~ {
[r: CD.Rect, l: CD.Layer, data: REF ANY] RETURNS [TransistorMaterial]
cir: REF SX.Circuit ~ NARROW [data, REF SX.Circuit];
SELECT l FROM
NMos.dif => RETURN [diffusion];
NMos.pol => RETURN [polysilicon];
NMos.met => {
[] ← cir.AddRect[ lev~ NMos.met, dim~ r];
RETURN [nothing];
};
NMos.cut => {
RETURN [postProcess];
};
ENDCASE => RETURN [nothing];
};
Contact converters
ConvertNMosContactDifAndPol: SX.ConversionProc ~ {
box: CD.Rect ← ob.bbox;
node: REF SX.CircuitNode;
Attach two rectangles to the same node.
node ← cir.AddRect[ lev~NMos.met, dim~box, trans~trans];
[] ← cir.AddRect[ lev~ob.layer, dim~box, trans~trans, value~node];
IF ob.layer = NMos.dif THEN
[] ← cir.AddBox[ spinifexLayer~polSpinifex, dim~box, trans~trans, value~pCnstr[pExCon]];
};
ConvertNMosMmContact: SX.ConversionProc ~ {
[appl: CD.Instance, trans: CD.Transformation, cir: REF SX.Circuit]
s: CD.Position = CDBasics.SizeOfRect[ob.bbox];
[] ← cir.AddBox [
spinifexLayer: metSpinifex,
dim: [l/2, l/2, s.x-l/2, s.y-l/2], -- cut bloated by 1/2 lambda
trans: trans,
value: mCnstr[mCutEx]];
[] ← cir.AddBox [
spinifexLayer: metSpinifex,
dim: [l, l, s.x-l, s.y-l], -- cut unbloated
trans: trans,
value: mCnstr[mCut]];};
ConvertNMosButtingContact: SX.ConversionProc ~ {
[appl: CD.Instance, pos: CD.Position, orient: CD.Orientation, cir: REF SX.Circuit]
rimWidth: CD.Number ~ l;
box: CD.Rect ← ob.bbox;
size: CD.Position ← CDBasics.SizeOfRect[box];
polSize: CD.Number ~ size.y/2;
node: REF SX.CircuitNode;
node ← cir.AddRect[ lev~NMos.met, dim~box, trans~trans];
[] ← cir.AddRect[ lev~NMos.pol, dim~[0,0, size.x, polSize], trans~trans, value~node];
Add rect for poly exclusion
[] ← cir.AddBox[ spinifexLayer~polSpinifex,
dim~[-rimWidth,polSize, size.x+rimWidth, polSize+difToPolSep], trans~trans, value~pCnstr[pChE]];
[] ← cir.AddBox [spinifexLayer~polSpinifex,
dim~[-rimWidth,polSize-rimWidth, 0, polSize], trans~trans, value~pCnstr[pDxorP]];
[] ← cir.AddBox [spinifexLayer~polSpinifex,
dim~[size.x,polSize-rimWidth, size.x+rimWidth, polSize], trans~trans, value~pCnstr[pDxorP]];
[] ← cir.AddBox [spinifexLayer~polSpinifex,
dim~[0,polSize+difToPolSep, size.x, size.y], trans~trans,
interestBloat~SXTechnology.WNEGrow[difToPolExtSep],
value~pCnstr[pExCon]];
Add rect for diff width spacing and connection
[] ← cir.AddBox [spinifexLayer~difSpinifex,
dim~[0,polSize, size.x, size.y], trans~trans,
interestBloat~[(CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2), (CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2), (CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2), (CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2)], value~node];
};
ConvertNMosBuriedContact: SX.ConversionProc ~ {
[appl: CD.Instance, pos: CD.Position, orient: CD.Orientation, cir: REF SX.Circuit]
Buried contacts come in three flavours, Pol-Surround, Dif-Surround and Crossing. The buried contacts in chipndale are parameterized by lExt and wExt, their interpretation is as follows: Diff always extends 1l to the left, material above/below and to the right is determined by lExt and wExt respectively. 2l is the pivotal value, below 2l the material is Pol, at 2l or above the material is Diff. (Note: some combinations give Diff on all four sides, it is assumed that such combinations will not be created.)
s: CD.Position ~ CDBasics.SizeOfRect[ob.bbox];
cp: NMosContacts.ContactPtr ~ NARROW[ob.specific];
node: REF SX.CircuitNode ~ cir.AddRect[ lev~NMos.pol, dim~[2*l, cp.lExt, s.x-cp.wExt, s.y-cp.lExt], trans~trans];
Cut
[] ← cir.AddBox [
spinifexLayer: metSpinifex,
dim: [l/2, l/2, s.x-l/2, s.y-l/2], -- actual dimensions of cut
trans: trans,
value: mCnstr[mBCCut]];
[] ← cir.AddBox [
spinifexLayer: metSpinifex,
dim: [-l/2, -l/2, s.x+l/2, s.y+l/2], -- cut bloated by 1 lambda
trans: trans,
value: mCnstr[mBCEx]];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [l/2, l/2, s.x-l/2, s.y-l/2], -- actual dimensions of cut
trans: trans,
value: pCnstr[pBCCut]];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [0, 0, s.x, s.y], --cut Bloated by 1/2 lambda (poly is bloated by lambda)
trans: trans,
value: pCnstr[pBCExcl]];
SELECT TRUE FROM
cp.lExt < 2*l AND cp.wExt < 2*l => {
Polysilicon Surround
wex: CD.Number ~ MAX[cp.wExt+l, 2*l];
lex: CD.Number ~ MAX[cp.lExt+l, 2*l];
bcExclConstraint: SX.Constraint ← pCnstr[pBCExcl]^;
bcExclConstraint.specificCorrespondingNode ← node;
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [-l/2, -l/2, 0, s.y+l/2], -- buried contact poly exclude (left side)
trans: trans,
value: NEW[Constraint ← bcExclConstraint]];
[] ← cir.AddRect [
lev: ob.layer,
dim: [l, lex, 2*l, s.y-lex],
trans: trans,
value: node];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [2*l-difToPolSep, lex, 2*l, s.y-lex],
trans: trans,
value: pCnstr[pChE]];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [2*l, lex, s.x-wex, s.y-lex],
trans: trans,
value: pCnstr[pDandP]];
[] ← cir.AddBox [
spinifexLayer: difSpinifex,
dim: [2*l, lex, s.x-wex, s.y-lex],
trans: trans,
value: node];
};
cp.lExt < 2*l AND cp.wExt >= 2*l => {
Polysilicon/Diffusion Crossing.
lex: CD.Number ~ MAX[cp.lExt+l, 2*l];
bcExclConstraint: SX.Constraint ← pCnstr[pBCExcl]^;
bcExclConstraint.specificCorrespondingNode ← node;
Cut
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [s.x, -l/2, s.x+l/2, s.y+l/2], -- buried contact poly exclude (right side)
trans: trans,
value: NEW[Constraint ← bcExclConstraint]];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [-l/2, -l/2, 0, s.y+l/2], -- buried contact poly exclude (left side)
trans: trans,
value: NEW[Constraint ← bcExclConstraint]];
[] ← cir.AddBox [
spinifexLayer: difSpinifex,
dim: [2*l, lex, s.x-cp.wExt, s.y-lex],
trans: trans,
value: node];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [2*l, lex, s.x-cp.wExt, s.y-lex],
trans: trans,
value: pCnstr[pDandP]];
Left side.
[] ← cir.AddRect [lev: ob.layer,
dim: [l, lex, 2*l, s.y-lex],
trans: trans,
value: node];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [2*l-difToPolSep, lex, 2*l, s.y-lex],
trans: trans,
value: pCnstr[pChE]];
Right side.
[] ← cir.AddRect [
lev: ob.layer,
dim: [s.x-cp.wExt, lex, s.x-(cp.wExt-l), s.y-lex],
trans: trans,
value: node];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [s.x-cp.wExt, lex, s.x-(cp.wExt-difToPolSep), s.y-lex],
trans: trans,
value: pCnstr[pChE]];
};
cp.lExt >= 2*l AND cp.wExt < 2*l => {
Diffusion Surround
wex: CD.Number ~ MAX[cp.wExt+l, 2*l];
lex: CD.Number ~ cp.lExt-l;
bcExclConstraint: SX.Constraint ← pCnstr[pBCExcl]^;
bcExclConstraint.specificCorrespondingNode ← node;
Cut
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [-l/2, -l/2, l/2, s.y+l/2], -- buried contact poly exclude (left side)
trans: trans,
value: NEW[Constraint ← bcExclConstraint]];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [l/2, s.y, s.x+l/2, s.y+l/2], -- buried contact poly exclude (top side)
trans: trans,
value: NEW[Constraint ← bcExclConstraint]];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [l/2, -l/2, s.x, 0], -- buried contact poly exclude (bottom side)
trans: trans,
value: NEW[Constraint ← bcExclConstraint]];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [2*l, cp.lExt, s.x-wex, s.y-cp.lExt],
trans: trans,
value: pCnstr[pDandP]];
Left side.
[] ← cir.AddRect [
lev: ob.layer,
dim: [l, lex, s.x-wex, s.y-lex],
trans: trans,
value: node];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [2*l-difToPolSep, lex, 2*l, s.y-lex],
trans: trans,
value: pCnstr[pChE]];
Top.
[] ← cir.AddRect [
lev: ob.layer,
dim: [2*l, s.y-cp.lExt, s.x-wex, s.y-lex],
trans: trans,
value: node];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [2*l, s.y-cp.lExt, s.x-wex, s.y-(cp.lExt-difToPolSep)],
trans: trans,
value: pCnstr[pChE]];
Bottom.
[] ← cir.AddRect [
lev: ob.layer,
dim: [2*l, lex, s.x-wex, cp.lExt],
trans: trans,
value: node];
[] ← cir.AddBox [
spinifexLayer: polSpinifex,
dim: [2*l, cp.lExt-difToPolSep, s.x-wex, cp.lExt],
trans: trans,
value: pCnstr[pChE]];
};
cp.lExt >= 2*l AND cp.wExt >= 2*l => {
Diffusion Surround ! on all sides ???
ERROR SX.IllegalConstruct [ob.class.interestRect[ob], "Polysilicon surrounded by diffusion or all sides in Buried Contact"];
};
ENDCASE => ERROR;
};
Thyme and Rosemary
RoseNMosTransistor: SXOutput.LinkagePrintProc ~ {
[desWDir: ROPE, dfStream, cellStream: IO.STREAM, linkage: REF NodeLinkage, name: Rope.ROPE, PrintNode: NodePrintProc]
PrintAttachment: PROCEDURE [key: ATOM, portName: Rope.ROPE] ~ {
cellStream.Put[ IO.rope[" (\""], IO.rope[portName], IO.rope["\" "]];
FOR attachments: LIST OF REF SX.AttachedNode ← linkage.nodes, attachments.rest WHILE attachments # NIL DO
IF attachments.first.attachmentType = key THEN {
PrintNode[cellStream, attachments.first.node];
cellStream.PutRope[")"];
RETURN
}
ENDLOOP;
cellStream.PutRope[ "\"?\")"];
};
p: NMosTransistors.TransistorPtr ~ NARROW [linkage.source.ob.specific];
naming: SXOutputPrivate.Naming ← SXOutputPrivate.GetANaming [linkage.source];
cellStream.PutRope ["(CI "];
SXOutputPrivate.PrintNaming [
cellStream,
naming,
Rope.Cat[" \"", SXOutputPrivate.NameTransType [
desWDir: desWDir,
obj: linkage.source.ob,
dfStream: dfStream,
type: $n,
mode: IF p.pullup THEN $D ELSE SELECT p.implant FROM
NMosTransistors.enhancement => $E,
NMosTransistors.strongDepletion => $D,
NMosTransistors.zeroTresh => $Z,
NMosTransistors.weakDepletion => $W,
ENDCASE => ERROR,
length: p.length,
width: p.width], "\""]];
SXOutputPrivate.PrintRoseInstantiationTransformation [cellStream, linkage.source];
cellStream.PutRope [" (CIC"];
PrintAttachment [$Gate, "gate"];
PrintAttachment [$Source, "in"];
PrintAttachment [$Drain, "out"];
cellStream.PutRope ["))"]
};
ThymeNMosTransistor: SXOutput.LinkagePrintProc ~ {
[desWDir: ROPE, dfStream, cellStream: IO.STREAM, linkage: REF NodeLinkage, PrintNode: NodePrintProc]
PrintAttachment: PROCEDURE [ key: ATOM] ~ {
FOR attachments: LIST OF REF SX.AttachedNode ← linkage.nodes, attachments.rest WHILE attachments # NIL DO
IF attachments.first.attachmentType = key THEN {
PrintNode [cellStream, attachments.first.node];
RETURN
}
ENDLOOP;
cellStream.Put[IO.char['?]];
};
p: NMosTransistors.TransistorPtr ~ NARROW [linkage.source.ob.specific];
defaultL: INTEGER ~ 2*l;
propertyValue: REF;
cellStream.Put [IO.rope[name], IO.rope[": "]];
cellStream.PutRope [IF ~p.pullup THEN
SELECT p.implant FROM
NMosTransistors.enhancement => "ETran[",
NMosTransistors.strongDepletion => "DTran[",
NMosTransistors.zeroTresh => "ZTran[",
NMosTransistors.weakDepletion => "WTran",
ENDCASE => ERROR
ELSE
"DTran ["
];
PrintAttachment [$Gate];  cellStream.Put [IO.char[',]];
PrintAttachment [$Source]; cellStream.Put [IO.char[',]];
PrintAttachment [$Drain]; cellStream.Put [IO.char['|]];
cellStream.PutF [" W←N*%g", IO.int[p.width/l]];
IF p.length # defaultL THEN cellStream.PutF [", L←%g", IO.int[p.length/l]];
The following is a quick hack to allow John Ousterhout to test Crystal. In a later stage, SX.AttachedNode shall receive an additional field for this info. At the moment it is not clear yet, how the user interface should be like.
propertyValue ← CDProperties.GetInstanceProp [from: linkage.source, prop: $Crystal];
WITH propertyValue SELECT FROM
crystalHack: Rope.ROPE => IO.Put [stream: cellStream, v1: IO.rope["; "], v2: IO.rope[crystalHack]];
ENDCASE => IF propertyValue # NIL THEN TerminalIO.PutRope [" $Crystal property must be a rope. /n"];
cellStream.PutRope ["];"]
};
Module Initialization
Global constants and variables.
nMosHandle: REF SX.TechHandle;
difSpinifex: SX.SpinifexLayerIndex ~ SX.SpinifexLayerIndex.FIRST;
polSpinifex: SX.SpinifexLayerIndex ~ difSpinifex.SUCC;
metSpinifex: SX.SpinifexLayerIndex ~ polSpinifex.SUCC;
Constraint: TYPE ~ SX.Constraint;
Diffusion layer
dCnstr: REF SX.ConstraintArray ← NEW[SX.ConstraintArray]; -- Diffusion constraints
dCh: SX.ConstraintIndex ~ SX.techCIndexBase; -- Diffusion channel
Poly layer
pCnstr: REF SX.ConstraintArray ← NEW[SX.ConstraintArray]; -- Poly constraints
pExcl: SX.ConstraintIndex ~ SX.techCIndexBase; -- Poly not allowed here.
pExCon: SX.ConstraintIndex ~ pExcl.SUCC; -- Poly not allowed here because of Contact to n-Diffusion.
pDPErr: SX.ConstraintIndex ~ pExCon.SUCC; -- Poly and Diffusion found together here.
pChE: SX.ConstraintIndex ~ pDPErr.SUCC; -- Close to Xstr Gate, (Channel Edge).
pDxorP: SX.ConstraintIndex ~ pChE.SUCC; -- Diffusion XOR Poly allowed here.
pDandP: SX.ConstraintIndex ~ pDxorP.SUCC; -- Diffusion AND Poly may appear together here.
pBCExcl: SX.ConstraintIndex = pDandP.SUCC; -- Buried Contact Cut Exclusion
pBCErr: SX.ConstraintIndex = pBCExcl.SUCC; -- Buried Contact Cut Separation violation
pBCCut: SX.ConstraintIndex = pBCErr.SUCC; -- Buried Contact Cut
mCnstr: REF SX.ConstraintArray ← NEW[SX.ConstraintArray]; -- metal constraints
mBCEx: SX.ConstraintIndex = SX.techCIndexBase; -- Buried Contact Cut Bloated
mBCErr: SX.ConstraintIndex = mBCEx.SUCC; -- Buried Contact Cut Separation violation
mBCCut: SX.ConstraintIndex = mBCErr.SUCC; -- Buried Contact Cut Unbloated
mCutEx: SX.ConstraintIndex = mBCCut.SUCC; -- Metal Contact Cut Bloated
mCut: SX.ConstraintIndex = mCutEx.SUCC; -- Metal Contact Cut Unbloated
mBCExM: SX.ConstraintIndex = mCut.SUCC; -- Buried Contact Cut Bloated over metal
mBCErrM: SX.ConstraintIndex = mBCExM.SUCC; -- Buried Contact Cut Separation violation over metal
mBCCutM: SX.ConstraintIndex = mBCErrM.SUCC; -- Buried Contact Cut Unbloated over metal
mCutExM: SX.ConstraintIndex = mBCCutM.SUCC; -- Metal Contact Cut Bloated over metal
mCutM: SX.ConstraintIndex = mCutExM.SUCC; -- Metal Contact Cut Unbloated over metal
Init: PROCEDURE ~ {
GeometricRule: TYPE ~ SX.GeometricRule;
difSpacingRule, difWidthRule: REF GeometricRule;
polSpacingRule, polWidthRule, polDifSepRuleA, polDifSepRuleB, polOverDifRule, polBuriedSpacingRuleA, polBuriedSpacingRuleB: REF GeometricRule;
metSpacingRule, metWidthRule, bcCutSpacingRule, bcMetalCutSpacingRuleA, bcMetalCutSpacingRuleB: REF GeometricRule;
detectOpaqueViolation: REF GeometricRule;
TriggerMap: TYPE ~ PACKED ARRAY SX.ConstraintIndex OF BOOLEANALL[FALSE];
spaceRuleTrigger: TriggerMap;
widthRuleTrigger: TriggerMap;
polOverDifTrigger1, polOverDifTrigger2, polDifSepTriggerA, polDifSepTriggerB: TriggerMap;
difSpaceTrigger1: TriggerMap;
polWidthTrigger: TriggerMap;
polBuriedSpaceTriggerA, polBuriedSpaceTriggerB, polSpaceTrigger, metSpaceTrigger, metWidthTrigger: TriggerMap;
bcSpaceTrigger, bcMetalCutSpacingTriggerA, bcMetalCutSpacingTriggerB: TriggerMap;
difResolution: REF SX.ConstraintResolution;
polyResolution: REF SX.ConstraintResolution;
metResolution: REF SX.ConstraintResolution;
Construction of the Layer Constraints.
dCnstr[dCh] ← NEW[ Constraint ← [ $DifChannel, dCh]];
pCnstr[pExcl] ← NEW[ Constraint ← [ $ExcludePol, pExcl]];
pCnstr[pExCon] ← NEW[ Constraint ← [ $ExcludePolByContact, pExCon]];
pCnstr[pDPErr] ← NEW[ Constraint ← [ $PolDifError, pDPErr]];
pCnstr[pChE] ← NEW[ Constraint ← [ $ChannelEdge, pChE]];
pCnstr[pDxorP]← NEW[ Constraint ← [ $PolXorDif, pDxorP]];
pCnstr[pDandP] ← NEW[ Constraint ← [ $PolAndDif, pDandP, TRUE, polSpinifex]];
pCnstr[pBCExcl] ← NEW[ Constraint ← [ $PolyBCExcl, pBCExcl, TRUE]];
pCnstr[pBCErr] ← NEW[ Constraint ← [ $PolyBCErr, pBCErr, TRUE]];
pCnstr[pBCCut] ← NEW[ Constraint ← [ $PolyBCCut, pBCCut]];
mCnstr[mBCEx] ← NEW[ Constraint ← [ $BCExclCut, mBCEx]];
mCnstr[mBCErr] ← NEW[ Constraint ← [ $BCErr, mBCErr]];
mCnstr[mBCCut] ← NEW[ Constraint ← [ $BCCut, mBCCut]];
mCnstr[mCutEx] ← NEW[ Constraint ← [ $CutExcl, mCutEx]];
mCnstr[mCut] ← NEW[ Constraint ← [ $Cut, mCut]];
mCnstr[mBCExM] ← NEW[ Constraint ← [ $BCExclCutM, mBCExM]];
mCnstr[mBCErrM] ← NEW[ Constraint ← [ $BCErrM, mBCErrM]];
mCnstr[mBCCutM] ← NEW[ Constraint ← [ $BCCutM, mBCCutM]];
mCnstr[mCutExM] ← NEW[ Constraint ← [ $CutExclM, mCutExM]];
mCnstr[mCutM] ← NEW[ Constraint ← [ $CutM, mCutM]];
{
nd: SX.ConstraintIndex ~ SX.nodeIndex;
sp: SX.ConstraintIndex ~ SX.spaceIndex;
dResTab: SXTechnology.ResolutionTable ~ [
[ sp,  nd,  dCh, ,,,,,,,,,,,,],
[ nd,  nd,  dCh, ,,,,,,,,,,,,],
[ dCh, dCh, dCh, ,,,,,,,,,,,,],
,,,,,,,,,,,,
];
pResTab: SXTechnology.ResolutionTable = [
[ sp,   nd,   pExcl,  pExCon, pDPErr, pChE,  pDxorP, pDandP, pBCExcl, pBCErr, ,,,,,],
[ nd,   nd,   pDPErr, pDPErr, pDPErr, pDPErr, nd,   pDandP, pBCErr, pBCErr, ,,,,,],
[ pExcl,  pDPErr, pExcl,  pExCon, pDPErr, pChE,  pChE,  pDandP, pExcl,  pExcl,  ,,,,,],
[ pExCon, pDPErr, pExCon, pExCon, pDPErr, pExCon, pExCon, pDandP, pExCon, pExCon, ,,,,,],
[ pDPErr, pDPErr, pDPErr, pDPErr, pDPErr, pDPErr, pDPErr, pDandP, pDPErr, pDPErr, ,,,,,],
[ pChE,  pDPErr, pChE,  pExCon, pDPErr, pChE,  pChE,  pDandP, pChE,  pChE,  ,,,,,],
[ pDxorP, nd,   pChE,  pExCon, pDPErr, pChE,  pDxorP, pDandP, pDxorP, pDxorP, ,,,,,],
[ pDandP, pDandP, pDandP, pDandP, pDandP, pDandP, pDandP, pDandP, pDandP, pDandP, ,,,,,],
[ pBCExcl, pBCErr, pExcl,  pExCon, pDPErr, pChE,  pDxorP, pDandP, pBCExcl, pBCErr, ,,,,,],
[ pBCErr, pBCErr, pExcl,  pExCon, pDPErr, pChE,  pDxorP, pDandP, pBCErr, pBCErr, ,,,,,],
,,,,,
];
mResTab: SXTechnology.ResolutionTable = [
[ sp,    nd,    mBCEx, mBCErr, mBCCut, mCutEx, mCut,  mBCExM, mBCErrM, mBCCutM, mCutExM, mCutM,,,,],
[ nd,    nd,    mBCExM, mBCErrM, mBCCutM, mCutExM, mCutM, mBCExM, mBCErrM, mBCCutM, mCutExM, mCutM,,,,],
[ mBCEx,  mBCExM,  mBCErr, mBCErr, mBCCut, mBCErr, mCut,  mBCErrM, mBCErrM, mBCCutM, mBCErrM, mCutM,,,,],
[ mBCErr,  mBCErrM,  mBCErr, mBCErr, mBCCut, mBCErr, mCut,  mBCErrM, mBCErrM, mBCCutM, mBCErrM, mCutM,,,,],
[ mBCCut,  mBCCutM,  mBCCut, mBCCut, mBCCut, mBCCut, mCut,  mBCCutM, mBCCutM, mBCCutM, mBCCutM, mCutM,,,,],
[ mCutEx,  mCutExM,  mBCErr, mBCErr, mBCCut, mCutEx, mCut,  mBCErrM, mBCErrM, mBCCutM, mCutExM, mCutM,,,,],
[ mCut,   mCutM,  mCut,  mCut,  mCut,  mCut,  mCut,  mCutM, mCutM, mCutM, mCutM, mCutM,,,,],
[ mBCExM,  mBCExM,  mBCErrM, mBCErrM, mBCCutM, mBCErrM, mCutM, mBCErrM, mBCErrM, mBCCutM, mBCErrM, mCutM,,,,],
[ mBCErrM,  mBCErrM,  mBCErrM, mBCErrM, mBCCutM, mBCErrM, mCutM, mBCErrM, mBCErrM, mBCCutM, mBCErrM, mCutM,,,,],
[ mBCCutM,  mBCCutM,  mBCCutM, mBCCutM, mBCCutM, mBCCutM, mCutM, mBCCutM, mBCCutM, mBCCutM, mBCCutM, mCutM,,,,],
[ mCutExM,  mCutExM,  mBCErrM, mBCErrM, mBCCutM, mCutExM, mCutM, mBCErrM, mBCErrM, mBCCutM, mBCExM, mCutM,,,,],
[ mCutM,  mCutM,  mCutM, mCutM, mCutM, mCutM, mCutM, mCutM, mCutM, mCutM, mCutM, mCutM,,,,],
,,,
];
difResolution ← SXTechnology.SetUpResolution[ dCnstr, dResTab];
polyResolution ← SXTechnology.SetUpResolution[ pCnstr, pResTab];
metResolution ← SXTechnology.SetUpResolution[ mCnstr, mResTab];
};
Basic nMosHandle & cdLayerMappings.
nMosHandle ← NEW[SX.TechHandle ← [numSpinifexLayers~3, layerInterestBloat~[(CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2), (CDSimpleRules.MinSpace[$NMosA, NMos.pol, NMos.pol]/2), (CDSimpleRules.MinSpace[$NMosA, NMos.met, NMos.met]/2), ,,,,]] ];
nMosHandle.illegalLayer[NMos.dif] ← FALSE;
nMosHandle.illegalLayer[NMos.pol] ← FALSE;
nMosHandle.illegalLayer[NMos.met] ← FALSE;
nMosHandle.illegalLayer[NMos.ovg] ← FALSE;
nMosHandle.cdLayerMapping[NMos.dif] ← LIST[ [difSpinifex, (CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif]/2)], [polSpinifex,difToPolExtSep,pCnstr[pExcl]]];
nMosHandle.cdLayerMapping[NMos.pol] ← LIST[ [polSpinifex,(CDSimpleRules.MinSpace[$NMosA, NMos.pol, NMos.pol]/2)]];
nMosHandle.cdLayerMapping[NMos.met] ← LIST[ [metSpinifex,(CDSimpleRules.MinSpace[$NMosA, NMos.met, NMos.met]/2)]];
Spinifex Layer Identification.
nMosHandle.spinifexLayerNames[difSpinifex].layerId ← $Diffusion;
nMosHandle.spinifexLayerNames[polSpinifex].layerId ← $Poly;
nMosHandle.spinifexLayerNames[metSpinifex].layerId ← $Metal;
Thyme stray capacitance layer names.
nMosHandle.spinifexLayerNames[difSpinifex].thymeName ← "D";
nMosHandle.spinifexLayerNames[polSpinifex].thymeName ← "P";
nMosHandle.spinifexLayerNames[metSpinifex].thymeName ← "M";
Set Constraint Resolutions for each layer into the TechHandle.
nMosHandle.constraintResolutions[difSpinifex] ← difResolution;
nMosHandle.constraintResolutions[polSpinifex] ← polyResolution;
nMosHandle.constraintResolutions[metSpinifex] ← metResolution;
Geometric rule triggers.
spaceRuleTrigger[SX.nodeIndex] ← TRUE;
widthRuleTrigger[SX.spaceIndex] ← TRUE;
Corners are defined by union of dif and gate, but checking only looks at dif
difSpaceTrigger1[SX.nodeIndex] ← TRUE;
difSpaceTrigger1[dCh] ← TRUE;
polWidthTrigger ← ALL[TRUE];
polWidthTrigger[ SX.nodeIndex] ← FALSE;
polWidthTrigger [pDandP] ← FALSE; -- newly added by gbb
polWidthTrigger[pBCErr] ← FALSE; -- added by Bowers
polDifSepTriggerA[ SX.nodeIndex] ← TRUE;
polDifSepTriggerB[ pExcl] ← TRUE;
polDifSepTriggerB[ pExCon] ← TRUE;
Purely local errors are not handled in a natural manner by the corner-based scheme, so for every corner we find in pCnstr[pDPErr] we generate an error if there is anything on any layer nearby, of course there is always something so we get our error.
polOverDifTrigger1[ pDPErr] ← TRUE;
polOverDifTrigger2 ← ALL[TRUE];
bcSpaceTrigger[mBCCut] ← TRUE;
bcMetalCutSpacingTriggerA[mCut] ← TRUE;
bcMetalCutSpacingTriggerB[mBCCut] ← TRUE;
polBuriedSpaceTriggerA[pBCErr] ← TRUE;
polBuriedSpaceTriggerA[pBCExcl] ← TRUE;
polBuriedSpaceTriggerB[SX.nodeIndex] ← TRUE;
polSpaceTrigger[SX.nodeIndex] ← TRUE;
polSpaceTrigger[pBCErr] ← TRUE;
metSpaceTrigger[SX.nodeIndex] ← TRUE;
metSpaceTrigger[mBCExM] ← TRUE;
metSpaceTrigger[mBCErrM] ← TRUE;
metSpaceTrigger[mBCCutM] ← TRUE;
metSpaceTrigger[mCutExM] ← TRUE;
metSpaceTrigger[mCutM] ← TRUE;
metWidthTrigger[SX.spaceIndex] ← TRUE;
metWidthTrigger[mBCEx] ← TRUE;
metWidthTrigger[mBCErr] ← TRUE;
metWidthTrigger[mBCCut] ← TRUE;
metWidthTrigger[mCutEx] ← TRUE;
metWidthTrigger[mCut] ← TRUE;
The geometric rules.
difSpacingRule ← NEW[ GeometricRule ← [extent~CDSimpleRules.MinSpace[$NMosA, NMos.dif, NMos.dif], message~"Diffusion spacing", okIfConnected~TRUE, trigger1~difSpaceTrigger1, trigger2~spaceRuleTrigger]];
difWidthRule ← NEW[ GeometricRule ← [extent~CDSimpleRules.MinWidth[$NMosA, NMos.dif], message~"Diffusion width", trigger1~widthRuleTrigger, trigger2~widthRuleTrigger]];
polSpacingRule ← NEW[ GeometricRule ← [extent~CDSimpleRules.MinSpace[$NMosA, NMos.pol, NMos.pol], message~"Poly spacing", okIfConnected~TRUE, trigger1~polSpaceTrigger, trigger2~polSpaceTrigger]];
polWidthRule ← NEW[ GeometricRule ← [extent~CDSimpleRules.MinWidth[$NMosA, NMos.pol], message~"Poly width", trigger1~polWidthTrigger, trigger2~polWidthTrigger]];
polDifSepRuleA ← NEW[ GeometricRule ← [extent~CDSimpleRules.MinSpace[$NMosA, NMos.pol, NMos.dif], message~"Poly/Diffusion spacing[debug:A]", trigger1~polDifSepTriggerA, trigger2~polDifSepTriggerB]];
polDifSepRuleB ← NEW[ GeometricRule ← [extent~CDSimpleRules.MinSpace[$NMosA, NMos.pol, NMos.dif], message~"Poly/Diffusion spacing[debug:B]", trigger1~polDifSepTriggerB, trigger2~polDifSepTriggerA]];
polOverDifRule ← NEW[ GeometricRule ← [extent~polOverDif, message~"Poly over Diffusion", trigger1~polOverDifTrigger1, trigger2~polOverDifTrigger2]];
metSpacingRule ← NEW[ GeometricRule ← [extent~CDSimpleRules.MinSpace[$NMosA, NMos.met, NMos.met], message~"Metal spacing", okIfConnected~TRUE, trigger1~metSpaceTrigger, trigger2~metSpaceTrigger]];
metWidthRule ← NEW[ GeometricRule ← [extent~CDSimpleRules.MinWidth[$NMosA, NMos.met], message~"Metal width", trigger1~metWidthTrigger, trigger2~metWidthTrigger]];
bcCutSpacingRule ← NEW[ GeometricRule ← [extent: 2*l, message: "Buried Contact Cut Spacing", okIfConnected: FALSE, trigger1~bcSpaceTrigger, trigger2~bcSpaceTrigger]];
bcMetalCutSpacingRuleANEW[ GeometricRule ← [extent: 3*l/2, message: "Buried Contact Cut/Metal Cut Spacing[debug: A]", okIfConnected: FALSE, trigger1~bcMetalCutSpacingTriggerA, trigger2~bcMetalCutSpacingTriggerB]];
bcMetalCutSpacingRuleBNEW[ GeometricRule ← [extent: 3*l/2, message: "Buried Contact Cut/Metal Cut Separation[debug: B]", okIfConnected: FALSE, trigger1~bcMetalCutSpacingTriggerB, trigger2~bcMetalCutSpacingTriggerA]];
polBuriedSpacingRuleA ← NEW[ GeometricRule ← [extent: l/2, message: "Buried Contact Cut/Unrelated Poly Spacing[debug:A]", okIfConnected: TRUE, trigger1~polBuriedSpaceTriggerA, trigger2~polBuriedSpaceTriggerB]];
polBuriedSpacingRuleB ← NEW[ GeometricRule ← [extent: l/2, message: "Buried Contact Cut/Unrelated Poly Spacing[debug:B]", okIfConnected: TRUE, trigger1~polBuriedSpaceTriggerB, trigger2~polBuriedSpaceTriggerA]];
detectOpaqueViolation ← NEW[ GeometricRule ← [ extent~ l, message~ "Opaque cell boundary violated", trigger1~ ALL[TRUE], trigger2~ ALL[TRUE]]];
We set violateIndex = FALSE, ALL else TRUE so that corner checks face inward, which should result in more logically pleasing error reports.
detectOpaqueViolation.trigger1[SX.violateIndex] ← FALSE;
nMosHandle.rules[ difSpinifex] ← LIST[difSpacingRule, difWidthRule, detectOpaqueViolation];
nMosHandle.rules[ polSpinifex] ← LIST[polSpacingRule, polWidthRule, polDifSepRuleA, polDifSepRuleB, polOverDifRule, polBuriedSpacingRuleA, polBuriedSpacingRuleB, detectOpaqueViolation];
nMosHandle.rules[ metSpinifex] ← LIST[metSpacingRule, metWidthRule, bcCutSpacingRule, bcMetalCutSpacingRuleA, bcMetalCutSpacingRuleB, detectOpaqueViolation];
Technology handle is attached to the ChipNDale technology.
SXTechnology.RegisterTechnologyHandle[cdTech~ NMos.nmos, technologyHandle~ nMosHandle];
Technology specific objects.
SXTechnology.RegisterSpinifexObjectProcs[ cdTech~ NMos.nmos, objectType~$NMosTransistor, conv~ConvertNMosTransistor, thyme~ThymeNMosTransistor, rose~RoseNMosTransistor, fini~SXOutputPrivate.UnNameTransType];
SXTechnology.RegisterSpinifexObjectProcs[ cdTech~ NMos.nmos, objectType~$NMosATransistor, conv~ConvertNMosTransistor, thyme~ThymeNMosTransistor, rose~RoseNMosTransistor];
SXTechnology.RegisterSpinifexObjectProcs[ cdTech~ NMos.nmos, objectType~$NMosPullUp, conv~ConvertNMosTransistor, thyme~ThymeNMosTransistor, rose~RoseNMosTransistor];
SXTechnology.RegisterSpinifexObjectProcs[ cdTech~ NMos.nmos, objectType~$NMosContactDifAndPol, conv~ConvertNMosContactDifAndPol];
SXTechnology.RegisterSpinifexObjectProcs[ cdTech~ NMos.nmos, objectType~$NMosContactBut, conv~ConvertNMosButtingContact];
SXTechnology.RegisterSpinifexObjectProcs[ cdTech~ NMos.nmos, objectType~$NMosBurContact, conv~ConvertNMosBuriedContact];
SXTechnology.RegisterSpinifexObjectProcs[ cdTech~ NMos.nmos, objectType~$NMosMmContact, conv~ConvertNMosMmContact];
};
Init[];
TerminalIO.PutRope["nMos technology parameters Loaded\n"];
END.
Edited on March 7, 1985 1:28:12 am PST, by Shand
added interaction region around dCnstr[dCh] constraints, new parameter to SXTechnology.ProcessMosTransistor to handle channel constraint interest bloating. Also changed dCnstr[dCh].withNode so that dCnstr[dCh]+Node => $Conflict.
changes to: ConvertNMosTransistor contains creation of dCnstr[dCh] constraints and call of SXTechnology.ProcessMosTransistor, Init setting of dCnstr[dCh].withNode
Edited on March 7, 1985 4:25:39 pm PST, by Shand
Transistor Output changes: n*W multiplier for McCreight, ZTrans for Bowers.
Edited on March 9, 1985 2:01:08 pm PST, by Beretta & Shand
New Constraint Representation from SX and procedures to set it up.
changes to: ConvertNMosTransistor, ConvertNMosButtingContact, ConvertNMosBuriedContact, Constraint, dCnstr, pCnstr, Init, DIRECTORY
Edited on March 10, 1985 10:25:58 pm PST, by Shand
changes to: RoseNMosTransistor
Edited on March 12, 1985 4:23:50 pm PST, by Shand
Now uses registration mechanisms of SXTechnology.
changes to: DIRECTORY, NMosSpinifex, Init, pCnstr, Init, ConvertNMosContactDifAndPol, ConvertNMosButtingContact, pCnstr, Init, Init
Edited on March 19, 1985 12:44:28 pm PST, by Beretta
Thyme output change: substituted `n' coefficient for Ed McCreight by `N'
changes to: ThymeNMosTransistor
Edited on March 27, 1985 6:37:12 pm PST, by Beretta
Corrected bug in poly constraint resolution table
changes to: Init: pResTab[3,1] ← pDPErr
Edited on April 29, 1985 8:09:08 pm PDT, by Beretta
Fixed bug that flagged a poly width rule violation at the attachments of buried contacts "Polysilicon Surround" and "Diffusion Surround"
changes to: Init added polWidthTrigger [pDandP] ← FALSE;
Edited on May 2, 1985 10:45:08 am PDT, by Beretta
Added a quick hack to the Thyme output to allow John Ousterhout to test Crystal.
changes to: ThymeNMosTransistor: If a transistor has a property $Crystal, then its rope value is placed in the parameter list, preceded by a semicolon.
Edited on May 6, 1985 11:26:55 am PDT, by Beretta
Converted to ChipNDale CD20
Edited on May 20, 1985 2:38:11 pm PDT, by Beretta,
Created new interface SXNMosBasicRules.
Edited on June 18, 1985 4:56:52 pm PDT, by Beretta
Changed transistor types from FooTrans to FooTran, as Thyme expects.
changes to: ThymeNMosTransistor
Last edited by: gbb July 18, 1985 4:47:07 pm PDT
Converted to ChipNDale 2.1.
changes to: ConvTransistor: Adapted by Christian, ConvertContact: Completely rewritten.
gbb August 13, 1985 6:15:20 pm PDT
Added creation of Core data structure.
changes to: DIRECTORY, SXNMos, MakeCoreNMOSTransistor: new; type is not correct because Core does not yet cater for NMos transistors, Init
gbb November 7, 1985 5:07:31 pm PST
Conversions for ChipNDale22
gbb November 24, 1985 4:21:44 pm PST
Removed creation of Core data structure.
changes to: DIRECTORY, SXNMos