DIRECTORY CD, CDCells, CDSimpleRules, CDSymbolicObjects, CMosB, CoreCreate, CoreOps, CoreProperties, EU2LeafUtils, EU2Regs, EU2Utils, LayoutCheckpoint, PW, PWCore, PWCoreRoute, Rope;

EU2RegsImpl: CEDAR PROGRAM
IMPORTS CD, CDCells, CDSimpleRules, CDSymbolicObjects, CMosB, CoreCreate, CoreOps, CoreProperties, EU2LeafUtils, EU2Utils, LayoutCheckpoint, PW, PWCore, PWCoreRoute, Rope 
EXPORTS EU2Regs = 
BEGIN OPEN CoreCreate, EU2LeafUtils, EU2Regs, EU2Utils;

ConnectedBuses: PROC [reg: PipeRange] RETURNS [buses: Wire] ~ {
dReadBusPresent: BOOL _ FALSE;
names: LIST OF WR _ NIL;
name: ROPE;
FOR i: NAT IN [0..sources[reg].sizeSel) DO
input: SourceRange _ sources[reg].inputs[i];
name _ sources[input].name; 	-- name of one input
IF Rope.Equal[name, dReadBus] THEN dReadBusPresent _ TRUE;
names _ CONS[sources[input].name, names];
ENDLOOP;
name _ sources[reg].name;	-- name of the output of the source
names _ CONS[name, names];
IF Rope.Equal[name, dReadBus] THEN dReadBusPresent _ TRUE;
IF ~dReadBusPresent THEN names _ CONS[dReadBus, names];
buses _ WireList[names];
};
CreateBuses: PROC [reg: PipeRange, leftCT: CellType, horizontalWire: Wire] RETURNS [cellType: CellType] ~ {
public: Wire _ CoreOps.CopyWire[Union[AllBuses[reg], horizontalWire]]; -- do not forget the copy wire! (otherwise, wires are shared and that might result in 815!!!)
cellType _ Cell[
name: "CreateBuses",
public: public,
instances: NIL
];
PWCore.SetLayout[cellType, $CreateBusesLayout, $LeftCellType, leftCT];
CoreProperties.PutCellTypeProp[cellType, $Reg, NEW[NAT _ reg]];
};

FindBusPosX: PROC [name: ROPE] RETURNS [INT] ~ {
FOR i: SourceRange IN SourceRange DO
IF sources[i].name=name THEN RETURN[(sources[i].trackPosX*8+2)*CMosB.lambda];
ENDLOOP;
ERROR;	-- who the hell is this bus???
};

