[Indigo]<Dragon>IFUPack>IFUSrcComplete.mesa!15

IMPORTS CCDUtils, CD, CDOrient, CoreClasses, CoreCreate, CoreFrame, CoreGeometry, CoreGlue, CoreName, IFUCoreCtl, IFUCoreDrive, IFUCorePads, IFUSrc, IO, PW, PWC

EXPORTS IFUSrc =

BEGIN

ROPE: TYPE = Core.ROPE;

PadsType: TYPE = IFUCorePads.PadsType;

PadRec: TYPE = IFUCorePads.PadRec;

Side: TYPE = CoreFrame.Side;

CellType: TYPE = Core.CellType;

Ph: TYPE = CoreName.Ph;

DrGate: TYPE = IFUCoreDrive.DrGate;

GND: ROPE ← CoreName.RopeNm["GND"];

VDD: ROPE ← CoreName.RopeNm["VDD"];

Signal: SIGNAL = CODE;

MakePads: PROC[name: ROPE, side: Side, pads: LIST OF PadRec]

RETURNS[cellType: CellType] = {

PadCell: PROC[pad: PadRec] =

{pad.side ← side; cnt ← cnt-1; new.seq[cnt] ← IFUCorePads.CellProc[data: pad]};

Sig: PROC RETURNS[pad: PadRec] = {pad ← list.first; list ← list.rest};

ltOrRt: BOOL ← side=left OR side=right;

list: LIST OF PadRec;

new: CoreFrame.Frame;

cnt: INT ← 0;

list ← pads; pads ← NIL;

FOR list ← list, list.rest WHILE list # NIL DO

cnt ← cnt+1; pads ← CONS[list.first, pads] ENDLOOP; -- count and reverse list

IF cnt # (IF ltOrRt THEN 28 ELSE 32) THEN ERROR; -- left and right missing 4

cnt ← cnt+15;

IF ltOrRt

THEN {cellType ← CoreFrame.NewFrameCell[ name: name, rec: [first: bottom], size: cnt ]}

ELSE {cellType ← CoreFrame.NewFrameCell[ name: name, rec: [first: left], size: cnt ]};

new ← CoreFrame.FCT[cellType];

list ← pads;

From Top or Right

IF NOT ltOrRt THEN { PadCell[ Sig[] ]; PadCell[ Sig[] ] };

PadCell[[type: gnd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: padgnd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: padvdd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: vdd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: padvdd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: padgnd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: gnd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: padgnd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: padvdd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: vdd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: padvdd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: padgnd ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

PadCell[[type: gnd ]];

IF NOT ltOrRt THEN { PadCell[ Sig[] ]; PadCell[ Sig[] ] };

IF list#NIL OR cnt#0 THEN ERROR };

PadLt: PUBLIC PROC RETURNS[cellType: CellType] = {

pads: LIST OF PadRec ← NIL;

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

pads ← CONS[ [type: empty], pads];

pads ← CONS[ [type: empty], pads];

pads ← CONS[ [type: in, data1: "IPRejectB"], pads];

pads ← CONS[ [type: in, data1: "IPFaultingB"], pads];

pads ← CONS[ [type:gate2Out, data2:"NewFetchBAA", enWtA:"PhA"],pads];

pads ← CONS[ [type: in, data1: "ResetAB"], pads];

pads ← CONS[ [type: in, data1: "RescheduleAB"], pads];

pads ← CONS[ [type: conn, data1: "VBB"], pads];

pads ← CONS[ [type: in, data1: IFUSrc.dShIn], pads];

pads ← CONS[ [type: out, data2: IFUSrc.dShOut], pads];

pads ← CONS[ [type: conn, data1: "PhA"], pads];

pads ← CONS[ [type: conn, data1: "PhB"], pads];

pads ← CONS[ [type: conn, data1: "NotPhA"], pads];

pads ← CONS[ [type: conn, data1: "NotPhB"], pads];

pads ← CONS[ [type: conn, data1: "DShA"], pads];

pads ← CONS[ [type: conn, data1: "DShB"], pads];

pads ← CONS[ [type: conn, data1: "DShRd"], pads];

pads ← CONS[ [type: conn, data1: "DShWt"], pads];

pads ← CONS[ [type: empty], pads];

pads ← CONS[ [type: empty], pads];

cellType ← MakePads[name, left, pads];

CoreFrame.WriteFrameCache[cellType]};

cellType ← CoreFrame.NewFrameCells[ name: "IFUPadLt", rec: [first: top], cells: LIST[

CoreGlue.CellProc[t: ext, b: conn ],

cellType,

CoreGlue.CellProc[t: conn, b: ext ] ] ]};

PadRt: PUBLIC PROC RETURNS[cellType: CellType] = {

pads: LIST OF PadRec ← NIL;

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

wa: ROPE ← CoreName.RopeNm["PhA"];

wb: ROPE ← CoreName.RopeNm["NotDPRejectBA"];

wc: ROPE ← CoreName.RopeNm["Stage3ANormalBA"];

pads ← CONS[ [type: conn, data1: "IDPlaFireV"], pads];

pads ← CONS[ [type: conn, data1: "IDPlaNotPhA"], pads];

pads ← CONS[ [type: in, data1: "DPFaultB.3"], pads];

pads ← CONS[ [type: in, data1: "DPFaultB.2"], pads];

pads ← CONS[ [type: in, data1: "DPFaultB.1"], pads];

pads ← CONS[ [type: in, data1: "DPFaultB.0"], pads];

pads ← CONS[ [type: in, data1: "DPRejectB"], pads];

pads ← CONS[ [type: out, data2: "UserMode2BAA"], pads];

pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.7",enWtA:wa,enWtB:wb,enWtC:wc],pads];

pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.6",enWtA:wa,enWtB:wb,enWtC:wc],pads];

pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.5",enWtA:wa,enWtB:wb,enWtC:wc],pads];

pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.4",enWtA:wa,enWtB:wb,enWtC:wc],pads];

pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.3",enWtA:wa,enWtB:wb,enWtC:wc],pads];

pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.2",enWtA:wa,enWtB:wb,enWtC:wc],pads];

pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.1",enWtA:wa,enWtB:wb,enWtC:wc],pads];

pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.0",enWtA:wa,enWtB:wb,enWtC:wc],pads];

pads ← CONS[ [type: out, data2: "EUAluOp2ABB.3"], pads];

pads ← CONS[ [type: out, data2: "EUAluOp2ABB.2"], pads];

pads ← CONS[ [type: out, data2: "EUAluOp2ABB.1"], pads];

pads ← CONS[ [type: out, data2: "EUAluOp2ABB.0"], pads];

pads ← CONS[ [type: out, data2: "EUCondSel2ABB.3"], pads];

pads ← CONS[ [type: out, data2: "EUCondSel2ABB.2"], pads];

pads ← CONS[ [type: out, data2: "EUCondSel2ABB.1"], pads];

pads ← CONS[ [type: out, data2: "EUCondSel2ABB.0"], pads];

pads ← CONS[ [type: in, data1: "EUCondition2B"], pads];

pads ← CONS[ [type: out, data2: "EURdFromPBus3ABB"], pads];

pads ← CONS[ [type: out, data2: "EUWriteToPBus3ABB"], pads];

pads ← CONS[ [type: empty], pads];

pads ← CONS[ [type: empty], pads];

cellType ← MakePads[name, right, pads];

CoreFrame.WriteFrameCache[cellType]};

cellType ← CoreFrame.NewFrameCells[ name: "IFUPadRt", rec: [first: top], cells: LIST[

CoreGlue.CellProc[t: ext, b: conn ],

cellType,

CoreGlue.CellProc[t: conn, b: ext ] ] ]};

PadTop: PUBLIC PROC RETURNS[cellType: CellType] = {

pads: LIST OF PadRec ← NIL;

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

FOR i: INT DECREASING IN [0..32) DO

in: ROPE ← IO.PutFR["IPData.%02b", IO.int[i] ];

out: ROPE ← IO.PutFR["IPAddr.%02b", IO.int[i] ];

pads ← CONS[ [type: triOut, data1: in, data2: out, enWtA: VDD, enWtB: GND], pads];

ENDLOOP;

cellType ← MakePads[name, top, pads];

CoreFrame.WriteFrameCache[cellType]};

cellType ← CoreFrame.NewFrameCells[ name: "IFUPadTop", rec: [first: left], cells: LIST[

IFUCorePads.CellProc["TopLeft", [corLo, top] ],

cellType,

IFUCorePads.CellProc["TopRight", [corHi, top] ] ] ]};

