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

IMPORTS CCDUtils, CDOrient, CoreFrame, CoreGlue, CoreName, CoreLibrary, IFUCoreCtl, IFUCoreDrive, IFUCorePads, IFUSrc, IO, PW

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"];

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

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#32 THEN ERROR;

IF ltOrRt

THEN {

cnt ← 32+15;

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

ELSE {

cnt ← 32+15+2; -- corners on top and bottom

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[[type: corHi ]];

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 ]]; PadCell[ Sig[] ]; PadCell[ Sig[] ];

IF NOT ltOrRt THEN PadCell[[type: corLo ]];

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 RETURN;

IF Dragon.PBusCommands[Fetch].ORD#16 THEN Signal[];

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

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

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

pads ← CONS[ [type: out, data2: "NewFetchBAA"], 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];

cellType ← MakePads[name, left, pads];

CoreFrame.WriteFrameCache[cellType]};

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

pads: LIST OF PadRec ← NIL;

IF (cellType ← CoreFrame.ReadFrameCache[name])#NIL THEN RETURN;

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

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

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

pads ← CONS[ [type: in, data1: "DPRejectB"], 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: triOut, data2: "DPCmnd3A.7", enWtA: NRjt, enWtB: GND], pads];

pads ← CONS[ [type: triOut, data2: "DPCmnd3A.6", enWtA: NRjt, enWtB: GND], pads];

pads ← CONS[ [type: triOut, data2: "DPCmnd3A.5", enWtA: NRjt, enWtB: GND], pads];

pads ← CONS[ [type: triOut, data2: "DPCmnd3A.4", enWtA: NRjt, enWtB: GND], pads];

pads ← CONS[ [type: triOut, data2: "DPCmnd3A.3", enWtA: NRjt, enWtB: GND], pads];

pads ← CONS[ [type: triOut, data2: "DPCmnd3A.2", enWtA: NRjt, enWtB: GND], pads];

pads ← CONS[ [type: triOut, data2: "DPCmnd3A.1", enWtA: NRjt, enWtB: GND], pads];

pads ← CONS[ [type: triOut, data2: "DPCmnd3A.0", enWtA: NRjt, enWtB: GND], pads];

pads ← CONS[ [type: out, data2: "DPCmnd3ABB.7"], pads];

pads ← CONS[ [type: out, data2: "DPCmnd3ABB.6"], pads];

pads ← CONS[ [type: out, data2: "DPCmnd3ABB.5"], pads];

pads ← CONS[ [type: out, data2: "DPCmnd3ABB.4"], pads];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

cellType ← MakePads[name, right, pads];

CoreFrame.WriteFrameCache[cellType]};

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

pads: LIST OF PadRec ← NIL;

IF (cellType ← CoreFrame.ReadFrameCache[name])#NIL THEN RETURN;

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: out, data2: in, enWtA: VDD, enWtB: GND], pads];

ENDLOOP;

cellType ← MakePads[name, top, pads];

CoreFrame.WriteFrameCache[cellType]};

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

enWtA: ROPE ← "NotKPadsIn3BA";

enRd: ROPE ← "KPadsIn4Ac";

disRd: ROPE ← "NotKPadsIn4Ac";

pads: LIST OF PadRec ← NIL;

IF (cellType ← CoreFrame.ReadFrameCache[name])#NIL THEN RETURN;

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], pads];

ENDLOOP;

cellType ← MakePads[name, bottom, pads];

CoreFrame.WriteFrameCache[cellType]};

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[r: ext, l: conn] ] ] };

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 {

dr: IFUCoreDrive.Drive;

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

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

desc.plaType ← hot ;

desc.nofTermCols ← 3;

desc.fullWidthTerms ← FALSE;

desc.inSh ← sIn;

IFUCoreCtl.MakePLA1[desc];

dr ← IFUCoreDrive.FindDrive[desc.inDrs, "CIsField2BA"]; dr.in.ph ← AB;

dr ← IFUCoreDrive.FindDrive[desc.inDrs, "CIsField3BA"]; dr.in.ph ← AB;

dr ← IFUCoreDrive.FindDrive[desc.inDrs, "A1IsC2BA"]; dr.in.ph ← B;

dr ← IFUCoreDrive.FindDrive[desc.inDrs, "A1IsC3BA"]; dr.in.ph ← B;

dr ← IFUCoreDrive.FindDrive[desc.inDrs, "B1IsC2BA"]; dr.in.ph ← B;

dr ← IFUCoreDrive.FindDrive[desc.inDrs, "B1IsC3BA"]; dr.in.ph ← B;

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];

dr ← IFUCoreDrive.FindDrive[desc.inDrs, "DPFaultedBA"]; dr.name ← "DPFault"; dr.idx ← 0;