IsTopBus: PROC [name: ROPE, reg: NAT] RETURNS [BOOL _ FALSE] ~ {
FOR l: Buses _ sources[reg].topOnlyBuses, l.rest WHILE l#NIL DO
IF Rope.Equal[sources[l.first].name, name] THEN RETURN [TRUE];
ENDLOOP;
};
IsBotBus: PROC [name: ROPE, reg: NAT] RETURNS [BOOL _ FALSE] ~ {
FOR l: Buses _ sources[reg].botOnlyBuses, l.rest WHILE l#NIL DO
IF Rope.Equal[sources[l.first].name, name] THEN RETURN [TRUE];
ENDLOOP;
};
IsVBus: PROC [name: ROPE, reg: NAT] RETURNS [BOOL _ FALSE] ~ {
FOR l: Buses _ sources[reg].throughBuses, l.rest WHILE l#NIL DO
IF Rope.Equal[sources[l.first].name, name] THEN RETURN [TRUE];
ENDLOOP;
FOR l: Buses _ sources[reg].topOnlyBuses, l.rest WHILE l#NIL DO
IF Rope.Equal[sources[l.first].name, name] THEN RETURN [TRUE];
ENDLOOP;
FOR l: Buses _ sources[reg].botOnlyBuses, l.rest WHILE l#NIL DO
IF Rope.Equal[sources[l.first].name, name] THEN RETURN [TRUE];
ENDLOOP;
};
CreateBusesLayout: PWCore.LayoutProc = {
DrawNet: PROC [wire: Wire] ~ {
leftWire: Wire;
shortName: ROPE _ CoreOps.GetFullWireName[cellType.public, wire];
leftWire _ CoreCreate.FindWire[leftCT.public, shortName];
IF leftWire=NIL THEN { -- vertical through bus, no contact
posX: INT _ FindBusPosX[shortName];
inst: CD.Instance _ PW.IncludeInCell[obj, 
CDSymbolicObjects.CreatePin[[4*CMosB.lambda, sizeY]], 
[posX, 0]];
CDSymbolicObjects.SetName[inst, shortName];
CDSymbolicObjects.SetLayer[inst, CMosB.met2];
[] _ PW.IncludeInCell[obj, 
CDSimpleRules.Rect[[4*CMosB.lambda, sizeY], CMosB.met2], 
[posX, 0]];
RETURN};	
IF ~IsVBus[shortName, reg] THEN {	-- control line
DrawHoriz: PWCore.EachPinProc = {
inst: CD.Instance;
IF side#right THEN RETURN;
IF layer#CMosB.met THEN RETURN;
inst _ PW.IncludeInCell[obj, 
CDSymbolicObjects.CreatePin[[sizeX, max-min]], 
[0, min]];
CDSymbolicObjects.SetName[inst, shortName];
CDSymbolicObjects.SetLayer[inst, CMosB.met];
[] _ PW.IncludeInCell[obj, 
CDSimpleRules.Rect[[sizeX, max-min], CMosB.met], 
[0, min]];
};
[] _ PWCore.EnumeratePins[leftCT, leftWire, DrawHoriz];
RETURN;
}
ELSE {		-- contact on this bus
DrawContact: PWCore.EachPinProc = {
inst: CD.Instance;
IF side#right THEN RETURN;
IF layer#CMosB.met THEN RETURN;
inst _ PW.IncludeInCell[obj, 
CDSymbolicObjects.CreatePin[[posX, max-min]], 
[0, min]];
CDSymbolicObjects.SetName[inst, shortName];
CDSymbolicObjects.SetLayer[inst, CMosB.met];
[] _ PW.IncludeInCell[obj, 
CDSimpleRules.Rect[[posX, max-min], CMosB.met], 
[0, min]];
[] _ PW.IncludeInCell[obj, 
CDSimpleRules.Contact[CMosB.met, CMosB.met2], 
[posX, min]];	-- the contact
y1 _ MIN[y1, min];
y2 _ MAX[y2, max];
};
y1, y2: INT;
posX: INT _ FindBusPosX[shortName];
y1 _ IF IsTopBus[shortName, reg] THEN LAST[INT] ELSE 0;
y2 _ IF IsBotBus[shortName, reg] THEN FIRST[INT] ELSE sizeY;
[] _ PWCore.EnumeratePins[leftCT, leftWire, DrawContact];
[] _ PW.IncludeInCell[obj, CDSimpleRules.Rect[[4*CMosB.lambda, y2-y1], CMosB.met2], [posX, y1]];
};
};
leftCT: CellType _ NARROW[CoreProperties.GetCellTypeProp[cellType, $LeftCellType]];
leftSize: CD.Position _ CD.InterestSize[PWCore.Layout[leftCT]];
sizeX: INT _ 140*CMosB.lambda-leftSize.x;
sizeY: INT _ leftSize.y;
reg: NAT _ NARROW[CoreProperties.GetCellTypeProp[cellType, $Reg], REF NAT]^;
obj _ PW.CreateEmptyCell[];
CoreOps.VisitAtomicWires[cellType.public, DrawNet];
CDCells.SetInterestRect[obj, [0, 0, sizeX, sizeY]];
PW.RepositionCell[obj];
};