PadBot: PUBLIC PROC RETURNS[cellType: CellType] = {

enWtA: ROPE ← "KPadsOut3BA";

enRd: ROPE ← "KPadsIn4Ac";

disRd: ROPE ← "NotKPadsIn4Ac";

pads: LIST OF PadRec ← NIL;

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

FOR i: INT DECREASING IN [0..32) DO

in: ROPE ← IO.PutFR["XBus.%02b", IO.int[i] ];

out: ROPE ← IO.PutFR["XBus.%02b", IO.int[i] ];

pads ← CONS[[type: triIO,

data1: in, data2: out,

enWtA: enWtA, enWtB: VDD,

enRd: enRd, disRd: disRd], pads];

ENDLOOP;

cellType ← MakePads[name, bottom, pads];

CoreFrame.WriteFrameCache[cellType]};

cellType ← CoreFrame.NewFrameCells[ name: "IFUPadBot", rec: [first: left], cells: LIST[

IFUCorePads.CellProc["BottomLeft", [corLo, bottom] ],

cellType,

IFUCorePads.CellProc["BottomRight", [corHi, bottom] ] ] ]};

PadExt: PROC[side1, side2: Side] RETURNS[cellType: CellType] = {

cellType ← CoreFrame.NewFrameCells[name:CoreName.ID["PadExt"],

rec:[ -- starts in top-left

first: left,

orient: CDOrient.ComposeOrient[

SELECT side1 FROM

top => CDOrient.original,

bottom => CDOrient.mirrorY,

left => CDOrient.rotate270X,

right => CDOrient.rotate270, ENDCASE => ERROR,

SELECT side2 FROM

top => CDOrient.original,

bottom => CDOrient.mirrorY,

left => CDOrient.original,

right => CDOrient.mirrorX, ENDCASE => ERROR] ],

cells: LIST[

IFUCorePads.CellProc[data: [type: ext, side: top]],

CoreGlue.CellProc[l: conn, r: ext] ] ] };

