| 1 |
8 |
alikat |
//--------------------------------------------------------------------------------------------------
|
| 2 |
|
|
//
|
| 3 |
|
|
// Title : AU
|
| 4 |
|
|
// Design : MicroRISCII
|
| 5 |
|
|
// Author : Ali Mashtizadeh
|
| 6 |
|
|
//
|
| 7 |
|
|
//-------------------------------------------------------------------------------------------------
|
| 8 |
|
|
`timescale 1ps / 1ps
|
| 9 |
|
|
|
| 10 |
|
|
`define ALUENABLEMUL 1
|
| 11 |
|
|
// `define ALUENABLEDIV 1
|
| 12 |
|
|
// `define ALUENABLEMOD 1
|
| 13 |
|
|
`define ALU_ADD 4'b0000
|
| 14 |
|
|
`define ALU_SUB 4'b0001
|
| 15 |
|
|
`define ALU_MUL 4'b0010
|
| 16 |
|
|
`define ALU_UMUL 4'b0011
|
| 17 |
|
|
`define ALU_DIV 4'b0100
|
| 18 |
|
|
`define ALU_UDIV 4'b0101
|
| 19 |
|
|
`define ALU_MOD 4'b0110
|
| 20 |
|
|
`define ALU_UMOD 4'b0111
|
| 21 |
|
|
`define ALU_SHR 4'b1000
|
| 22 |
|
|
`define ALU_SHL 4'b1001
|
| 23 |
|
|
`define ALU_ROR 4'b1010
|
| 24 |
|
|
`define ALU_ROL 4'b1011
|
| 25 |
|
|
`define ALU_PCNT 4'b1100
|
| 26 |
|
|
`define ALU_PCNTZ 4'b1101
|
| 27 |
|
|
`define ALU_PCNTC 4'b1110
|
| 28 |
|
|
`define ALU_RND 4'b1111
|
| 29 |
|
|
|
| 30 |
11 |
alikat |
module au(a,b,arith_op,carry,o,rndin);
|
| 31 |
8 |
alikat |
// Inputs
|
| 32 |
|
|
input [31:0] a;
|
| 33 |
|
|
wire [31:0] a;
|
| 34 |
|
|
input [31:0] b;
|
| 35 |
|
|
wire [31:0] b;
|
| 36 |
|
|
input [3:0] arith_op;
|
| 37 |
|
|
wire [3:0] arith_op;
|
| 38 |
|
|
input [31:0] rndin;
|
| 39 |
|
|
wire [31:0] rndin;
|
| 40 |
|
|
// Outputs
|
| 41 |
|
|
output [31:0] o;
|
| 42 |
|
|
reg [31:0] o;
|
| 43 |
|
|
output carry;
|
| 44 |
|
|
reg carry;
|
| 45 |
|
|
// Internal
|
| 46 |
|
|
reg [4:0] pcnt0,pcnt1; // Population Count
|
| 47 |
|
|
reg [4:0] pcntz0,pcntz1;
|
| 48 |
|
|
reg [4:0] pcntc0,pcntc1;
|
| 49 |
|
|
reg [31:0] a_inv; // Inverted A Register
|
| 50 |
|
|
reg [31:0] a_chg; // Bit Change Checking Register
|
| 51 |
|
|
reg [31:0] rnd; // Random Register
|
| 52 |
|
|
|
| 53 |
|
|
always @ (a) // Inverter
|
| 54 |
|
|
a_inv = !(a);
|
| 55 |
|
|
|
| 56 |
|
|
always @ (a) // Change Checker
|
| 57 |
|
|
begin
|
| 58 |
|
|
a_chg[31] = 1'b0;
|
| 59 |
|
|
a_chg[30] = a[31] ^^ a[30];
|
| 60 |
|
|
a_chg[29] = a[30] ^^ a[29];
|
| 61 |
|
|
a_chg[28] = a[29] ^^ a[28];
|
| 62 |
|
|
a_chg[27] = a[28] ^^ a[27];
|
| 63 |
|
|
a_chg[26] = a[27] ^^ a[26];
|
| 64 |
|
|
a_chg[25] = a[26] ^^ a[25];
|
| 65 |
|
|
a_chg[24] = a[25] ^^ a[24];
|
| 66 |
|
|
a_chg[23] = a[24] ^^ a[23];
|
| 67 |
|
|
a_chg[22] = a[23] ^^ a[22];
|
| 68 |
|
|
a_chg[21] = a[22] ^^ a[21];
|
| 69 |
|
|
a_chg[20] = a[21] ^^ a[20];
|
| 70 |
|
|
a_chg[19] = a[20] ^^ a[19];
|
| 71 |
|
|
a_chg[18] = a[19] ^^ a[18];
|
| 72 |
|
|
a_chg[17] = a[18] ^^ a[17];
|
| 73 |
|
|
a_chg[16] = a[17] ^^ a[16];
|
| 74 |
|
|
a_chg[15] = a[16] ^^ a[15];
|
| 75 |
|
|
a_chg[14] = a[15] ^^ a[14];
|
| 76 |
|
|
a_chg[13] = a[14] ^^ a[13];
|
| 77 |
|
|
a_chg[12] = a[13] ^^ a[12];
|
| 78 |
|
|
a_chg[11] = a[12] ^^ a[11];
|
| 79 |
|
|
a_chg[10] = a[11] ^^ a[10];
|
| 80 |
|
|
a_chg[9] = a[10] ^^ a[9];
|
| 81 |
|
|
a_chg[8] = a[9] ^^ a[8];
|
| 82 |
|
|
a_chg[7] = a[8] ^^ a[7];
|
| 83 |
|
|
a_chg[6] = a[7] ^^ a[6];
|
| 84 |
|
|
a_chg[5] = a[6] ^^ a[5];
|
| 85 |
|
|
a_chg[4] = a[5] ^^ a[4];
|
| 86 |
|
|
a_chg[3] = a[4] ^^ a[3];
|
| 87 |
|
|
a_chg[2] = a[3] ^^ a[2];
|
| 88 |
|
|
a_chg[1] = a[2] ^^ a[1];
|
| 89 |
|
|
a_chg[0] = a[1] ^^ a[0];
|
| 90 |
|
|
end
|
| 91 |
|
|
|
| 92 |
11 |
alikat |
// TODO: Random Number Generator
|
| 93 |
8 |
alikat |
|
| 94 |
|
|
always @ (arith_op || a || b) // Main Operation
|
| 95 |
|
|
case (arith_op)
|
| 96 |
|
|
`ALU_ADD : // Add
|
| 97 |
|
|
o = a + b;
|
| 98 |
|
|
`ALU_SUB : // Sub
|
| 99 |
|
|
o = a - b;
|
| 100 |
|
|
`ifdef ALUENABLEMUL
|
| 101 |
|
|
`ALU_MUL : // Multiply
|
| 102 |
|
|
{o[31],o[30:0]} = {(a ^^ b),(a[30:0] * b[30:0])};
|
| 103 |
|
|
`ALU_UMUL : // Multiply
|
| 104 |
|
|
o = a * b;
|
| 105 |
|
|
`endif
|
| 106 |
|
|
`ifdef ALUENABLEDIV
|
| 107 |
|
|
`ALU_DIV : // Divide
|
| 108 |
|
|
{o[31],o[30:0]} = {(a ^^ b),(a[30:0] / b[30:0])};
|
| 109 |
|
|
`ALU_UDIV : // Divide
|
| 110 |
|
|
o = a / b;
|
| 111 |
|
|
`endif
|
| 112 |
|
|
`ifdef ALUENABLEMOD
|
| 113 |
|
|
`ALU_MOD : // Modulo
|
| 114 |
|
|
{o[31],o[30:0]} = {(a ^^ b),(a[30:0] % b[30:0])};
|
| 115 |
|
|
`ALU_UMOD : // Modulo
|
| 116 |
|
|
o = a % b;
|
| 117 |
|
|
`endif
|
| 118 |
|
|
`ALU_SHR : // Shift Right
|
| 119 |
|
|
o = a >> b[4:0];
|
| 120 |
|
|
`ALU_SHL : // Shift Left
|
| 121 |
|
|
o = a << b[4:0];
|
| 122 |
|
|
`ALU_ROR : // Rotate Right ? I think this is mest up
|
| 123 |
|
|
o = (a >> b[4:0]) || (a << (5'b1-b[4:0]));
|
| 124 |
|
|
`ALU_ROL : // Rotate Left ? I think this is mest up
|
| 125 |
|
|
o = (a << b[4:0]) || (a >> (5'b1-b[4:0]));
|
| 126 |
|
|
`ALU_PCNT : // Population Count (One)
|
| 127 |
|
|
begin
|
| 128 |
|
|
pcnt0 = PopCntO4(a[31:28]) + PopCntO4(a[27:24]) + PopCntO4(a[23:20]) + PopCntO4(a[19:16]);
|
| 129 |
|
|
pcnt1 = PopCntO4(a[15:12]) + PopCntO4(a[11:8]) + PopCntO4(a[7:4]) + PopCntO4(a[3:0]);
|
| 130 |
|
|
o = pcnt0 + pcnt1;
|
| 131 |
|
|
end
|
| 132 |
|
|
`ALU_PCNTZ : // Population Count (Zero)
|
| 133 |
|
|
begin
|
| 134 |
|
|
pcntz0 = PopCntO4(a_inv[31:28]) + PopCntO4(a_inv[27:24]) + PopCntO4(a_inv[23:20]) + PopCntO4(a_inv[19:16]);
|
| 135 |
|
|
pcntz1 = PopCntO4(a_inv[15:12]) + PopCntO4(a_inv[11:8]) + PopCntO4(a_inv[7:4]) + PopCntO4(a_inv[3:0]);
|
| 136 |
|
|
o = pcntz0 + pcntz1;
|
| 137 |
|
|
end
|
| 138 |
|
|
`ALU_PCNTC : // Population Count (Change)
|
| 139 |
|
|
begin
|
| 140 |
|
|
pcntc0 = PopCntO4(a_chg[31:28]) + PopCntO4(a_chg[27:24]) + PopCntO4(a_chg[23:20]) + PopCntO4(a_chg[19:16]);
|
| 141 |
|
|
pcntc1 = PopCntO4(a_chg[15:12]) + PopCntO4(a_chg[11:8]) + PopCntO4(a_chg[7:4]) + PopCntO4(a_chg[3:0]);
|
| 142 |
|
|
o = pcntc0 + pcntc1;
|
| 143 |
|
|
end
|
| 144 |
|
|
`ALU_RND : // Random
|
| 145 |
|
|
o = rnd;
|
| 146 |
|
|
endcase
|
| 147 |
|
|
|
| 148 |
|
|
function [5:0] PopCntO4; // One Count
|
| 149 |
|
|
input [3:0] x;
|
| 150 |
|
|
begin
|
| 151 |
|
|
PopCntO4[5:3] = 3'b000;
|
| 152 |
|
|
PopCntO4[2] = x[0] && x[1] && x[2] && x[3];
|
| 153 |
|
|
PopCntO4[1] = (((x[0] ^^ x[1]) && (x[2] ^^ x[3])) || ((x[0] && x[1]) ^^ (x[2] && x[3])));
|
| 154 |
|
|
PopCntO4[0] = (((x[0] ^^ x[1]) && !(x[2] ^^ x[3])) || (!(x[0] ^^ x[1]) && (x[2] ^^ x[3])));
|
| 155 |
|
|
end
|
| 156 |
|
|
endfunction
|
| 157 |
|
|
endmodule
|