CreateRegAndMuxOnly: PROC [reg: PipeRange] RETURNS [cellType: CellType] ~ {
-- The select lines, i.e. selLeftSrc[0..3), and all public of reg, except "in"
sel: Wire _ Seq["sel", sources[reg].sizeSel+2];
mux: CellType _ Extract["RegMux.sch"];	-- Vdd, Gnd, sel, muxIn, muxOut
instances: LIST OF CellInstance _ NIL;
muxOut: Wire _ CoreOps.CreateWire[name: "muxOut"];
FOR i: NAT IN [0..sources[reg].sizeSel) DO
instances _ CONS[
Instance[mux, 
["sel", Index[sel, i]], 
["muxIn", sources[sources[reg].inputs[i]].name], 
["muxOut", muxOut]],
instances];
ENDLOOP;
instances _ CONS[	-- sel[max] = write cBus
Instance[mux, 
["sel", sel[sources[reg].sizeSel]], 
["muxIn", dReadBus], 
["muxOut", muxOut]],
instances];
instances _ CONS[
Instance[Extract["Register.sch"], 	-- Vdd, Gnd, in, out, dRead, dOut
["in", muxOut],
["out", sources[reg].name],
["dRead", Index[sel, sources[reg].sizeSel+1]],
["dOut", dReadBus] ],
instances];
cellType _ Cell[
name: "RegAndMuxOnly",
public: Union[ConnectedBuses[reg], Wires[sel, "Vdd", "Gnd"]],
onlyInternal: Wires[muxOut],
instances: instances
];
PWCore.SetAbutY[cellType];
};
CreateRegCell: PROC [reg: PipeRange] RETURNS [cellType: CellType] ~ {
sel: Wire _ Seq["sel", sources[reg].sizeSel+2];
regAndMuxOnly: CellType _ CreateRegAndMuxOnly[reg];
cellType _ Cell[
name: "Reg",
public: Union[AllBuses[reg], Wires[sel, "Vdd", "Gnd"]],
instances: LIST[
Instance[regAndMuxOnly],
Instance[CreateBuses[reg, regAndMuxOnly, Wires[sel]]]]
];
PWCore.SetAbutX[cellType];
};
CreateReg: PUBLIC PROC [reg: PipeRange] RETURNS [cellType: CellType] = {
buses: Wire _ AllBuses[reg];
cellType _ SequenceCell[
name: "RegWithMux",
baseCell: CreateRegCell[reg],
count: wordSize,
sequencePorts: buses];
PWCore.SetArrayX[cellType];
};

CreatePDriver: PUBLIC PROC RETURNS [cellType: CellType] = {
cellType _ SequenceCell[
name: "PDriver",
baseCell: Extract["PDriver.sch"],
count: wordSize,
sequencePorts: Wires["r2B", "st3A", "cBus", "pDriver"]];
PWCore.SetArrayX[cellType];
};
CreateCBusDriver: PUBLIC PROC RETURNS [cellType: CellType] = {
cellType _ SequenceCell[
name: "CBusDriver",
baseCell: Extract["cBusDriver.sch"],
count: wordSize,
sequencePorts: Wires["r3B", "dataIn", "cBus", "pDriver"]];
PWCore.SetArrayX[cellType];
};
CreateShRegDriver: PUBLIC PROC RETURNS [cellType: CellType] = {
cellType _ SequenceCell[
name: "shRegDriver",
baseCell: Extract["shReg.sch"],
count: wordSize,
sequencePorts: Wires["out", "ramA", "ramB", "in", "cBus", "ifuIn"]];
PWCore.SetArrayX[cellType];
};

CreatekRegAndRight: PUBLIC PROC RETURNS [cellType: CellType] = {
In: PROC [i: NAT] RETURNS [Wire] ~ {RETURN[inOut[i+1]]};
Out: PROC [i: NAT] RETURNS [Wire] ~ {RETURN[inOut[i]]};
Vdd: Wire _ CoreOps.CreateWire[name: "Vdd"];
Gnd: Wire _ CoreOps.CreateWire[name: "Gnd"];
ramA: Wire _ Bus["ramA"];
ramB: Wire _ Bus["ramB"];
cBus: Wire _ Bus["cBus"];
ifuIn: Wire _ Bus["ifuIn"];
kReg: Wire _ Bus["kReg"];
selKReg: Wire _ GenRegSelWire[EU2Utils.kReg];
shiftA: Wire _ CoreOps.CreateWire[name: "shiftA"];
shiftB: Wire _ CoreOps.CreateWire[name: "shiftB"];
read: Wire _ CoreOps.CreateWire[name: "read"];
write: Wire _ CoreOps.CreateWire[name: "write"];
inOut: Wire _ Seq["inOut", 33];
shRegIn: Wire _ Seq["shRegIn", 32];
shRegOut: Wire _ Seq["shRegOut", 32];

public: Wire _ WireList[LIST[Vdd, Gnd, ramA, ramB, cBus, ifuIn, kReg, selKReg, shiftA, shiftB, read, write, In[31], Out[0]]];	-- notice the indexes !!!
onlyInternal: Wire _ WireList[LIST[inOut, shRegIn, shRegOut]];
channelData: PWCoreRoute.ChannelData _ NEW[PWCoreRoute.ChannelDataRec _ [
inX: FALSE,
bottomOrLeftWires: LIST[Vdd, Gnd, kReg],
topOrRightWires: LIST[Vdd, Gnd, cBus, ifuIn, In[31], Out[0]],
trunkLayer: "metal",
branchLayer: "metal2",
wireWidthProc: PWCoreRoute.GndAndVdd25Met2MinWidth
]];
[] _ CoreOps.SetShortWireName[In[31], "shIn"];
[] _ CoreOps.SetShortWireName[Out[0], "shOut"];

FOR i: NAT IN [0..32) DO shRegIn[i] _ In[i]; shRegOut[i] _ Out[i]; ENDLOOP;

IF EU2Utils.usekRegAndRightCheckpoint THEN RETURN [LayoutCheckpoint.Retrieve["kRegAndRight"]];

cellType _ Cell[
name: "kRegAndRight",
public: public,
onlyInternal: onlyInternal,
instances: LIST [
Instance[CreateShRegDriver[], ["in", shRegIn], ["out", shRegOut]],
Instance[CreateReg[EU2Utils.kReg], ["sel", selKReg]]
]
];
PWCore.SetLayout[cellType, $Channel, $ChannelData, channelData];
};