Interlock: PUBLIC PROC [sIn: ROPE, altOut: ROPE ← NIL]

RETURNS [cellType: CellType, sOut: ROPE] = {

IF altOut#NIL THEN Signal[];

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

{

desc: IFUCoreCtl.PLADescription ← NEW[IFUCoreCtl.PLADescriptionRec ←

[name: "IFUPLAInterlock", plaPhs: [BA, B, BAA, B, BA] ] ];

desc.plaType ← hot ;

desc.inSh ← sIn;

IFUCoreCtl.MakePLA1[desc];

IFUCoreDrive.AdjustDriveInPhRef[B, desc.inDrs, "

KIsRtOp1BA

FCtlIsRtOp1BA

CIsField2AB

CIsField3AB

DPCmndIsRd2BA

A1IsC2B

A1IsC3B

B1IsC2B

B1IsC3B "];

IFUCoreCtl.MakePLA2[desc];

sOut ← desc.outSh;

cellType ← IFUCoreCtl.CellProc[complete, desc];

[ ] ← CoreName.CellNm[cellType, name];

IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];

};

CoreFrame.WriteFrameCache[cellType]};

[sIn, sOut] ← IFUCoreDrive.GetDShiftIO[cellType];

cellType ← CoreFrame.NewFrameCells[ name: "InterlockFillX", rec: [first: left], cells: LIST[

CoreGlue.CellProc[l: ext, r: conn],

cellType ]]};

MainPipeControl: PUBLIC PROC [sIn: ROPE, altOut: ROPE ← NIL]

