| 1 |
2 |
protik |
/***************************************************************************************/
|
| 2 |
|
|
/* */
|
| 3 |
|
|
/* Author:- Pratik Mahajan */
|
| 4 |
|
|
/* Create Date:- Spring 2009 */
|
| 5 |
|
|
/* Project Name:- Unconfuser for 32 bit data */
|
| 6 |
|
|
/* Target Devices: ASIC */
|
| 7 |
|
|
/*Project Description: To build an unconfuser for 32 bit confused data with around 700 */
|
| 8 |
|
|
/* bits of confusion */
|
| 9 |
|
|
|
| 10 |
|
|
module unConfuser(Clk, Reset, PushIn, Din, Caddr, Cdata, Cpush, PushOut, StopIn, Dout, inMdin, inAddrw, inWrite, inMdout, inAddrr, opMdin, opAddrw, opWrite, opMdout, opAddrr);
|
| 11 |
|
|
|
| 12 |
|
|
/*Port list for unConfuser */
|
| 13 |
|
|
input[7:0] Din, Cdata;
|
| 14 |
|
|
input[6:0] Caddr;
|
| 15 |
|
|
output[7:0] Dout;
|
| 16 |
|
|
input PushIn, Clk, Reset, StopIn, Cpush;
|
| 17 |
|
|
output PushOut;
|
| 18 |
|
|
|
| 19 |
|
|
/* Port list for Fifo and memory interfacing */
|
| 20 |
|
|
output inWrite, opWrite;
|
| 21 |
|
|
output [7:0] inMdin, opMdin;
|
| 22 |
|
|
output [15:0] inAddrr, inAddrw, opAddrr, opAddrw;
|
| 23 |
|
|
input [7:0] inMdout, opMdout;
|
| 24 |
|
|
|
| 25 |
|
|
/*/Variables and parameters declaration*/
|
| 26 |
|
|
/*Registers being used for CRCs*/
|
| 27 |
|
|
reg[159:0] rDataPad0;
|
| 28 |
|
|
reg[160:0] rDataPad1;
|
| 29 |
|
|
reg[161:0] rDataPad2;
|
| 30 |
|
|
reg[162:0] rDataPad3;
|
| 31 |
|
|
reg[31:0] rDataInjector;
|
| 32 |
|
|
reg[39:0] rDataPadSel;
|
| 33 |
|
|
reg[31:0] rDataCDATA;
|
| 34 |
|
|
|
| 35 |
|
|
/*Wires/Nets Representing combinational logic (XORing) - i.e. (D input to F/F)*/
|
| 36 |
|
|
wire[159:0] wXorPad0FW, wXorPad0BW, wXorPad0, wLoadPad0;
|
| 37 |
|
|
wire[160:0] wXorPad1FW, wXorPad1BW, wXorPad1, wLoadPad1;
|
| 38 |
|
|
wire[161:0] wXorPad2FW, wXorPad2BW, wXorPad2, wLoadPad2;
|
| 39 |
|
|
wire[162:0] wXorPad3FW, wXorPad3BW, wXorPad3, wLoadPad3;
|
| 40 |
|
|
wire[39:0] wXorPadSelFW, wXorPadSelBW, wXorPadSel, wLoadPadSel;
|
| 41 |
|
|
wire[31:0] wXorCDATAFW, wXorCDATABW, wXorCDATABW0, wXorCDATA; //---> Forward moving CDATA is Never been used
|
| 42 |
|
|
wire[31:0] wXorInjectorFW, wXorInjectorBW, wXorInjector, wLoadInjector; //---> Backword moving injector is Never been used
|
| 43 |
|
|
|
| 44 |
|
|
|
| 45 |
|
|
/*Control signals for controlling CRCs*/
|
| 46 |
|
|
reg rIdle, rDirection, rIdleInjector, rIdleCDATA, rIsBW;
|
| 47 |
|
|
|
| 48 |
|
|
/*Internal signals for design like PRN select lines for pad select MUX etc.*/
|
| 49 |
|
|
wire[4:0] wSelectPadBit;
|
| 50 |
|
|
wire[5:0] wPadAmount;
|
| 51 |
|
|
wire wPRN;
|
| 52 |
|
|
reg rPRN;
|
| 53 |
|
|
reg rDataOut;
|
| 54 |
|
|
/*Variables used in for loops and etc*/
|
| 55 |
|
|
integer unConfuserCnt, ipFifoLoadCnt, opFifoLoadCnt, PadCounter, injectorCounter;
|
| 56 |
|
|
reg[2:0] nextState;
|
| 57 |
|
|
reg[5:0] rPadAmount;
|
| 58 |
|
|
|
| 59 |
|
|
/*FIFO signals declaration*/
|
| 60 |
|
|
wire inPull, inEmpty, inWrite, opWrite;
|
| 61 |
|
|
wire[7:0] inDout, inMdin, inMdout;
|
| 62 |
|
|
wire[15:0] inAddrw, inAddrr;
|
| 63 |
|
|
wire opPull, opPush, opEmpty, opFull;
|
| 64 |
|
|
wire[7:0] wopDin, opMdin, opMdout;
|
| 65 |
|
|
wire[15:0] opAddrw, opAddrr;
|
| 66 |
|
|
reg[7:0] opDin;
|
| 67 |
|
|
|
| 68 |
|
|
/*Parameters representing Polynomials for all CRCs*/
|
| 69 |
|
|
|
| 70 |
|
|
/* X^160+X^139+X^119+X^98+X^79+X^40+X^20+1 -> Pad0 polynomial*/
|
| 71 |
|
|
parameter [159:0] pPolyPad0 = 160'H00000800_00800004_00008000_00000100_00100001;
|
| 72 |
|
|
|
| 73 |
|
|
/* X161+X140+X121+X100+X80+X60+X40+X20+1 -> Pad1 polynomial*/
|
| 74 |
|
|
parameter [160:0] pPolyPad1 = 161'H0_00001000_02000010_00010000_10000100_00100001;
|
| 75 |
|
|
|
| 76 |
|
|
/* X162+X141+X121+X100 +X80+X60+X40+X20+1 -> Pad2 polynomial*/
|
| 77 |
|
|
parameter [161:0] pPolyPad2 = 162'H0_00002000_02000010_00010000_10000100_00100001;
|
| 78 |
|
|
|
| 79 |
|
|
/* X163+X142+X122+X102+X82+X61+X41+X20+1 -> Pad3 polynomial*/
|
| 80 |
|
|
parameter [162:0] pPolyPad3 = 162'H0_00004000_04000040_00040000_20000200_00100001;
|
| 81 |
|
|
|
| 82 |
|
|
/* X32+X27+X21+X16+X10+X5+1 -> Injector polynomial*/
|
| 83 |
|
|
parameter [31:0] pPolyInjector = 32'H0821_0421;
|
| 84 |
|
|
|
| 85 |
|
|
/* X40+X34+X27+X19+X12+X6+1 -> PadSelect Polynomial*/
|
| 86 |
|
|
parameter [39:0] pPolyPadSel = 40'H04_0808_1041;
|
| 87 |
|
|
|
| 88 |
|
|
/* X32+X31+X29+X28+X26+X25+X24+X22+X21+X13+X11+X9+X8+X5+1 -> CRC (unConfuser) polynomial*/
|
| 89 |
|
|
parameter [31:0] pPolyCDATA = 32'HB760_2B21;
|
| 90 |
|
|
|
| 91 |
|
|
/*Parameters for State Machine*/
|
| 92 |
|
|
parameter stateReset = 3'b000;
|
| 93 |
|
|
parameter stateLoadPads = 3'b001;
|
| 94 |
|
|
parameter stateLoad = 3'b010;
|
| 95 |
|
|
parameter stateStepFW = 3'b011;
|
| 96 |
|
|
parameter stateStepBW = 3'b100;
|
| 97 |
|
|
parameter stateCDATABW = 3'b101;
|
| 98 |
|
|
parameter stateLoadOut = 3'b110;
|
| 99 |
|
|
parameter stateFinalFW = 3'b111;
|
| 100 |
|
|
|
| 101 |
|
|
/* Forward and Backward flags as parameters*/
|
| 102 |
|
|
parameter pFW = 1'b1;
|
| 103 |
|
|
parameter pBW = 1'b0;
|
| 104 |
|
|
|
| 105 |
|
|
/*Instatiate input and output fifos*/
|
| 106 |
|
|
fifooneflag ipfifo (Clk, Reset, PushIn, Din, inPull, inEmpty, inDout, inAddrw, inMdin, inWrite, inAddrr, inMdout);
|
| 107 |
|
|
assign inPull = (inEmpty == 1'b0 && nextState == stateLoad); //When CDATA is begin loaded
|
| 108 |
|
|
fifotwoflag opfifo (Clk, Reset, opPush, opFull, opDin, opPull, opEmpty, Dout, opAddrw, opMdin, opWrite, opAddrr, opMdout);
|
| 109 |
|
|
assign opPush = (opFull == 1'b0 && rDataOut == 1'b1); //when not full
|
| 110 |
|
|
assign opPull = (StopIn == 1'b0);
|
| 111 |
|
|
|
| 112 |
|
|
assign PushOut = (opEmpty == 1'b0);
|
| 113 |
|
|
assign wopDin = (opPush==1'b1 && opFifoLoadCnt==1) ? rDataCDATA[31:24] :
|
| 114 |
|
|
((opPush==1'b1 && opFifoLoadCnt==2) ? rDataCDATA[23:16] :
|
| 115 |
|
|
((opPush==1'b1 && opFifoLoadCnt==3) ? rDataCDATA[15:8] :
|
| 116 |
|
|
((opPush==1'b1 && opFifoLoadCnt==4) ? rDataCDATA[7:0] : opDin)));
|
| 117 |
|
|
|
| 118 |
|
|
/*Logic starts here*/
|
| 119 |
|
|
/*All CRC going forward :-*/
|
| 120 |
|
|
assign wXorPad0FW = {rDataPad0[158:0],1'b0} ^ (rDataPad0[159] ? pPolyPad0 : 160'h0);
|
| 121 |
|
|
assign wXorPad1FW = {rDataPad1[159:0],1'b0} ^ (rDataPad1[160] ? pPolyPad1 : 161'h0);
|
| 122 |
|
|
assign wXorPad2FW = {rDataPad2[160:0],1'b0} ^ (rDataPad2[161] ? pPolyPad2 : 162'h0);
|
| 123 |
|
|
assign wXorPad3FW = {rDataPad3[161:0],1'b0} ^ (rDataPad3[162] ? pPolyPad3 : 163'h0);
|
| 124 |
|
|
assign wXorPadSelFW = {rDataPadSel[38:0],1'b0} ^ (rDataPadSel[39]? pPolyPadSel : 40'h0);
|
| 125 |
|
|
/*CDATA will never move forward*/
|
| 126 |
|
|
assign wXorCDATAFW = {rDataCDATA[30:0],1'b0} ^ (rDataCDATA[31] ? pPolyCDATA : 32'h0);
|
| 127 |
|
|
assign wXorInjectorFW = {rDataInjector[30:0],1'b0}^ (rDataInjector[31] ? pPolyInjector : 32'h0);
|
| 128 |
|
|
|
| 129 |
|
|
/*All CRC going Backword*/
|
| 130 |
|
|
assign wXorPad0BW[158:0] = {rDataPad0[159:1]} ^ (rDataPad0[0] ? pPolyPad0[159:1] : 159'h0); assign wXorPad0BW[159] = rDataPad0[0];
|
| 131 |
|
|
assign wXorPad1BW[159:0] = {rDataPad1[160:1]} ^ (rDataPad1[0] ? pPolyPad1[160:1] : 160'h0); assign wXorPad1BW[160] = rDataPad1[0];
|
| 132 |
|
|
assign wXorPad2BW[160:0] = {rDataPad2[161:1]} ^ (rDataPad2[0] ? pPolyPad2[161:1] : 161'h0); assign wXorPad2BW[161] = rDataPad2[0];
|
| 133 |
|
|
assign wXorPad3BW[161:0] = {rDataPad3[162:1]} ^ (rDataPad3[0] ? pPolyPad3[162:1] : 162'h0); assign wXorPad3BW[162] = rDataPad3[0];
|
| 134 |
|
|
assign wXorPadSelBW[38:0] = {rDataPadSel[39:1]} ^ (rDataPadSel[0]? pPolyPadSel[39:1]: 39'h0); assign wXorPadSelBW[39]= rDataPadSel[0];
|
| 135 |
|
|
assign wXorCDATABW[30:0] = {rDataCDATA[31:1]} ^ ((rDataCDATA[0] ^ wPRN) ? pPolyCDATA[31:1] : 31'h0); assign wXorCDATABW[31] = (rDataCDATA[0] ^ wPRN); /*We need datain(wPRN) input to provide PRN from MUX*/
|
| 136 |
|
|
assign wXorCDATABW0[30:0] = {rDataCDATA[31:1]} ^ (rDataCDATA[0] ? pPolyCDATA[31:1] : 31'h0); assign wXorCDATABW0[31] = rDataCDATA[0];
|
| 137 |
|
|
/*Injector Backward never need to be used*/
|
| 138 |
|
|
assign wXorInjectorBW[30:0] = {rDataInjector[31:1]}^ (rDataInjector[0] ? pPolyInjector[31:1] : 31'h0); assign wXorInjectorBW[31] = rDataInjector[0];
|
| 139 |
|
|
|
| 140 |
|
|
/*Chosing out of Reset, Idle, Forward or Backward Condition Make RESET asynchronous*/
|
| 141 |
|
|
assign wXorPad0 = Cpush ? wLoadPad0 : (rIdle ? rDataPad0 : (rDirection ? wXorPad0FW : wXorPad0BW));
|
| 142 |
|
|
assign wXorPad1 = Cpush ? wLoadPad1 : (rIdle ? rDataPad1 : (rDirection ? wXorPad1FW : wXorPad1BW));
|
| 143 |
|
|
assign wXorPad2 = Cpush ? wLoadPad2 : (rIdle ? rDataPad2 : (rDirection ? wXorPad2FW : wXorPad2BW));
|
| 144 |
|
|
assign wXorPad3 = Cpush ? wLoadPad3 : (rIdle ? rDataPad3 : (rDirection ? wXorPad3FW : wXorPad3BW));
|
| 145 |
|
|
assign wXorPadSel = Cpush ? wLoadPadSel : (rIdle ? rDataPadSel : (rDirection ? wXorPadSelFW : wXorPadSelBW));
|
| 146 |
|
|
assign wXorCDATA = rIdleCDATA ? rDataCDATA : (rIsBW ? wXorCDATABW0 : wXorCDATABW); //Direction will always be Backward
|
| 147 |
|
|
assign wXorInjector = Cpush ? wLoadInjector : (rIdleInjector ? rDataInjector : wXorInjectorFW ); //Direction will always be Forward
|
| 148 |
|
|
|
| 149 |
|
|
/*Implementation of configuration register for loading each register*/
|
| 150 |
|
|
//loadPad0:
|
| 151 |
|
|
assign wLoadPad0 = {Caddr=='d19 ? Cdata : rDataPad0[159:152],
|
| 152 |
|
|
Caddr=='d18 ? Cdata : rDataPad0[151:144],
|
| 153 |
|
|
Caddr=='d17 ? Cdata : rDataPad0[143:136],
|
| 154 |
|
|
Caddr=='d16 ? Cdata : rDataPad0[135:128],
|
| 155 |
|
|
Caddr=='d15 ? Cdata : rDataPad0[127:120],
|
| 156 |
|
|
Caddr=='d14 ? Cdata : rDataPad0[119:112],
|
| 157 |
|
|
Caddr=='d13 ? Cdata : rDataPad0[111:104],
|
| 158 |
|
|
Caddr=='d12 ? Cdata : rDataPad0[103:96],
|
| 159 |
|
|
Caddr=='d11 ? Cdata : rDataPad0[95:88],
|
| 160 |
|
|
Caddr=='d10 ? Cdata : rDataPad0[87:80],
|
| 161 |
|
|
Caddr=='d09 ? Cdata : rDataPad0[79:72],
|
| 162 |
|
|
Caddr=='d08 ? Cdata : rDataPad0[71:64],
|
| 163 |
|
|
Caddr=='d07 ? Cdata : rDataPad0[63:56],
|
| 164 |
|
|
Caddr=='d06 ? Cdata : rDataPad0[55:48],
|
| 165 |
|
|
Caddr=='d05 ? Cdata : rDataPad0[47:40],
|
| 166 |
|
|
Caddr=='d04 ? Cdata : rDataPad0[39:32],
|
| 167 |
|
|
Caddr=='d03 ? Cdata : rDataPad0[31:24],
|
| 168 |
|
|
Caddr=='d02 ? Cdata : rDataPad0[23:16],
|
| 169 |
|
|
Caddr=='d01 ? Cdata : rDataPad0[15:08],
|
| 170 |
|
|
Caddr=='d00 ? Cdata : rDataPad0[07:00]};
|
| 171 |
|
|
|
| 172 |
|
|
//loadPad1:
|
| 173 |
|
|
assign wLoadPad1 = {Caddr=='d41 ? Cdata[0] : rDataPad1[160],
|
| 174 |
|
|
Caddr=='d40 ? Cdata : rDataPad1[159:152],
|
| 175 |
|
|
Caddr=='d39 ? Cdata : rDataPad1[151:144],
|
| 176 |
|
|
Caddr=='d38 ? Cdata : rDataPad1[143:136],
|
| 177 |
|
|
Caddr=='d37 ? Cdata : rDataPad1[135:128],
|
| 178 |
|
|
Caddr=='d36 ? Cdata : rDataPad1[127:120],
|
| 179 |
|
|
Caddr=='d35 ? Cdata : rDataPad1[119:112],
|
| 180 |
|
|
Caddr=='d34 ? Cdata : rDataPad1[111:104],
|
| 181 |
|
|
Caddr=='d33 ? Cdata : rDataPad1[103:96],
|
| 182 |
|
|
Caddr=='d32 ? Cdata : rDataPad1[95:88],
|
| 183 |
|
|
Caddr=='d31 ? Cdata : rDataPad1[87:80],
|
| 184 |
|
|
Caddr=='d30 ? Cdata : rDataPad1[79:72],
|
| 185 |
|
|
Caddr=='d29 ? Cdata : rDataPad1[71:64],
|
| 186 |
|
|
Caddr=='d28 ? Cdata : rDataPad1[63:56],
|
| 187 |
|
|
Caddr=='d27 ? Cdata : rDataPad1[55:48],
|
| 188 |
|
|
Caddr=='d26 ? Cdata : rDataPad1[47:40],
|
| 189 |
|
|
Caddr=='d25 ? Cdata : rDataPad1[39:32],
|
| 190 |
|
|
Caddr=='d24 ? Cdata : rDataPad1[31:24],
|
| 191 |
|
|
Caddr=='d23 ? Cdata : rDataPad1[23:16],
|
| 192 |
|
|
Caddr=='d22 ? Cdata : rDataPad1[15:08],
|
| 193 |
|
|
Caddr=='d21 ? Cdata : rDataPad1[07:00]};
|
| 194 |
|
|
|
| 195 |
|
|
//loadPad2:
|
| 196 |
|
|
assign wLoadPad2 = {Caddr=='d62 ? Cdata[1:0] : rDataPad2[161:160],
|
| 197 |
|
|
Caddr=='d61 ? Cdata : rDataPad2[159:152],
|
| 198 |
|
|
Caddr=='d60 ? Cdata : rDataPad2[151:144],
|
| 199 |
|
|
Caddr=='d59 ? Cdata : rDataPad2[143:136],
|
| 200 |
|
|
Caddr=='d58 ? Cdata : rDataPad2[135:128],
|
| 201 |
|
|
Caddr=='d57 ? Cdata : rDataPad2[127:120],
|
| 202 |
|
|
Caddr=='d56 ? Cdata : rDataPad2[119:112],
|
| 203 |
|
|
Caddr=='d55 ? Cdata : rDataPad2[111:104],
|
| 204 |
|
|
Caddr=='d54 ? Cdata : rDataPad2[103:96],
|
| 205 |
|
|
Caddr=='d53 ? Cdata : rDataPad2[95:88],
|
| 206 |
|
|
Caddr=='d52 ? Cdata : rDataPad2[87:80],
|
| 207 |
|
|
Caddr=='d51 ? Cdata : rDataPad2[79:72],
|
| 208 |
|
|
Caddr=='d50 ? Cdata : rDataPad2[71:64],
|
| 209 |
|
|
Caddr=='d49 ? Cdata : rDataPad2[63:56],
|
| 210 |
|
|
Caddr=='d48 ? Cdata : rDataPad2[55:48],
|
| 211 |
|
|
Caddr=='d47 ? Cdata : rDataPad2[47:40],
|
| 212 |
|
|
Caddr=='d46 ? Cdata : rDataPad2[39:32],
|
| 213 |
|
|
Caddr=='d45 ? Cdata : rDataPad2[31:24],
|
| 214 |
|
|
Caddr=='d44 ? Cdata : rDataPad2[23:16],
|
| 215 |
|
|
Caddr=='d43 ? Cdata : rDataPad2[15:08],
|
| 216 |
|
|
Caddr=='d42 ? Cdata : rDataPad2[07:00]};
|
| 217 |
|
|
|
| 218 |
|
|
//loadPad3:
|
| 219 |
|
|
assign wLoadPad3 = {Caddr=='d83 ? Cdata[2:0] : rDataPad3[162:160],
|
| 220 |
|
|
Caddr=='d82 ? Cdata : rDataPad3[159:152],
|
| 221 |
|
|
Caddr=='d81 ? Cdata : rDataPad3[151:144],
|
| 222 |
|
|
Caddr=='d80 ? Cdata : rDataPad3[143:136],
|
| 223 |
|
|
Caddr=='d79 ? Cdata : rDataPad3[135:128],
|
| 224 |
|
|
Caddr=='d78 ? Cdata : rDataPad3[127:120],
|
| 225 |
|
|
Caddr=='d77 ? Cdata : rDataPad3[119:112],
|
| 226 |
|
|
Caddr=='d76 ? Cdata : rDataPad3[111:104],
|
| 227 |
|
|
Caddr=='d75 ? Cdata : rDataPad3[103:96],
|
| 228 |
|
|
Caddr=='d74 ? Cdata : rDataPad3[95:88],
|
| 229 |
|
|
Caddr=='d73 ? Cdata : rDataPad3[87:80],
|
| 230 |
|
|
Caddr=='d72 ? Cdata : rDataPad3[79:72],
|
| 231 |
|
|
Caddr=='d71 ? Cdata : rDataPad3[71:64],
|
| 232 |
|
|
Caddr=='d70 ? Cdata : rDataPad3[63:56],
|
| 233 |
|
|
Caddr=='d69 ? Cdata : rDataPad3[55:48],
|
| 234 |
|
|
Caddr=='d68 ? Cdata : rDataPad3[47:40],
|
| 235 |
|
|
Caddr=='d67 ? Cdata : rDataPad3[39:32],
|
| 236 |
|
|
Caddr=='d66 ? Cdata : rDataPad3[31:24],
|
| 237 |
|
|
Caddr=='d65 ? Cdata : rDataPad3[23:16],
|
| 238 |
|
|
Caddr=='d64 ? Cdata : rDataPad3[15:08],
|
| 239 |
|
|
Caddr=='d63 ? Cdata : rDataPad3[07:00]};
|
| 240 |
|
|
|
| 241 |
|
|
//loadInjector:
|
| 242 |
|
|
assign wLoadInjector = {
|
| 243 |
|
|
Caddr=='d87 ? Cdata : rDataInjector[31:24],
|
| 244 |
|
|
Caddr=='d86 ? Cdata : rDataInjector[23:16],
|
| 245 |
|
|
Caddr=='d85 ? Cdata : rDataInjector[15:08],
|
| 246 |
|
|
Caddr=='d84 ? Cdata : rDataInjector[07:00]};
|
| 247 |
|
|
|
| 248 |
|
|
|
| 249 |
|
|
//loadPadSel:
|
| 250 |
|
|
assign wLoadPadSel = {
|
| 251 |
|
|
Caddr=='d92 ? Cdata : rDataPadSel[39:32],
|
| 252 |
|
|
Caddr=='d91 ? Cdata : rDataPadSel[31:24],
|
| 253 |
|
|
Caddr=='d90 ? Cdata : rDataPadSel[23:16],
|
| 254 |
|
|
Caddr=='d89 ? Cdata : rDataPadSel[15:08],
|
| 255 |
|
|
Caddr=='d88 ? Cdata : rDataPadSel[07:00]};
|
| 256 |
|
|
|
| 257 |
|
|
/*Logic for generating PRN by selcting pad values with the help of pad select*/
|
| 258 |
|
|
assign wSelectPadBit = {rDataPadSel[31], rDataPadSel[3], rDataPadSel[5], rDataPadSel[19], rDataPadSel[8]};
|
| 259 |
|
|
assign wPadAmount = {1'b1, rDataInjector[30], rDataInjector[5], rDataInjector[9], rDataInjector[2], rDataInjector[27]};
|
| 260 |
|
|
|
| 261 |
|
|
assign wPRN =
|
| 262 |
|
|
(wSelectPadBit == 5'd00) ? rDataPad1[15] :
|
| 263 |
|
|
(wSelectPadBit == 5'd01) ? rDataPad0[37] :
|
| 264 |
|
|
(wSelectPadBit == 5'd02) ? rDataPad2[73] :
|
| 265 |
|
|
(wSelectPadBit == 5'd03) ? rDataPad3[99] :
|
| 266 |
|
|
(wSelectPadBit == 5'd04) ? rDataPad0[121] :
|
| 267 |
|
|
(wSelectPadBit == 5'd05) ? rDataPad1[130] :
|
| 268 |
|
|
(wSelectPadBit == 5'd06) ? rDataPad3[15] :
|
| 269 |
|
|
(wSelectPadBit == 5'd07) ? rDataPad2[9] :
|
| 270 |
|
|
(wSelectPadBit == 5'd08) ? rDataPad3[97] :
|
| 271 |
|
|
(wSelectPadBit == 5'd09) ? rDataPad2[140] :
|
| 272 |
|
|
(wSelectPadBit == 5'd10) ? rDataPad1[4] :
|
| 273 |
|
|
(wSelectPadBit == 5'd11) ? rDataPad0[88] :
|
| 274 |
|
|
(wSelectPadBit == 5'd12) ? rDataPad0[33] :
|
| 275 |
|
|
(wSelectPadBit == 5'd13) ? rDataPad1[75] :
|
| 276 |
|
|
(wSelectPadBit == 5'd14) ? rDataPad2[35] :
|
| 277 |
|
|
(wSelectPadBit == 5'd15) ? rDataPad3[155] :
|
| 278 |
|
|
(wSelectPadBit == 5'd16) ? rDataPad2[28] :
|
| 279 |
|
|
(wSelectPadBit == 5'd17) ? rDataPad1[150] :
|
| 280 |
|
|
(wSelectPadBit == 5'd18) ? rDataPad3[29] :
|
| 281 |
|
|
(wSelectPadBit == 5'd19) ? rDataPad0[144] :
|
| 282 |
|
|
(wSelectPadBit == 5'd20) ? rDataPad0[127] :
|
| 283 |
|
|
(wSelectPadBit == 5'd21) ? rDataPad1[125] :
|
| 284 |
|
|
(wSelectPadBit == 5'd22) ? rDataPad2[0] :
|
| 285 |
|
|
(wSelectPadBit == 5'd23) ? rDataPad3[5] :
|
| 286 |
|
|
(wSelectPadBit == 5'd24) ? rDataPad0[110] :
|
| 287 |
|
|
(wSelectPadBit == 5'd25) ? rDataPad3[87] :
|
| 288 |
|
|
(wSelectPadBit == 5'd26) ? rDataPad1[19] :
|
| 289 |
|
|
(wSelectPadBit == 5'd27) ? rDataPad2[82] :
|
| 290 |
|
|
(wSelectPadBit == 5'd28) ? rDataPad0[48] :
|
| 291 |
|
|
(wSelectPadBit == 5'd29) ? rDataPad1[47] :
|
| 292 |
|
|
(wSelectPadBit == 5'd30) ? rDataPad2[46] :
|
| 293 |
|
|
rDataPad3[51];
|
| 294 |
|
|
|
| 295 |
|
|
always @(posedge Clk or posedge Reset) begin
|
| 296 |
|
|
if(Reset == 1'b1) begin
|
| 297 |
|
|
rDataPad0 <= 'b0;
|
| 298 |
|
|
rDataPad1 <= 'b0;
|
| 299 |
|
|
rDataPad2 <= 'b0;
|
| 300 |
|
|
rDataPad3 <= 'b0;
|
| 301 |
|
|
rDataPadSel <= 'b0;
|
| 302 |
|
|
rDataCDATA <= 'b0;
|
| 303 |
|
|
rDataInjector <= 'b0;
|
| 304 |
|
|
nextState <= stateReset;
|
| 305 |
|
|
end
|
| 306 |
|
|
else
|
| 307 |
|
|
begin
|
| 308 |
|
|
rDataPad0 <= wXorPad0;
|
| 309 |
|
|
rDataPad1 <= wXorPad1;
|
| 310 |
|
|
rDataPad2 <= wXorPad2;
|
| 311 |
|
|
rDataPad3 <= wXorPad3;
|
| 312 |
|
|
rDataPadSel <= wXorPadSel;
|
| 313 |
|
|
rDataCDATA <= wXorCDATA;
|
| 314 |
|
|
rDataInjector <= wXorInjector;
|
| 315 |
|
|
opDin <= wopDin;
|
| 316 |
|
|
/*State Machine code*/
|
| 317 |
|
|
|
| 318 |
|
|
case(nextState)
|
| 319 |
|
|
|
| 320 |
|
|
stateReset: begin
|
| 321 |
|
|
rIdle <= 1'b1;
|
| 322 |
|
|
rIdleInjector <= 1'b1;
|
| 323 |
|
|
rIdleCDATA <= 1'b1;
|
| 324 |
|
|
rIsBW <= 1'b0;
|
| 325 |
|
|
rDataOut <= 1'b0;
|
| 326 |
|
|
nextState <= stateLoadPads;
|
| 327 |
|
|
end
|
| 328 |
|
|
|
| 329 |
|
|
stateLoadPads: begin
|
| 330 |
|
|
rIdle <= 1'b1;
|
| 331 |
|
|
rIdleInjector <= 1'b1;
|
| 332 |
|
|
rIdleCDATA <= 1'b1;
|
| 333 |
|
|
rIsBW <= 1'b0;
|
| 334 |
|
|
if(inEmpty == 1'b1)
|
| 335 |
|
|
nextState <= stateLoadPads;
|
| 336 |
|
|
else begin
|
| 337 |
|
|
ipFifoLoadCnt = 0;
|
| 338 |
|
|
nextState <= stateLoad;
|
| 339 |
|
|
end
|
| 340 |
|
|
|
| 341 |
|
|
end
|
| 342 |
|
|
|
| 343 |
|
|
stateLoad: begin
|
| 344 |
|
|
rIdle <= 1'b1;
|
| 345 |
|
|
rIdleInjector <= 1'b1;
|
| 346 |
|
|
rIdleCDATA <= 1'b1;
|
| 347 |
|
|
rIsBW <= 1'b0;
|
| 348 |
|
|
rPadAmount <= wPadAmount;
|
| 349 |
|
|
if(inEmpty == 1'b0) begin
|
| 350 |
|
|
case(ipFifoLoadCnt)
|
| 351 |
|
|
0: rDataCDATA[31:24] <= inDout;
|
| 352 |
|
|
1: rDataCDATA[23:16] <= inDout;
|
| 353 |
|
|
2: rDataCDATA[15:8] <= inDout;
|
| 354 |
|
|
3: rDataCDATA[7:0] <= inDout;
|
| 355 |
|
|
endcase // case (ipFifoLoadCnt)
|
| 356 |
|
|
ipFifoLoadCnt = ipFifoLoadCnt+1;
|
| 357 |
|
|
end
|
| 358 |
|
|
if(ipFifoLoadCnt == 4) begin
|
| 359 |
|
|
nextState <= stateStepFW;
|
| 360 |
|
|
PadCounter = 0;
|
| 361 |
|
|
injectorCounter= 0;
|
| 362 |
|
|
rIdle <= 1'b0;
|
| 363 |
|
|
rDirection <= 1'b1;
|
| 364 |
|
|
rIdleCDATA <= 1'b1;
|
| 365 |
|
|
rIdleInjector <= 1'b0;
|
| 366 |
|
|
rIsBW <= 1'b0;
|
| 367 |
|
|
end
|
| 368 |
|
|
else
|
| 369 |
|
|
nextState <= stateLoad;
|
| 370 |
|
|
|
| 371 |
|
|
end // case: (stateLoad)
|
| 372 |
|
|
|
| 373 |
|
|
stateStepFW: begin
|
| 374 |
|
|
ipFifoLoadCnt = 0;
|
| 375 |
|
|
rIdle <= 1'b0;
|
| 376 |
|
|
rDirection <= 1'b1;
|
| 377 |
|
|
rIdleCDATA <= 1'b1;
|
| 378 |
|
|
rIsBW <= 1'b0;
|
| 379 |
|
|
unConfuserCnt = 0;
|
| 380 |
|
|
if(PadCounter == rPadAmount-1) begin
|
| 381 |
|
|
nextState <= stateStepBW;
|
| 382 |
|
|
rDirection <= 1'b0;
|
| 383 |
|
|
rIsBW <= 1'b1;
|
| 384 |
|
|
rPRN <= 1'b0;
|
| 385 |
|
|
// rIdleCDATA <= 1'b0;
|
| 386 |
|
|
PadCounter = PadCounter-1;
|
| 387 |
|
|
end
|
| 388 |
|
|
else
|
| 389 |
|
|
nextState <= stateStepFW;
|
| 390 |
|
|
if(injectorCounter >= 38) begin
|
| 391 |
|
|
rIdleInjector <= 1'b1;
|
| 392 |
|
|
end
|
| 393 |
|
|
else rIdleInjector <= 1'b0;
|
| 394 |
|
|
PadCounter = PadCounter+1;
|
| 395 |
|
|
injectorCounter= injectorCounter+1;
|
| 396 |
|
|
end // case: (stateStepFW)
|
| 397 |
|
|
|
| 398 |
|
|
stateStepBW: begin
|
| 399 |
|
|
rIdle <= 1'b0;
|
| 400 |
|
|
if(PadCounter == rPadAmount-1) begin
|
| 401 |
|
|
rIsBW <= 1'b0;
|
| 402 |
|
|
rPRN <= 1'b0;
|
| 403 |
|
|
end
|
| 404 |
|
|
else begin
|
| 405 |
|
|
rIsBW <= 1'b0;
|
| 406 |
|
|
rPRN <= wPRN;
|
| 407 |
|
|
end
|
| 408 |
|
|
if(injectorCounter >= 38) begin
|
| 409 |
|
|
rIdleInjector <= 1'b1;
|
| 410 |
|
|
//injectorCounter = injectorCounter+1;
|
| 411 |
|
|
end
|
| 412 |
|
|
else begin
|
| 413 |
|
|
rIdleInjector <= 1'b0;
|
| 414 |
|
|
injectorCounter= injectorCounter+1;
|
| 415 |
|
|
end
|
| 416 |
|
|
rDirection <= 1'b0;
|
| 417 |
|
|
rIsBW <= 1'b0;
|
| 418 |
|
|
rIdleCDATA <= 1'b0;
|
| 419 |
|
|
PadCounter = PadCounter - 1;
|
| 420 |
|
|
unConfuserCnt = unConfuserCnt+1;
|
| 421 |
|
|
if(PadCounter == -1) begin
|
| 422 |
|
|
nextState <= stateCDATABW;
|
| 423 |
|
|
opFifoLoadCnt = 0;
|
| 424 |
|
|
rIdle <= 1'b1;
|
| 425 |
|
|
rIdleInjector <= 1'b1;
|
| 426 |
|
|
rIdleCDATA <= 1'b0;
|
| 427 |
|
|
rIsBW <= 1'b0;
|
| 428 |
|
|
end
|
| 429 |
|
|
else
|
| 430 |
|
|
nextState <= stateStepBW;
|
| 431 |
|
|
end // case: (stateStepBW)
|
| 432 |
|
|
|
| 433 |
|
|
stateCDATABW: begin
|
| 434 |
|
|
rIdle <= 1'b1;
|
| 435 |
|
|
rIdleCDATA <= 1'b1;
|
| 436 |
|
|
rIdleInjector <= 1'b1;
|
| 437 |
|
|
rIsBW <= 1'b0;
|
| 438 |
|
|
nextState <= stateLoadOut;
|
| 439 |
|
|
end
|
| 440 |
|
|
|
| 441 |
|
|
stateLoadOut: begin
|
| 442 |
|
|
rIdle <= 1'b1;
|
| 443 |
|
|
rIdleCDATA <= 1'b1;
|
| 444 |
|
|
rIdleInjector <= 1'b1;
|
| 445 |
|
|
rIsBW <= 1'b0;
|
| 446 |
|
|
rDataOut <= 1'b1;
|
| 447 |
|
|
if(opFull == 1'b0)
|
| 448 |
|
|
opFifoLoadCnt = opFifoLoadCnt+1;
|
| 449 |
|
|
|
| 450 |
|
|
if(opFifoLoadCnt == 4) begin
|
| 451 |
|
|
rIdle <= 1'b0;
|
| 452 |
|
|
rDirection <= 1'b1;
|
| 453 |
|
|
PadCounter = 0;
|
| 454 |
|
|
rIdleCDATA <= 1'b1;
|
| 455 |
|
|
rIdleInjector<= 1'b1;
|
| 456 |
|
|
nextState <= stateFinalFW;
|
| 457 |
|
|
end
|
| 458 |
|
|
end // case: (stateLoadOut)
|
| 459 |
|
|
|
| 460 |
|
|
stateFinalFW: begin
|
| 461 |
|
|
rIdle <= 1'b0;
|
| 462 |
|
|
rDirection <= 1'b1;
|
| 463 |
|
|
rIdleCDATA <= 1'b1;
|
| 464 |
|
|
rIdleInjector <= 1'b1;
|
| 465 |
|
|
rDataOut <= 1'b0;
|
| 466 |
|
|
if(PadCounter == rPadAmount-2) begin
|
| 467 |
|
|
if(inEmpty == 1'b1)
|
| 468 |
|
|
nextState <= stateLoadPads;
|
| 469 |
|
|
else begin
|
| 470 |
|
|
ipFifoLoadCnt = 0;
|
| 471 |
|
|
nextState <= stateLoad; end
|
| 472 |
|
|
end
|
| 473 |
|
|
else
|
| 474 |
|
|
nextState <= stateFinalFW;
|
| 475 |
|
|
PadCounter = PadCounter+1;
|
| 476 |
|
|
end
|
| 477 |
|
|
default: $display("Wrong CHoice");
|
| 478 |
|
|
|
| 479 |
|
|
endcase // case (nextState)
|
| 480 |
|
|
end
|
| 481 |
|
|
end // always @ (posedge Clk or wReset)
|
| 482 |
|
|
endmodule
|