[] _ PWCore.RegisterLayoutAtom[$CreateBusesLayout, CreateBusesLayout, PWCore.DecorateGet];

END.






|EU2RegsImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Louis Monier June 19, 1986 4:43:22 pm PDT
Barth, April 22, 1986 12:27:26 pm PST
Bertrand Serlet May 12, 1986 0:47:30 am PDT
-- All the buses used as input or output, including the bus for debugging (dReadBus)
-- no bus is both an input and an output
-- add the dReadBus if not yet present

-- control line or contact on this bus, i.e. pins found on the right side of leftCT
-- Assemble the reg, the muxes and the buses
-- The inputs in EU2Utils.sources[reg].inputs are in the order, i.e. for left: sel[0]->ramA
-- Instances: the register and all mux transistors

-- Same as before, but with the routing on the right
-- write from cBus (debugging only) is mapped onto sel[max+1]
-- dRead is mapped onto sel[max+2]

-- Just a replication of 32 register+mux
-- Special guys
-- To build the internal and public
Κ<–

"cedar" style˜
codeš
œ™Kšœ
Οm
œ1™<K™)K™%K™+—K˜KšΟk	œ
žœŠ
žœ˜Ά
K˜•StartOfExpansion[]šΟbœžœ
ž˜Kšžœ
žœ
žœ˜«
Kšžœ˜Kšžœ
žœ-˜7K˜Kš
œT™TšΟnœžœžœ˜?Kšœžœžœ
˜Kš	œžœ
žœ
žœžœ
˜Kšœžœ
˜šžœžœ
žœž˜*Kš
œ,˜,KšœΟc˜1Kšžœžœžœ
˜:Kšœžœ˜)Kšžœ
˜—K™(Kšœ‘#˜=Kšœžœ˜Kšžœžœžœ
˜:Kš
œ&™&Kšžœžœ	žœ˜7Kš
œ˜K˜K™—š œžœ:žœ˜kKšœG‘]˜€
š
œ˜Kš
œ˜Kš
œ˜Kšœž˜K˜—Kš
œF˜FKšœ/žœ
žœ	˜?K˜K˜—š
 œžœžœžœžœ˜0šžœžœ