RETURNS [cellType: CellType, sOut: ROPE] = {

IF altOut#NIL THEN Signal[];

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

{

dr: IFUCoreDrive.Drive;

desc: IFUCoreCtl.PLADescription ← NEW[IFUCoreCtl.PLADescriptionRec ←

[name: "IFUPLAMainPipeControl", plaPhs: [BA, B, BAA, B, BA] ] ];

desc.plaType ← hot ;

desc.nofTermCols ← 3;

desc.fullWidthTerms ← FALSE;

IFUCoreCtl.MakePLA1[desc];

IFUCoreDrive.AdjustDriveInPhRef[A, desc.inDrs, "

RschClearAB "];

IFUCoreDrive.AdjustDriveInPhRef[B, desc.inDrs, "

ResetBA

DPRejectBA

DPFaultingBA ← DPFaultBA.0

ProtMicroCycleBA

MicroExcptJmpBubbleAB

Stage2BAbortAB

Stage1BHoldBA

CondEffect1BA.0 CondEffect1BA.1

CondEffect2BA.0 CondEffect2BA.1

EUCondition2BA

TrapsEnabled2BA ← Flag2BA.7

EStkOverflow2BA

InstStarting2BA

RescheduleBA

RschWaitingAB

Push2AB

InstFault2BA

IStkNearlyFullBA "];

IFUCoreDrive.AdjustDriveOutPh[desc.outDrs, "

Stage2ANormalBA Stage2ABubbleBA

Stage3ANormalBA Stage3AAbortBA

LoadStage1Ac

LoadStage2Ac

LoadStage3Ac

Stage1BHoldingAB NotStage1BHoldingAB

Stage2BNormalAB Stage2BAbortAB

Stage3BCPipeNormalAB Stage3BCPipeAbortAB

MicroExcptJmpNoneAB

MicroExcptJmpMicroJumpAB

MicroExcptJmpBubbleAB

MicroExcptJmpResettingAB

MicroExcptJmpTrapAB

MicroExcptJmpCJumpAB

ExceptTypeSpecialCodeAB ExceptTypeCondCodeAB ExceptTypeDpFaultAB

ExceptCodeAB.0 ExceptCodeAB.1 ExceptCodeAB.2 ExceptCodeAB.3

RschClearAB

RschWaitingAB " ];

dr ← IFUCoreDrive.FindDrive[desc.outDrs, "BcLoadStage1BA"];

dr.name ← "LoadStage";

dr.dualOut ← FALSE;

dr.gate ← negBc;

dr.in ← [pos, A];

dr.ref ← [pos, A];

dr.out ← [pos, Bc];

IFUCoreCtl.MakePLA2[desc];

sOut ← desc.outSh;

cellType ← IFUCoreCtl.CellProc[complete, desc];

[ ] ← CoreName.CellNm[cellType, name];

IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];

};

CoreFrame.WriteFrameCache[cellType]};

[sIn, sOut] ← IFUCoreDrive.GetDShiftIO[cellType];

cellType ← CoreFrame.NewFrameCells[name: "MainPipeControlFillX", rec:[first:left], cells:LIST[

CoreGlue.CellProc[l: ext, r: conn],

cellType ]]};

LtDrPadIO: PUBLIC PROC[sIn: ROPE, altOut: ROPE ← NIL]

RETURNS [cellType: CellType, sOut: ROPE] = {

IF altOut#NIL THEN Signal[];

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

{

Drive: PROC[dir: IFUCoreDrive.Dir, in, out: ROPE, inverted, dual: BOOL ← FALSE] = {

drives ← CONS[IFUCoreDrive.SpecificDrive[dir, in, out, inverted, dual], drives]};

drives: IFUCoreDrive.Drives ← NIL;

toInside: IFUCoreDrive.Dir = out;

toOutside: IFUCoreDrive.Dir = in;

Drive[toInside, "IPRejectB", "IPRejectBA"];

Drive[toInside, "IPFaultingB", "IPFaultingBA"];

Drive[toOutside, "NewFetchBA", "NewFetchBAA"];

Drive[toInside, "ResetAB", "ResetBA", FALSE, TRUE];

Drive[toInside, "RescheduleAB", "RescheduleBA"];

[drives, sOut] ← IFUCoreDrive.CapDrives[drives, sIn];

cellType ← IFUCoreDrive.DrivesToFrame[name, drives];

IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];

};

CoreFrame.WriteFrameCache[cellType]};