dr ← IFUCoreDrive.FindDrive[desc.inDrs, "Push2BA"]; dr.in.ph ← AB;

dr ← IFUCoreDrive.FindDrive[desc.inDrs, "MicroExcptJmpBubbleBA"]; dr.in.ph ← AB;

dr ← IFUCoreDrive.FindDrive[desc.inDrs, "Stage2BAbortBA"]; dr.in.ph ← AB;

IFUCoreDrive.AdjustDriveOutPh[desc.outDrs, "

Stage2ANormalBA Stage2ABubbleBA

Stage3ANormalBA Stage3AAbortBA

LoadStage1Ac

LoadStage2Ac

LoadStage3Ac

X2ASrcLit2Ac NotX2ASrcLit2Ac

Stage1BHoldingAB NotStage1BHoldingAB

Stage2BNormalAB Stage2BAbortAB

Stage3BCPipeNormalAB Stage3BCPipeAbortAB

MicroExcptJmpNoneAB

MicroExcptJmpMicroJumpAB

MicroExcptJmpBubbleAB

MicroExcptJmpResettingAB

MicroExcptJmpTrapAB

MicroExcptJmpCJumpAB

ExceptTypeSpecialCodeAB ExceptTypeCondCodeAB ExceptTypeDpFaultAB

ExceptCodeAB.0 ExceptCodeAB.1 ExceptCodeAB.2 ExceptCodeAB.3 " ];

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

dr.name ← "LoadStage";

dr.dualOut ← FALSE;

dr.gate ← negBc;

dr.in ← [pos, A];

dr.ref ← [neg, 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"];

Drive[toInside, NIL, "DebugOpStatus"];

Drive[toInside, NIL, "DebugABGD"];

Drive[toInside, NIL, "DebugPC"];

Drive[toInside, NIL, "DebugLSC"];

Drive[toInside, NIL, "DebugABStLim"];

Drive[toOutside, "KPadsIn3BA", "KPadsIn3BAA"];

Drive[toInside, "KPadsIn3BAA", "NotKPadsIn3BA", TRUE];

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

[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 ]]};

IFULogoObj: CD.Object ← NIL;

GetIFULogo: PWCore.LayoutProc = {

IF IFULogoObj=NIL THEN {

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

IFULogoObj ← PW.Get[design, "IFULogo"];

IFULogoObj ← PW.Rot90[IFULogoObj]};

RETURN[IFULogoObj]};

IFULogo: PROC RETURNS [cellType: CellType] = {

cellType ← CCDUtils.NewBlankCellType[];

PWCore.SetLayout[cellType, $IFULogo];

cellType ← CoreFrame.NewFrameCell

[name: "IFULogo", rec: [first: top, cell: cellType], size: 0]};

IFULogoCell: CellType ← NIL;

IFULogo: PROC RETURNS [cellType: CellType] = {

IF IFULogoCell=NIL THEN {

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

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

object ← PW.Rot90[object];

IFULogoCell ← CoreLibrary.ObjCell[object, "IFULogo"]};

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[] ]] };

pwrLeft: CellType ← CoreLibrary.ObjCell[ CoreGlue.SideObject[ left, LIST[

[name: GND, max: 32*CCDUtils.lambda],

[name: VDD, max: 32*CCDUtils.lambda] ], CCDUtils.cmosMet], CoreName.ID["ChanSide"]];

pwrRight: CellType ← CoreLibrary.ObjCell[ CoreGlue.SideObject[ right, LIST[

[name: GND, max: 32*CCDUtils.lambda],

[name: VDD, max: 32*CCDUtils.lambda] ], CCDUtils.cmosMet], CoreName.ID["ChanSide"]];

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

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

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

IFUSrc.LeftColumnTop[],

IFUSrc.LeftColumnBot[] ] ];

CoreFrame.WriteFrameCache[cellType]};

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

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

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

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

sft: ROPE ← NIL;

fetchIndex, fetchControl, ltDrPadIO: CellType;

chanTopLeft, chanTopRight: CellType;

[ltDrPadIO, sft] ← LtDrPadIO [NIL];

[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 ]];

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 ] ];

CoreFrame.WriteFrameCache[cellType]};

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

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

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

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

sftIn: ROPE ← IFUSrc.dShIn;

sft: ROPE ← sftIn;

sftRtn: ROPE ← IFUSrc.dShOut;

stackControl, mainPipeControl, interlock, stackIndex, chanBotLeft, chanBotRight: CellType;

stackIndex ← IFUSrc.StackIndexing [];

capBot

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

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

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

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[

stackControl,

mainPipeControl,

interlock,

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

stackIndex ] ];

CoreFrame.WriteFrameCache[cellType]};

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

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

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

name: ROPE ← CoreName.RopeNm["IFULeftColumnCore"];

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.DataColumnTop[],