ž˜$Kšžœžœ
žœ*˜MKšžœ
˜—Kšžœ‘˜%K˜—K˜š œžœžœžœžœžœžœ˜@šžœ.žœžœ
ž˜?Kšžœ)žœ
žœžœ˜>Kšžœ
˜—K˜—š œžœžœžœžœžœžœ˜@šžœ.žœžœ
ž˜?Kšžœ)žœ
žœžœ˜>Kšžœ
˜—K˜—š œžœžœžœžœžœžœ˜>šžœ.žœžœ
ž˜?Kšžœ)žœ
žœžœ˜>Kšžœ
˜—šžœ.žœžœ
ž˜?Kšžœ)žœ
žœžœ˜>Kšžœ
˜—šžœ.žœžœ
ž˜?Kšžœ)žœ
žœžœ˜>Kšžœ
˜—K˜—š œ˜(š œžœ˜K˜Kšœžœ2˜AKš
œ9˜9šžœ
žœ
žœ‘#˜:Kšœžœ˜#šœžœžœ˜*Kš
œ6˜6Kš
œ˜—Kš
œ+˜+Kš
œ-˜-šœžœ˜Kš
œ9˜9Kš
œ˜—Kšžœ˜	—Kš
œS™Sšžœžœ‘˜1š 	œ˜!Kšœžœ
˜Kšžœžœ
žœ
˜Kšžœžœ
žœ
˜šœžœ˜Kš
œ/˜/Kš
œ
˜
—Kš
œ+˜+Kš
œ,˜,šœžœ˜Kš
œ1˜1Kš
œ
˜
—Kš
œ˜—Kš
œ7˜7Kšžœ
˜Kš
œ
˜
—šžœ‘˜š œ˜#Kšœžœ
˜Kšžœžœ
žœ
˜Kšžœžœ
žœ
˜šœžœ˜Kš
œ.˜.Kš
œ
˜
—Kš
œ+˜+Kš
œ,˜,šœžœ˜Kš
œ0˜0Kš
œ
˜
—šœžœ˜Kš
œ.˜.Kšœ‘˜—Kšœžœ
˜Kšœžœ
˜Kš
œ˜—Kšœžœ
˜Kšœžœ˜#Kšœžœžœ
žœ
žœžœ˜7Kšœžœžœ
žœ
žœžœ˜<Kš
œ9˜9KšœžœY˜`K˜—K˜—Kšœžœ:˜SKšœ
žœ3˜?Kšœžœ˜)Kšœžœ˜Kš	œžœžœ1žœ
žœ˜LKšœžœ˜Kš
œ3˜3Kš
œ3˜3Kšžœ˜K˜K˜—Kš
œ,™,Kš
œ[™[š œžœžœ˜KKšœ‘K˜NKš
œ/˜/K™2Kšœ'‘˜FKšœžœ
žœžœ
˜&Kš
œ2˜2šžœžœ
žœž˜*šœžœ
˜š
œ˜Kš
œ˜Kš
œ1˜1Kš
œ˜—Kš
œ˜—Kšžœ
˜—šœžœ‘˜*š
œ˜Kš
œ$˜$Kš
œ˜Kš
œ˜—Kš
œ˜—šœžœ
˜šœ&‘˜DKš
œ˜Kš
œ˜Kš
œ.˜.Kš
œ˜—Kš
œ˜—š
œ˜Kš
œ˜Kš
œ=˜=Kš
œ˜Kš
œ˜K˜—Jš
œ˜K˜K™—J™4Jš
œ=™=Jš
œ"™"š 
œžœžœ˜EKš
œ/˜/Kš
œ3˜3š
œ˜Kš
œ˜Kš
œ7˜7šœžœ
˜Kš
œ˜Kš
œ6˜6—K˜—Jš
œ˜K˜K™—K™(š 	œžœ
žœžœ˜HKš
œ˜š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Jš
œ˜Kš
œ˜K˜—K™š 
œžœ
žœ
žœ˜;š
œ˜Kš
œ˜Kš
œ!˜!Kš
œ˜Kš
œ8˜8—Jš
œ˜Kš
œ˜—š œžœ
žœ
žœ˜>š
œ˜Kš
œ˜Kš
œ$˜$Kš
œ˜Kš
œ:˜:—Jš
œ˜Kš
œ˜—š œžœ
žœ
žœ˜?š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œD˜D—Jš
œ˜Kš
œ˜—K˜š œžœ
žœ
žœ˜@Kš
 œžœžœžœžœ˜8Kš
 œžœžœžœžœ˜7K™#Kš
œ,˜,Kš
œ,˜,Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ-˜-Kš
œ2˜2Kš
œ2˜2Kš
œ.˜.Kš
œ0˜0Kš
œ˜Kš
œ#˜#Kš
œ%˜%K˜Kšœžœb‘˜—
Kšœžœ˜>šœ'žœ˜IKšœžœ
˜Jšœžœ˜(Jšœžœ(˜=Jš
œ˜Jš
œ˜Jš
œ2˜2J˜—Kš
œ.˜.Kš
œ/˜/K˜Kš
žœžœ
žœ	žœ+žœ
˜KK˜Kšžœ$žœ
žœ-˜^K˜š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜šœžœ˜Kš
œB˜BKš
œ4˜4Kš
œ
˜
—K˜—Kš
œ@˜@Kš
œ˜K˜—š
œZ˜ZK˜——šžœ
˜K˜—K˜K˜K˜K˜K˜—…—%*3β