[sIn, sOut] ← IFUCoreDrive.GetDShiftIO[cellType];

cellType ← CoreFrame.NewFrameCells[ name: "LtDrPadIO", rec: [first: left],

cells: LIST[ CoreGlue.CellProc[l: ext, r: conn], cellType ]]};

IFULogo: PROC RETURNS [cellType: CellType] = {

design: CD.Design ← PW.OpenDesign["IFULogo"];

object: CD.Object ← PW.Get[design, "WideHorizontalLogo"];

cellType ← CoreClasses.CreateRecordCell

[CoreCreate.Seq[size:0], CoreCreate.Seq[size:0], NIL, "Logo", NIL];

PWC.SetLayoutObj[cellType, object];

PWC.SetExtractCell[object, cellType];

CoreGeometry.PutIR[PWC.extractMode.decoration, cellType, CD.InterestRect[object]];

cellType ← CoreFrame.NewFrameCells[ name: "IFULogo", rec: [first: top], cells: LIST[

CoreGlue.CellProc[],

CoreFrame.NewFrameCells[ name: NIL, rec: [first: left], cells: LIST[

CoreGlue.CellProc[],

CoreFrame.NewFrameCell[size: 0, name: "Logo", rec: [first: left, cell: cellType] ],

CoreGlue.CellProc[] ]],

CoreGlue.CellProc[] ]]};

IFULogoCell: CellType ← NIL;

IFULogo: PROC RETURNS [cellType: CellType] = {

IF IFULogoCell=NIL THEN {

design: CD.Design ← PW.OpenDesign["IFULogo"];

object: CD.Object ← PW.Get[design, "WideHorizontalLogo"];

object ← PW.Rot90[object];

IFULogoCell ← CoreLibrary.ObjCell[object, "HorizontalLogo", NIL, 0]};

cellType ← CoreFrame.NewFrameCells[ name: "IFULogo", rec: [first: top], cells: LIST[

CoreGlue.CellProc[],

CoreFrame.NewFrameCells[ name: NIL, rec: [first: left], cells: LIST[

CoreGlue.CellProc[l: ext, r: conn],

CoreFrame.NewFrameCell[size: 0, name: "IFULogoMain", rec: [first: left, cell: IFULogoCell] ],

CoreGlue.CellProc[l: conn, r: ext] ]],

CoreGlue.CellProc[] ]] };

LeftColumn: PUBLIC PROC RETURNS [cellType: CellType] = {

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

sftIn: ROPE ← IFUSrc.dShIn;

sft: ROPE ← sftIn;

sftRtn: ROPE ← IFUSrc.dShOut;

fetchIndex, stackIndex: CellType;

fetchControl, ltDrPadIO, stackControl, mainPipeControl, interlock: CellType;

chanTopLeft, chanTopRight, chanBotLeft, chanBotRight: CellType;

stackIndex ← IFUSrc.StackIndexing [];

capBot

[interlock, sft] ← IFUSrc.Interlock [sft];

[mainPipeControl, sft] ← IFUSrc.MainPipeControl [sft];

[stackControl, sft] ← IFUSrc.StackControler [sft];

[ltDrPadIO, sft] ← LtDrPadIO [sft];

[fetchControl, sft] ← IFUSrc.FetchControler [sft, IFUSrc.dShLeftOut];

capTop

fetchIndex ← IFUSrc.FetchIndexing [];

chanTopLeft ← CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[

"GND/50", "VDD/50" ]];

chanTopRight ← CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[

"GND/50", "VDD/50", IFUSrc.dShLeftOut ]];

chanBotLeft ← CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[

"GND/50", "VDD/50", "DShRd", "DShWt", "DShA", "DShB",

"PhA", "PhB", "NotPhA", "NotPhB", "VBB", sftRtn, sftIn ]];

chanBotRight ← CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[

"GND/50", "VDD/50","DShRd", "DShWt", "DShA", "DShB",

"PhA", "PhB", "NotPhA", "NotPhB", "VBB", sftRtn]];