IFUSrc.DataColumnBot[] ] ],

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] ] ]};

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

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

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

IFUSrc.Fetch[],

IFUSrc.FetchBuf[],

IFUSrc.XaForm[],

IFUSrc.PCFormTop[],

IFUSrc.PCFormBot[] ] ];

CoreFrame.WriteFrameCache[cellType]}};

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

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

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

IFUSrc.StackBuf[],

IFUSrc.LSForm[],

IFUSrc.ABForm[],

IFUSrc.ControlPipe[] ] ];

CoreFrame.WriteFrameCache[cellType]}};

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"];

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, "DPCmnd3AB.7", "DPCmnd3ABB.7"];

Drive[toOutside, "DPCmnd3AB.6", "DPCmnd3ABB.6"];

Drive[toOutside, "DPCmnd3AB.5", "DPCmnd3ABB.5"];

Drive[toOutside, "DPCmnd3AB.4", "DPCmnd3ABB.4"];

Drive[toOutside, "DPCmnd3AB.3", "DPCmnd3ABB.3"];

Drive[toOutside, "DPCmnd3AB.2", "DPCmnd3ABB.2"];

Drive[toOutside, "DPCmnd3AB.1", "DPCmnd3ABB.1"];

Drive[toOutside, "DPCmnd3AB.0", "DPCmnd3ABB.0"];

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, "EURes3BisPBus3AB", "EURes3BisPBus3ABB"];

Drive[toOutside, "X2ASrcStatus1BA", "X2ASrcStatus2Ac", FALSE, TRUE];

[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, statusControl: CellType;

idTopLeft, idTopRight, idBotLeft, idBotRight: CellType;

statusTopLeft, statusTopRight: CellType;

statusControl ← IFUSrc.StatusControl[];

capBot

[rtDrPadIO, sft] ← RtDrPadIO[sft];

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

capTop

logo ← IFULogo[];

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

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

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

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

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

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

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

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

"PhA", "PhB", "NotPhA", "NotPhB", "FireControlV", "NotPreChg", sftIn ]];

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

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

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

"GND/50", "VDD/50", "PhA", "PhB", "VBB", "DebugOpStatus", "X1ADstStatusBA", "NotX1ADstStatusBA", "LoadStage1Ac", "LoadStage1Bc"]];

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

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

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],

CoreGlue.CellProc[l: chan, b: conn, r: chan, lCell: statusTopLeft, rCell: statusTopRight],

statusControl ] ];

CoreFrame.WriteFrameCache[cellType] };

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 {

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

list: LIST[

"XBus.20","XBus.21","XBus.22","XBus.23","XBus.24","XBus.25","XBus.26","XBus.27",

"XBus.30","XBus.31","XBus.32","XBus.33","XBus.34","XBus.35","XBus.36","XBus.37" ] ];

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

HeartLt[],

CoreGlue.CellProc[name: "RtColumnRoute", l: conn, r: conn, b: chan, bCell: right],

RightColumn[] ] ];

CoreFrame.WriteFrameCache[cellType] }};

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

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

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

list: LIST["NotKPadsIn3BA", "NotKPadsIn4Ac", "KPadsIn4Ac" ] ];

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

LeftColumn[],

CoreGlue.CellProc[name: "LtColumnRoute", l: conn, r: conn, b: chan, bCell: left],

DataColumn[] ] ];

CoreFrame.WriteFrameCache[cellType] }};

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

name: ROPE ← CoreName.RopeNm["IFUHeart"];

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

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

list: LIST["NotKPadsIn3BA", "NotKPadsIn4Ac", "KPadsIn4Ac" ] ];

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

list: LIST[

"XBus.20","XBus.21","XBus.22","XBus.23","XBus.24","XBus.25","XBus.26","XBus.27",

"XBus.30","XBus.31","XBus.32","XBus.33","XBus.34","XBus.35","XBus.36","XBus.37" ] ];

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

LeftColumn[],

CoreGlue.CellProc[name: "LtColumnRoute", l: conn, r: conn, b: chan, bCell: left],

DataColumn[],

CoreGlue.CellProc[name: "RtColumnRoute", l: conn, r: conn, b: chan, bCell: right],

RightColumn[] ] ];

CoreFrame.WriteFrameCache[cellType] }};

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

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

PadLt[],

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

CoreGlue.CellProc[name: "LtPadRoute", l: pwr, b: diff, r: conn],

Heart[],

CoreGlue.CellProc[name: "RtPadRoute", l: conn, b: diff, r: pwr] ] ],

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: "TopPadRoute", t: pwr, b: conn],

PadExt[right, top] ] ],

PadHeart[],

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

PadExt[left, bottom],

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

PadExt[right, bottom] ] ],

PadBot[] ] ];

CoreFrame.WriteFrameCache[cellType]}};

END.