cellType ← CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST[

fetchIndex,

CoreGlue.CellProc[l: chan, b: conn, r: chan, lCell: chanTopLeft, rCell: chanTopRight],

fetchControl,

ltDrPadIO,

stackControl,

mainPipeControl,

interlock,

CoreGlue.CellProc[l: chan, t: conn, r: chan, lCell: chanBotLeft, rCell: chanBotRight],

stackIndex ] ];

CoreFrame.WriteFrameCache[cellType]};

cellType ← CoreFrame.NewFrameCells[ name: "IFULeftColumn", rec: [first: top],

cells: LIST[ CoreGlue.CellProc[], cellType, CoreGlue.CellProc[] ]]};

DataColumn: PUBLIC PROC RETURNS [cellType: CellType] = {

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

cellType ← CoreFrame.NewFrameCells[ name: name, rec: [first: left], cells: LIST[

CoreGlue.CellProc[ l: ext, r: conn, xlate: TRUE],

CoreFrame.NewFrameCells[ name: "IFUDataColumnMain", rec: [first: top], cells: LIST[

IFUSrc.Fetch[],

IFUSrc.FetchBuf[],

IFUSrc.XaForm[],

IFUSrc.PCFormTop[],

IFUSrc.PCFormBot[],

IFUSrc.StackBuf[],

IFUSrc.LSForm[],

IFUSrc.ABForm[],

IFUSrc.ControlPipe[] ] ],

CoreGlue.CellProc[ l: conn, r: ext, xlate: TRUE] ] ];

CoreFrame.WriteFrameCache[cellType]};

cellType ← CoreFrame.NewFrameCells[ name: "DataColumn", rec: [first: top], cells: LIST[

CoreGlue.CellProc[t:ext, b:conn, xlate: TRUE],

cellType,

CoreGlue.CellProc[t:conn, b:ext, xlate: TRUE] ] ]};

RtDrPadIO: PUBLIC PROC[sIn, altOut: ROPE ← NIL]

RETURNS [cellType: CellType, sOut: ROPE] = {

IF altOut#NIL THEN Signal[];

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

{

Drive: PROC[dir: IFUCoreDrive.Dir, in, out: ROPE, inverted, dual: BOOL ← FALSE] = {

drives ← CONS[IFUCoreDrive.SpecificDrive[dir, in, out, inverted, dual], drives]};

drives: IFUCoreDrive.Drives ← NIL;

toInside: IFUCoreDrive.Dir = out;

toOutside: IFUCoreDrive.Dir = in;

Drive[toInside, "DPRejectB", "DPRejectBA", FALSE, TRUE];

Drive[toInside, "DPFaultB.3", "DPFaultBA.3"];

Drive[toInside, "DPFaultB.2", "DPFaultBA.2"];

Drive[toInside, "DPFaultB.1", "DPFaultBA.1"];

Drive[toInside, "DPFaultB.0", "DPFaultBA.0"];

Drive[toOutside, "DPFaultBA.3", "DPFaultBAA.3"];

Drive[toOutside, "DPFaultBA.2", "DPFaultBAA.2"];

Drive[toOutside, "DPFaultBA.1", "DPFaultBAA.1"];

Drive[toInside, "DPFaultBAA.3", "DPFaultAB.3"];

Drive[toInside, "DPFaultBAA.2", "DPFaultAB.2"];

Drive[toInside, "DPFaultBAA.1", "DPFaultAB.1"];

Drive[toOutside, "DPCmnd2BA.7", "DPCmnd2BAA.7"];

Drive[toOutside, "DPCmnd2BA.6", "DPCmnd2BAA.6"];

Drive[toOutside, "DPCmnd2BA.5", "DPCmnd2BAA.5"];

Drive[toOutside, "DPCmnd2BA.4", "DPCmnd2BAA.4"];

Drive[toOutside, "DPCmnd2BA.3", "DPCmnd2BAA.3"];

Drive[toOutside, "DPCmnd2BA.2", "DPCmnd2BAA.2"];

Drive[toOutside, "DPCmnd2BA.1", "DPCmnd2BAA.1"];

Drive[toOutside, "DPCmnd2BA.0", "DPCmnd2BAA.0"];

Drive[toOutside, "Flag2BA.6", "UserMode2BAA"];

Drive[toOutside, "EUAluOp2AB.3", "EUAluOp2ABB.3"];

Drive[toOutside, "EUAluOp2AB.2", "EUAluOp2ABB.2"];

Drive[toOutside, "EUAluOp2AB.1", "EUAluOp2ABB.1"];

Drive[toOutside, "EUAluOp2AB.0", "EUAluOp2ABB.0"];

Drive[toOutside, "EUCondSel2AB.3", "EUCondSel2ABB.3"];

Drive[toOutside, "EUCondSel2AB.2", "EUCondSel2ABB.2"];

Drive[toOutside, "EUCondSel2AB.1", "EUCondSel2ABB.1"];

Drive[toOutside, "EUCondSel2AB.0", "EUCondSel2ABB.0"];

Drive[toInside, "EUCondition2B", "EUCondition2BA"];

Drive[toOutside, "EUWriteToPBus3AB", "EUWriteToPBus3ABB"];

Drive[toOutside, "EURdFromPBus3AB", "EURdFromPBus3ABB"];

Drive[toInside, "KPadsIn3BA", "KPadsOut3BA", TRUE];

Drive[toInside, "KPadsIn3BA", "KPadsIn4Ac", FALSE, TRUE];

Drive[toOutside, "X2ASrcLit1BA", "X2ASrcLit1BAA"];

Drive[toInside, "X2ASrcLit1BAA", "X2ASrcLit2Ac", FALSE, TRUE];

Drive[toInside, NIL, "DebugABGD"];

Drive[toInside, NIL, "DebugPC"];

Drive[toInside, NIL, "DebugLSCF"];

Drive[toInside, NIL, "DebugABStLim"];

[drives, sOut] ← IFUCoreDrive.CapDrives[drives, sIn];

cellType ← IFUCoreDrive.DrivesToFrame[name, drives];

IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];

CoreFrame.WriteFrameCache[cellType]};

};

[sIn, sOut] ← IFUCoreDrive.GetDShiftIO[cellType];

cellType ← CoreFrame.NewFrameCells[ name: "RtDrPadIO", rec: [first: left],

cells: LIST[ CoreGlue.CellProc[l: ext, r: conn], cellType ]]};

RightColumn: PUBLIC PROC RETURNS[cellType: CellType] = {

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

sftIn: ROPE ← IFUSrc.dShLeftOut;

sftOut: ROPE ← IFUSrc.dShRightOut;

sft: ROPE ← sftIn;

logo, instrDecode, rtDrPadIO: CellType;

idTopLeft, idTopRight, idBotLeft, idBotRight: CellType;

capBot

[rtDrPadIO, sft] ← RtDrPadIO[sft];

[instrDecode, sft] ← IFUSrc.InstrDecode[sft, sftOut];

capTop

logo ← IFULogo[];

CoreFrame.FCT[logo].orient ← CDOrient.mirrorX;

Note: left and right are deliberately swapped below. Want to make checkpoint in normal orientation so that all the specific generic drivers do not have to be reoriented. Left and right are set right just after reading in the checkpoint.

idTopLeft ← CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[

"GND/50", "VDD/50" ]];

idTopRight ← CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[

"GND/50", "VDD/50", sftOut ]];

idBotLeft ← CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[

"GND/50", "VDD/50", "IDPlaFireV", "IDPlaNotPhA", "NotDPRejectBA", "Stage3ANormalBA", "KPadsIn3BA"]];

idBotRight ← CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[

"GND/50", "VDD/50", "DShRd", "DShWt", "DShA", "DShB", "KPadsIn3BA",

"PhA", "PhB", "NotPhA", "NotPhB", "IDPlaFireV", "IDPlaNotPhA", "NotDPRejectBA", "Stage3ANormalBA", sftIn ]];

cellType ← CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST [

logo,

CoreGlue.CellProc[l: chan, b: conn, r: chan, lCell: idTopLeft, rCell: idTopRight],

instrDecode,

rtDrPadIO,

CoreGlue.CellProc[l: chan, t: conn, r: chan, lCell: idBotLeft, rCell: idBotRight] ] ];

CoreFrame.WriteFrameCache[cellType] };

CoreFrame.FCT[cellType].orient ← CDOrient.mirrorX;

cellType ← CoreFrame.NewFrameCells[ name: "IFURightColumn", rec: [first: top], cells: LIST [

CoreGlue.CellProc[ ], cellType, CoreGlue.CellProc[ ] ] ] };

Heart: PUBLIC PROC RETURNS[cellType: CellType] = {

IF (cellType ← CoreFrame.ReadFrameCache[name]) =NIL THEN {

topLt: CellType ← CoreGlue.ChanSideCell[ side: top, layer: CCDUtils.cmosMet2,

list: LIST["VDD/96", "GND/96" ] ];

botLt: CellType ← CoreGlue.ChanSideCell[ side: bottom, layer: CCDUtils.cmosMet2,

list: LIST["VDD/96", "GND/96" ] ];

topRt: CellType ← CoreGlue.ChanSideCell[ side: top, layer: CCDUtils.cmosMet2,

list: LIST["VDD/96", "GND/96", "ResetAB" ] ];

botRt: CellType ← CoreGlue.ChanSideCell[ side: bottom, layer: CCDUtils.cmosMet2,

list: LIST["VDD/96", "GND/96", "KPadsOut3BA", "NotKPadsIn4Ac", "KPadsIn4Ac" ] ];

cellType ← CoreFrame.NewFrameCells[ name: name, rec: [first: left], cells: LIST [

LeftColumn[],

CoreGlue.CellProc[name: "IFULtColumnRoute", l: conn, r: conn,

t: chan, tCell: topLt,

b: chan, bCell: botLt],

DataColumn[],

CoreGlue.CellProc[name: "IFURtColumnRoute", l: conn, r: conn,

t: chan, tCell: topRt,

b: chan, bCell: botRt],

RightColumn[] ] ];

CoreFrame.WriteFrameCache[cellType] }};

PadHeart: PUBLIC PROC RETURNS[cellType: CellType] = {

ltTop: CellType ← CoreGlue.ChanSideCell[ side: top, layer: CCDUtils.cmosMet2,

list: LIST["PhA", "PhB", "ResetAB" ] ];

ltBot: CellType ← CoreGlue.ChanSideCell[ side: bottom, layer: CCDUtils.cmosMet2,

list: LIST["PhA", "PhB" ] ];

cellType ← CoreFrame.NewFrameCells[ name: "IFUPadHeart", rec: [first: left], cells: LIST [

PadLt[],

CoreFrame.NewFrameCells[ name: "IFUPadHeartMid", rec: [first: left], cells: LIST [

CoreGlue.CellProc

[name: "IFULtPadRoute", l: pwr, b: chan, r: conn, t: chan, bCell: ltBot, tCell: ltTop],

CoreFrame.NewFrameCells[ name: "IFUPadHeartY", rec: [first: top], cells: LIST [

CoreGlue.CellProc[t: ext, b: conn],

Heart[],

CoreGlue.CellProc[t: conn, b: ext] ] ],

CoreGlue.CellProc

[name: "IFURtPadRoute", l: conn, b: cap, r: pwr, t: cap] ] ],

PadRt[] ] ]};

Complete: PUBLIC PROC RETURNS[cellType: CellType] = {

IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {

cellType ← CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST [

PadTop[],

CoreFrame.NewFrameCells[ name: "TopPadGlue", rec: [first: left], cells: LIST [

PadExt[left, top],

CoreGlue.CellProc[name: "IFUTopPadRoute", t: pwr, b: conn],

PadExt[right, top] ] ],

PadHeart[],

CoreFrame.NewFrameCells[ name: "BotPadGlue", rec: [first: left], cells: LIST [

PadExt[left, bottom],

CoreGlue.CellProc[name: "IFUBotPadRoute", t: conn, b: pwr],

PadExt[right, bottom] ] ],

PadBot[] ] ];

CoreFrame.WriteFrameCache[cellType]}};

END.