URL
https://opencores.org/ocsvn/amber/amber/trunk
Subversion Repositories amber
Compare Revisions
- This comparison shows the changes necessary to convert path
/amber/trunk/hw/vlog/amber23
- from Rev 88 to Rev 89
- ↔ Reverse comparison
Rev 88 → Rev 89
/a23_decode.v
52,7 → 52,7
input i_iabt, // instruction pre-fetch abort flag |
input i_adex, // Address Exception |
input [31:0] i_execute_address, // Registered address output by execute stage |
// 2 LSBs of read address used for calculating |
// 2 LSBs of read address used for calculating |
// shift in LDRB ops |
input [7:0] i_abt_status, // Abort status |
input [31:0] i_execute_status_bits, // current status bits values in execute stage |
68,13 → 68,13
output reg [31:0] o_imm32 = 'd0, |
output reg [4:0] o_imm_shift_amount = 'd0, |
output reg o_shift_imm_zero = 'd0, |
output reg [3:0] o_condition = 4'he, // 4'he = al |
output wire [3:0] o_condition, |
output reg o_exclusive_exec = 'd0, // exclusive access request ( swap instruction ) |
output reg o_data_access_exec = 'd0, // high means the memory access is a read |
output reg o_data_access_exec = 'd0, // high means the memory access is a read |
// read or write, low for instruction |
output reg [1:0] o_status_bits_mode = 2'b11, // SVC |
output reg o_status_bits_irq_mask = 1'd1, |
output reg o_status_bits_firq_mask = 1'd1, |
output wire [1:0] o_status_bits_mode, |
output wire o_status_bits_irq_mask, |
output wire o_status_bits_firq_mask, |
|
output reg [3:0] o_rm_sel = 'd0, |
output reg [3:0] o_rds_sel = 'd0, |
89,8 → 89,8
output reg o_use_carry_in = 'd0, |
output reg [1:0] o_multiply_function = 'd0, |
output reg [2:0] o_interrupt_vector_sel = 'd0, |
output reg [3:0] o_address_sel = 4'd2, |
output reg [1:0] o_pc_sel = 2'd2, |
output wire [3:0] o_address_sel, |
output wire [1:0] o_pc_sel, |
output reg [1:0] o_byte_enable_sel = 'd0, // byte, halfword or word write |
output reg [2:0] o_status_bits_sel = 'd0, |
output reg [2:0] o_reg_write_sel, |
101,7 → 101,7
output reg o_write_data_wen = 'd0, |
output reg o_base_address_wen = 'd0, // save LDM base address register |
// in case of data abort |
output reg o_pc_wen = 1'd1, |
output wire o_pc_wen, |
output reg [14:0] o_reg_bank_wen = 'd0, |
output reg [3:0] o_reg_bank_wsel = 'd0, |
output reg o_status_bits_flags_wen = 'd0, |
114,10 → 114,10
// -------------------------------------------------- |
output reg [2:0] o_copro_opcode1 = 'd0, |
output reg [2:0] o_copro_opcode2 = 'd0, |
output reg [3:0] o_copro_crn = 'd0, |
output reg [3:0] o_copro_crn = 'd0, |
output reg [3:0] o_copro_crm = 'd0, |
output reg [3:0] o_copro_num = 'd0, |
output reg [1:0] o_copro_operation = 'd0, // 0 = no operation, |
output reg [1:0] o_copro_operation = 'd0, // 0 = no operation, |
// 1 = Move to Amber Core Register from Coprocessor |
// 2 = Move to Coprocessor from Amber Core Register |
output reg o_copro_write_data_wen = 'd0, |
126,7 → 126,7
output [7:0] o_iabt_status, |
output o_dabt_trigger, |
output [31:0] o_dabt_address, |
output [7:0] o_dabt_status |
output [7:0] o_dabt_status |
|
|
); |
161,8 → 161,8
SWAP_WAIT1 = 5'd23, |
SWAP_WAIT2 = 5'd24, |
COPRO_WAIT = 5'd25; |
|
|
|
|
// ======================================================== |
// Internal signals |
// ======================================================== |
169,7 → 169,7
wire [31:0] instruction; |
wire instruction_iabt; // abort flag, follows the instruction |
wire instruction_adex; // address exception flag, follows the instruction |
wire [31:0] instruction_address; // instruction virtual address, follows |
wire [31:0] instruction_address; // instruction virtual address, follows |
// the instruction |
wire [7:0] instruction_iabt_status; // abort status, follows the instruction |
wire [1:0] instruction_sel; |
292,10 → 292,31
|
|
// ======================================================== |
// registers for output ports with non-zero initial values |
// ======================================================== |
reg [3:0] condition_r = 4'he; // 4'he = al |
reg [1:0] status_bits_mode_r = 2'b11; // SVC |
reg status_bits_irq_mask_r = 1'd1; |
reg status_bits_firq_mask_r = 1'd1; |
reg [3:0] address_sel_r = 4'd2; |
reg [1:0] pc_sel_r = 2'd2; |
reg pc_wen_r = 1'd1; |
|
assign o_condition = condition_r; |
assign o_status_bits_mode = status_bits_mode_r; |
assign o_status_bits_irq_mask = status_bits_irq_mask_r; |
assign o_status_bits_firq_mask = status_bits_firq_mask_r; |
assign o_address_sel = address_sel_r; |
assign o_pc_sel = pc_sel_r; |
assign o_pc_wen = pc_wen_r; |
|
|
|
// ======================================================== |
// Instruction Abort and Data Abort outputs |
// ======================================================== |
|
assign o_iabt_trigger = instruction_iabt && o_status_bits_mode == SVC && control_state == INT_WAIT1; |
assign o_iabt_trigger = instruction_iabt && status_bits_mode_r == SVC && control_state == INT_WAIT1; |
assign o_iabt_address = instruction_address; |
assign o_iabt_status = instruction_iabt_status; |
|
319,7 → 340,7
( control_state == MEM_WAIT1 || |
control_state == MEM_WAIT2 || |
control_state == MTRANS_EXEC1 || |
control_state == MTRANS_EXEC2 || |
control_state == MTRANS_EXEC2 || |
control_state == MTRANS_EXEC3 || |
control_state == MTRANS_EXEC3B || |
control_state == MTRANS_EXEC4 || |
338,9 → 359,9
assign use_pre_fetch_instruction = control_state == PRE_FETCH_EXEC; |
|
|
assign instruction_sel = use_saved_current_instruction ? 2'd1 : // saved_current_instruction |
use_pre_fetch_instruction ? 2'd2 : // pre_fetch_instruction |
2'd0 ; // o_read_data |
assign instruction_sel = use_saved_current_instruction ? 2'd1 : // saved_current_instruction |
use_pre_fetch_instruction ? 2'd2 : // pre_fetch_instruction |
2'd0 ; // o_read_data |
|
assign instruction = instruction_sel == 2'd0 ? o_read_data : |
instruction_sel == 2'd1 ? saved_current_instruction : |
350,7 → 371,7
assign instruction_iabt = instruction_sel == 2'd0 ? iabt_reg : |
instruction_sel == 2'd1 ? saved_current_instruction_iabt : |
pre_fetch_instruction_iabt ; |
|
|
assign instruction_address = instruction_sel == 2'd0 ? abt_address_reg : |
instruction_sel == 2'd1 ? saved_current_instruction_address : |
pre_fetch_instruction_address ; |
370,25 → 391,25
12'b00010?001001 : itype = SWAP; |
12'b000000??1001 : itype = MULT; |
12'b00?????????? : itype = REGOP; |
12'b01?????????? : itype = TRANS; |
12'b100????????? : itype = MTRANS; |
12'b101????????? : itype = BRANCH; |
12'b01?????????? : itype = TRANS; |
12'b100????????? : itype = MTRANS; |
12'b101????????? : itype = BRANCH; |
12'b110????????? : itype = CODTRANS; |
12'b1110???????0 : itype = COREGOP; |
12'b1110???????1 : itype = CORTRANS; |
12'b1110???????0 : itype = COREGOP; |
12'b1110???????1 : itype = CORTRANS; |
default: itype = SWI; |
endcase |
|
|
|
// ======================================================== |
// Fixed fields within the instruction |
// ======================================================== |
|
|
assign opcode = instruction[24:21]; |
assign condition_nxt = instruction[31:28]; |
|
assign o_rm_sel_nxt = instruction[3:0]; |
|
|
assign o_rn_sel_nxt = branch ? 4'd15 : // Use PC to calculate branch destination |
instruction[19:16] ; |
|
395,10 → 416,10
assign o_rds_sel_nxt = control_state == SWAP_WRITE ? instruction[3:0] : // Rm gets written out to memory |
itype == MTRANS ? mtrans_reg : |
branch ? 4'd15 : // Update the PC |
rds_use_rs ? instruction[11:8] : |
rds_use_rs ? instruction[11:8] : |
instruction[15:12] ; |
|
|
|
assign shift_imm = instruction[11:7]; |
|
// this is used for RRX |
410,23 → 431,23
|
assign immediate_shifter_operand = instruction[25]; |
assign rds_use_rs = (itype == REGOP && !instruction[25] && instruction[4]) || |
(itype == MULT && |
(control_state == MULT_PROC1 || |
(itype == MULT && |
(control_state == MULT_PROC1 || |
control_state == MULT_PROC2 || |
instruction_valid && !interrupt )) ; |
assign branch = itype == BRANCH; |
assign opcode_compare = |
opcode == CMP || |
opcode == CMN || |
opcode == TEQ || |
opcode == CMP || |
opcode == CMN || |
opcode == TEQ || |
opcode == TST ; |
|
|
|
|
assign mem_op = itype == TRANS; |
assign load_op = mem_op && instruction[20]; |
assign store_op = mem_op && !instruction[20]; |
assign write_pc = pc_wen_nxt && pc_sel_nxt != 2'd0; |
assign regop_set_flags = itype == REGOP && instruction[20]; |
assign regop_set_flags = itype == REGOP && instruction[20]; |
|
assign mem_op_pre_indexed = instruction[24] && instruction[21]; |
assign mem_op_post_indexed = !instruction[24]; |
433,7 → 454,7
|
assign imm32_nxt = // add 0 to Rm |
itype == MULT ? { 32'd0 } : |
|
|
// 4 x number of registers |
itype == MTRANS ? { mtrans_base_reg_change } : |
itype == BRANCH ? { offset24 } : |
458,25 → 479,25
|
assign imm_shift_amount_nxt = shift_imm ; |
|
// This signal is encoded in the decode stage because |
// This signal is encoded in the decode stage because |
// it is on the critical path in the execute stage |
assign shift_imm_zero_nxt = imm_shift_amount_nxt == 5'd0 && // immediate amount = 0 |
barrel_shift_amount_sel_nxt == 2'd2; // shift immediate amount |
|
assign alu_function_nxt = { alu_swap_sel_nxt, |
alu_not_sel_nxt, |
assign alu_function_nxt = { alu_swap_sel_nxt, |
alu_not_sel_nxt, |
alu_cin_sel_nxt, |
alu_cout_sel_nxt, |
alu_cout_sel_nxt, |
alu_out_sel_nxt }; |
|
|
|
|
// ======================================================== |
// MTRANS Operations |
// ======================================================== |
|
|
// Bit 15 = r15 |
// Bit 0 = R0 |
// In LDM and STM instructions R0 is loaded or stored first |
// In LDM and STM instructions R0 is loaded or stored first |
always @* |
casez (instruction[15:0]) |
16'b???????????????1 : mtrans_reg = 4'h0 ; |
501,28 → 522,28
always @* |
casez (instruction[15:0]) |
16'b???????????????1 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 1], 1'd0}; |
16'b??????????????10 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 2], 2'd0}; |
16'b?????????????100 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 3], 3'd0}; |
16'b????????????1000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 4], 4'd0}; |
16'b???????????10000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 5], 5'd0}; |
16'b??????????100000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 6], 6'd0}; |
16'b?????????1000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 7], 7'd0}; |
16'b????????10000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 8], 8'd0}; |
16'b???????100000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 9], 9'd0}; |
16'b??????1000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:10], 10'd0}; |
16'b?????10000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:11], 11'd0}; |
16'b????100000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:12], 12'd0}; |
16'b???1000000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:13], 13'd0}; |
16'b??10000000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:14], 14'd0}; |
16'b?100000000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15 ], 15'd0}; |
default : mtrans_instruction_nxt = {instruction[31:16], 16'd0}; |
16'b??????????????10 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 2], 2'd0}; |
16'b?????????????100 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 3], 3'd0}; |
16'b????????????1000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 4], 4'd0}; |
16'b???????????10000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 5], 5'd0}; |
16'b??????????100000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 6], 6'd0}; |
16'b?????????1000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 7], 7'd0}; |
16'b????????10000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 8], 8'd0}; |
16'b???????100000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15: 9], 9'd0}; |
16'b??????1000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:10], 10'd0}; |
16'b?????10000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:11], 11'd0}; |
16'b????100000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:12], 12'd0}; |
16'b???1000000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:13], 13'd0}; |
16'b??10000000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15:14], 14'd0}; |
16'b?100000000000000 : mtrans_instruction_nxt = {instruction[31:16], instruction[15 ], 15'd0}; |
default : mtrans_instruction_nxt = {instruction[31:16], 16'd0}; |
endcase |
|
|
// number of registers to be stored |
assign mtrans_num_registers = {4'd0, instruction[15]} + |
{4'd0, instruction[14]} + |
{4'd0, instruction[13]} + |
assign mtrans_num_registers = {4'd0, instruction[15]} + |
{4'd0, instruction[14]} + |
{4'd0, instruction[13]} + |
{4'd0, instruction[12]} + |
{4'd0, instruction[11]} + |
{4'd0, instruction[10]} + |
536,7 → 557,7
{4'd0, instruction[ 2]} + |
{4'd0, instruction[ 1]} + |
{4'd0, instruction[ 0]} ; |
|
|
// 4 x number of registers to be stored |
assign mtrans_base_reg_change = {25'd0, mtrans_num_registers, 2'd0}; |
|
550,15 → 571,15
assign dabt_request = dabt_reg; |
|
// copro15 and copro13 only supports reg trans opcodes |
// all other opcodes involving co-processors cause an |
// all other opcodes involving co-processors cause an |
// undefined instrution interrupt |
assign und_request = itype == CODTRANS || |
itype == COREGOP || |
assign und_request = itype == CODTRANS || |
itype == COREGOP || |
( itype == CORTRANS && instruction[11:8] != 4'd15 ); |
|
|
// in order of priority !! |
// Highest |
// in order of priority !! |
// Highest |
// 1 Reset |
// 2 Data Abort (including data TLB miss) |
// 3 FIRQ |
565,21 → 586,21
// 4 IRQ |
// 5 Prefetch Abort (including prefetch TLB miss) |
// 6 Undefined instruction, SWI |
// Lowest |
// Lowest |
assign next_interrupt = dabt_request ? 3'd1 : // Data Abort |
firq_request ? 3'd2 : // FIRQ |
irq_request ? 3'd3 : // IRQ |
instruction_adex ? 3'd4 : // Address Exception |
instruction_iabt ? 3'd5 : // PreFetch Abort, only triggered |
instruction_adex ? 3'd4 : // Address Exception |
instruction_iabt ? 3'd5 : // PreFetch Abort, only triggered |
// if the instruction is used |
und_request ? 3'd6 : // Undefined Instruction |
swi_request ? 3'd7 : // SWI |
3'd0 ; // none |
3'd0 ; // none |
|
// SWI and undefined instructions do not cause an interrupt in the decode |
// stage. They only trigger interrupts if they arfe executed, so the |
// interrupt is triggered if the execute condition is met in the execute stage |
assign interrupt = next_interrupt != 3'd0 && |
assign interrupt = next_interrupt != 3'd0 && |
next_interrupt != 3'd7 && // SWI |
next_interrupt != 3'd6 ; // undefined interrupt |
|
604,18 → 625,18
// default mode |
status_bits_mode_nxt = i_execute_status_bits[1:0]; // change to mode in execute stage get reflected |
// back to this stage automatically |
status_bits_irq_mask_nxt = o_status_bits_irq_mask; |
status_bits_firq_mask_nxt = o_status_bits_firq_mask; |
status_bits_irq_mask_nxt = status_bits_irq_mask_r; |
status_bits_firq_mask_nxt = status_bits_firq_mask_r; |
exclusive_exec_nxt = 1'd0; |
data_access_exec_nxt = 1'd0; |
copro_operation_nxt = 'd0; |
|
|
// Save an instruction to use later |
saved_current_instruction_wen = 1'd0; |
pre_fetch_instruction_wen = 1'd0; |
mtrans_r15_nxt = mtrans_r15; |
restore_base_address_nxt = restore_base_address; |
|
|
// default Mux Select values |
barrel_shift_amount_sel_nxt = 'd0; // don't shift the input |
barrel_shift_data_sel_nxt = 'd0; // immediate value |
622,21 → 643,21
barrel_shift_function_nxt = 'd0; |
use_carry_in_nxt = 'd0; |
multiply_function_nxt = 'd0; |
address_sel_nxt = 'd0; |
pc_sel_nxt = 'd0; |
byte_enable_sel_nxt = 'd0; |
status_bits_sel_nxt = 'd0; |
reg_write_sel_nxt = 'd0; |
address_sel_nxt = 'd0; |
pc_sel_nxt = 'd0; |
byte_enable_sel_nxt = 'd0; |
status_bits_sel_nxt = 'd0; |
reg_write_sel_nxt = 'd0; |
user_mode_regs_load_nxt = 'd0; |
o_user_mode_regs_store_nxt = 'd0; |
|
o_user_mode_regs_store_nxt = 'd0; |
|
// ALU Muxes |
alu_swap_sel_nxt = 'd0; |
alu_not_sel_nxt = 'd0; |
alu_cin_sel_nxt = 'd0; |
alu_cout_sel_nxt = 'd0; |
alu_out_sel_nxt = 'd0; |
|
alu_swap_sel_nxt = 'd0; |
alu_not_sel_nxt = 'd0; |
alu_cin_sel_nxt = 'd0; |
alu_cout_sel_nxt = 'd0; |
alu_out_sel_nxt = 'd0; |
|
// default Flop Write Enable values |
write_data_wen_nxt = 'd0; |
copro_write_data_wen_nxt = 'd0; |
647,7 → 668,7
status_bits_mode_wen_nxt = 'd0; |
status_bits_irq_mask_wen_nxt = 'd0; |
status_bits_firq_mask_wen_nxt = 'd0; |
|
|
if ( instruction_valid && !interrupt ) |
begin |
if ( itype == REGOP ) |
660,24 → 681,24
pc_sel_nxt = 2'd1; // alu_out |
address_sel_nxt = 4'd1; // alu_out |
end |
else |
else |
reg_bank_wsel_nxt = instruction[15:12]; |
end |
|
|
if ( !immediate_shifter_operand ) |
barrel_shift_function_nxt = instruction[6:5]; |
|
|
if ( !immediate_shifter_operand ) |
barrel_shift_data_sel_nxt = 2'd2; // Shift value from Rm register |
|
|
if ( !immediate_shifter_operand && instruction[4] ) |
barrel_shift_amount_sel_nxt = 2'd1; // Shift amount from Rs registter |
|
if ( !immediate_shifter_operand && !instruction[4] ) |
barrel_shift_amount_sel_nxt = 2'd2; // Shift immediate amount |
|
|
if ( !immediate_shifter_operand && !instruction[4] ) |
barrel_shift_amount_sel_nxt = 2'd2; // Shift immediate amount |
|
// regops that do not change the overflow flag |
if ( opcode == AND || opcode == EOR || opcode == TST || opcode == TEQ || |
if ( opcode == AND || opcode == EOR || opcode == TST || opcode == TEQ || |
opcode == ORR || opcode == MOV || opcode == BIC || opcode == MVN ) |
status_bits_sel_nxt = 3'd5; |
|
686,7 → 707,7
alu_out_sel_nxt = 4'd1; // Add |
use_carry_in_nxt = shift_extend; |
end |
|
|
if ( opcode == ADC ) // Add with Carry |
begin |
alu_out_sel_nxt = 4'd1; // Add |
693,7 → 714,7
alu_cin_sel_nxt = 2'd2; // carry in from status_bits |
use_carry_in_nxt = shift_extend; |
end |
|
|
if ( opcode == SUB || opcode == CMP ) // Subtract |
begin |
alu_out_sel_nxt = 4'd1; // Add |
700,8 → 721,8
alu_cin_sel_nxt = 2'd1; // cin = 1 |
alu_not_sel_nxt = 1'd1; // invert B |
end |
|
// SBC (Subtract with Carry) subtracts the value of its |
|
// SBC (Subtract with Carry) subtracts the value of its |
// second operand and the value of NOT(Carry flag) from |
// the value of its first operand. |
// Rd = Rn - shifter_operand - NOT(C Flag) |
712,7 → 733,7
alu_not_sel_nxt = 1'd1; // invert B |
use_carry_in_nxt = 1'd1; |
end |
|
|
if ( opcode == RSB ) // Reverse Subtract |
begin |
alu_out_sel_nxt = 4'd1; // Add |
720,7 → 741,7
alu_not_sel_nxt = 1'd1; // invert B |
alu_swap_sel_nxt = 1'd1; // swap A and B |
end |
|
|
if ( opcode == RSC ) // Reverse Subtract with carry |
begin |
alu_out_sel_nxt = 4'd1; // Add |
729,13 → 750,13
alu_swap_sel_nxt = 1'd1; // swap A and B |
use_carry_in_nxt = 1'd1; |
end |
|
|
if ( opcode == AND || opcode == TST ) // Logical AND, Test (using AND operator) |
begin |
alu_out_sel_nxt = 4'd8; // AND |
alu_cout_sel_nxt = 1'd1; // i_barrel_shift_carry |
end |
|
|
if ( opcode == EOR || opcode == TEQ ) // Logical Exclusive OR, Test Equivalence (using EOR operator) |
begin |
alu_out_sel_nxt = 4'd6; // XOR |
749,7 → 770,7
alu_cout_sel_nxt = 1'd1; // i_barrel_shift_carry |
use_carry_in_nxt = 1'd1; |
end |
|
|
if ( opcode == BIC ) // Bit Clear (using AND & NOT operators) |
begin |
alu_out_sel_nxt = 4'd8; // AND |
757,13 → 778,13
alu_cout_sel_nxt = 1'd1; // i_barrel_shift_carry |
use_carry_in_nxt = 1'd1; |
end |
|
|
if ( opcode == MOV ) // Move |
begin |
alu_cout_sel_nxt = 1'd1; // i_barrel_shift_carry |
use_carry_in_nxt = 1'd1; |
end |
|
|
if ( opcode == MVN ) // Move NOT |
begin |
alu_not_sel_nxt = 1'd1; // invert B |
771,22 → 792,22
use_carry_in_nxt = 1'd1; |
end |
end |
|
|
// Load & Store instructions |
if ( mem_op ) |
begin |
saved_current_instruction_wen = 1'd1; // Save the memory access instruction to refer back to later |
pc_wen_nxt = 1'd0; // hold current PC value |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
// rather than an instruction fetch |
alu_out_sel_nxt = 4'd1; // Add |
|
|
if ( !instruction[23] ) // U: Subtract offset |
begin |
alu_cin_sel_nxt = 2'd1; // cin = 1 |
alu_not_sel_nxt = 1'd1; // invert B |
end |
|
|
if ( store_op ) |
begin |
write_data_wen_nxt = 1'd1; |
793,7 → 814,7
if ( itype == TRANS && instruction[22] ) |
byte_enable_sel_nxt = 2'd1; // Save byte |
end |
|
|
// need to update the register holding the address ? |
// This is Rn bits [19:16] |
if ( mem_op_pre_indexed || mem_op_post_indexed ) |
800,33 → 821,33
begin |
// Check is the load destination is the PC |
if ( o_rn_sel_nxt == 4'd15 ) |
pc_sel_nxt = 2'd1; |
else |
pc_sel_nxt = 2'd1; |
else |
reg_bank_wsel_nxt = o_rn_sel_nxt; |
end |
|
|
// if post-indexed, then use Rn rather than ALU output, as address |
if ( mem_op_post_indexed ) |
address_sel_nxt = 4'd4; // Rn |
else |
else |
address_sel_nxt = 4'd1; // alu out |
|
|
if ( instruction[25] && itype == TRANS ) |
barrel_shift_data_sel_nxt = 2'd2; // Shift value from Rm register |
|
if ( itype == TRANS && instruction[25] && shift_imm != 5'd0 ) |
begin |
|
if ( itype == TRANS && instruction[25] && shift_imm != 5'd0 ) |
begin |
barrel_shift_function_nxt = instruction[6:5]; |
barrel_shift_amount_sel_nxt = 2'd2; // imm_shift_amount |
end |
end |
|
|
if ( itype == BRANCH ) |
begin |
pc_sel_nxt = 2'd1; // alu_out |
address_sel_nxt = 4'd1; // alu_out |
alu_out_sel_nxt = 4'd1; // Add |
|
|
if ( instruction[24] ) // Link |
begin |
reg_bank_wsel_nxt = 4'd14; // Save PC to LR |
833,23 → 854,23
reg_write_sel_nxt = 3'd1; // pc - 32'd4 |
end |
end |
|
|
if ( itype == MTRANS ) |
begin |
saved_current_instruction_wen = 1'd1; // Save the memory access instruction to refer back to later |
pc_wen_nxt = 1'd0; // hold current PC value |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
// rather than an instruction fetch |
alu_out_sel_nxt = 4'd1; // Add |
mtrans_r15_nxt = instruction[15]; // load or save r15 ? |
base_address_wen_nxt = 1'd1; // Save the value of the register used for the base address, |
// in case of a data abort, and need to restore the value |
// in case of a data abort, and need to restore the value |
|
// The spec says - |
// If the instruction would have overwritten the base with data |
// If the instruction would have overwritten the base with data |
// (that is, it has the base in the transfer list), the overwriting is prevented. |
// This is true even when the abort occurs after the base word gets loaded |
restore_base_address_nxt = instruction[20] && |
restore_base_address_nxt = instruction[20] && |
(instruction[15:0] & (1'd1 << instruction[19:16])); |
|
// Increment or Decrement |
857,7 → 878,7
begin |
if ( instruction[24] ) // increment before |
address_sel_nxt = 4'd7; // Rn + 4 |
else |
else |
address_sel_nxt = 4'd4; // Rn |
end |
else // decrement |
869,47 → 890,47
else |
address_sel_nxt = 4'd1; // alu out |
end |
|
|
// Load or store ? |
if ( !instruction[20] ) // Store |
write_data_wen_nxt = 1'd1; |
|
// LDM: load into user mode registers, when in priviledged mode |
// Don't use mtrans_r15 here because its not loaded yet |
write_data_wen_nxt = 1'd1; |
|
// LDM: load into user mode registers, when in priviledged mode |
// Don't use mtrans_r15 here because its not loaded yet |
//if ( {instruction[22],instruction[20],instruction[15]} == 3'b110 ) |
if ( {instruction[22:20],instruction[15]} == 4'b1010 ) |
if ( {instruction[22:20],instruction[15]} == 4'b1010 ) |
user_mode_regs_load_nxt = 1'd1; |
|
// SDM: store the user mode registers, when in priviledged mode |
//if ( {instruction[22],instruction[20]} == 3'b10 ) |
// SDM: store the user mode registers, when in priviledged mode |
//if ( {instruction[22],instruction[20]} == 3'b10 ) |
if ( {instruction[22:20]} == 3'b100 ) |
o_user_mode_regs_store_nxt = 1'd1; |
|
|
// update the base register ? |
if ( instruction[21] ) // the W bit |
reg_bank_wsel_nxt = o_rn_sel_nxt; |
end |
|
|
|
|
if ( itype == MULT ) |
begin |
multiply_function_nxt[0] = 1'd1; // set enable |
// some bits can be changed just below |
saved_current_instruction_wen = 1'd1; // Save the Multiply instruction to |
saved_current_instruction_wen = 1'd1; // Save the Multiply instruction to |
// refer back to later |
pc_wen_nxt = 1'd0; // hold current PC value |
|
|
if ( instruction[21] ) |
multiply_function_nxt[1] = 1'd1; // accumulate |
end |
|
|
|
|
// swp - do read part first |
if ( itype == SWAP ) |
begin |
saved_current_instruction_wen = 1'd1; // Save the memory access instruction to refer back to later |
pc_wen_nxt = 1'd0; // hold current PC value |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
// rather than an instruction fetch |
barrel_shift_data_sel_nxt = 2'd2; // Shift value from Rm register |
address_sel_nxt = 4'd4; // Rn |
923,7 → 944,7
saved_current_instruction_wen = 1'd1; // Save the memory access instruction to refer back to later |
pc_wen_nxt = 1'd0; // hold current PC value |
address_sel_nxt = 4'd3; // pc (not pc + 4) |
|
|
if ( instruction[20] ) // MRC |
copro_operation_nxt = 2'd1; // Register transfer from Co-Processor |
else // MCR |
935,35 → 956,35
end |
end |
|
|
|
if ( itype == SWI || und_request ) |
begin |
// save address of next instruction to Supervisor Mode LR |
reg_write_sel_nxt = 3'd1; // pc -4 |
reg_bank_wsel_nxt = 4'd14; // LR |
|
|
address_sel_nxt = 4'd2; // interrupt_vector |
pc_sel_nxt = 2'd2; // interrupt_vector |
|
|
status_bits_mode_nxt = interrupt_mode; // e.g. Supervisor mode |
status_bits_mode_wen_nxt = 1'd1; |
|
|
// disable normal interrupts |
status_bits_irq_mask_nxt = 1'd1; |
status_bits_irq_mask_wen_nxt = 1'd1; |
end |
|
|
|
if ( regop_set_flags ) |
begin |
status_bits_flags_wen_nxt = 1'd1; |
|
// If <Rd> is r15, the ALU output is copied to the Status Bits. |
// Not allowed to use r15 for mul or lma instructions |
|
// If <Rd> is r15, the ALU output is copied to the Status Bits. |
// Not allowed to use r15 for mul or lma instructions |
if ( instruction[15:12] == 4'd15 ) |
begin |
status_bits_sel_nxt = 3'd1; // alu out |
|
|
// Priviledged mode? Then also update the other status bits |
if ( i_execute_status_bits[1:0] != USR ) |
begin |
973,9 → 994,9
end |
end |
end |
|
end |
|
end |
|
// Handle asynchronous interrupts. |
// interrupts are processed only during execution states |
// multicycle instructions must complete before the interrupt starts |
987,8 → 1008,8
// Save the interrupt causing instruction to refer back to later |
// This also saves the instruction abort vma and status, in the case of an |
// instruction abort interrupt |
saved_current_instruction_wen = 1'd1; |
|
saved_current_instruction_wen = 1'd1; |
|
// save address of next instruction to Supervisor Mode LR |
// Address Exception ? |
if ( next_interrupt == 3'd4 ) |
995,15 → 1016,15
reg_write_sel_nxt = 3'd7; // pc |
else |
reg_write_sel_nxt = 3'd1; // pc -4 |
|
|
reg_bank_wsel_nxt = 4'd14; // LR |
|
|
address_sel_nxt = 4'd2; // interrupt_vector |
pc_sel_nxt = 2'd2; // interrupt_vector |
|
|
status_bits_mode_nxt = interrupt_mode; // e.g. Supervisor mode |
status_bits_mode_wen_nxt = 1'd1; |
|
|
// disable normal interrupts |
status_bits_irq_mask_nxt = 1'd1; |
status_bits_irq_mask_wen_nxt = 1'd1; |
1015,16 → 1036,16
status_bits_firq_mask_wen_nxt = 1'd1; |
end |
end |
|
|
|
// previous instruction was either ldr or sdr |
// if it is currently executing in the execute stage do the following |
// if it is currently executing in the execute stage do the following |
if ( control_state == MEM_WAIT1 ) |
begin |
// Save the next instruction to execute later |
// Do this even if this instruction does not execute because of Condition |
pre_fetch_instruction_wen = 1'd1; |
|
|
if ( instruction_execute ) // conditional execution state |
begin |
address_sel_nxt = 4'd3; // pc (not pc + 4) |
1031,24 → 1052,24
pc_wen_nxt = 1'd0; // hold current PC value |
end |
end |
|
|
// completion of load operation |
|
|
// completion of load operation |
if ( control_state == MEM_WAIT2 && load_op ) |
begin |
barrel_shift_data_sel_nxt = 2'd1; // load word from memory |
barrel_shift_amount_sel_nxt = 2'd3; // shift by address[1:0] x 8 |
|
|
// shift needed |
if ( i_execute_address[1:0] != 2'd0 ) |
barrel_shift_function_nxt = ROR; |
|
// load a byte |
|
// load a byte |
if ( itype == TRANS && instruction[22] ) |
alu_out_sel_nxt = 4'd3; // zero_extend8 |
|
|
if ( !dabt ) // dont load data there is an abort on the data read |
begin |
begin |
// Check if the load destination is the PC |
if (instruction[15:12] == 4'd15) |
begin |
1055,12 → 1076,12
pc_sel_nxt = 2'd1; // alu_out |
address_sel_nxt = 4'd1; // alu_out |
end |
else |
else |
reg_bank_wsel_nxt = instruction[15:12]; |
end |
end |
|
|
|
|
// second cycle of multiple load or store |
if ( control_state == MTRANS_EXEC1 ) |
begin |
1067,39 → 1088,39
// Save the next instruction to execute later |
// Do this even if this instruction does not execute because of Condition |
pre_fetch_instruction_wen = 1'd1; |
|
|
if ( instruction_execute ) // conditional execution state |
begin |
address_sel_nxt = 4'd5; // o_address |
pc_wen_nxt = 1'd0; // hold current PC value |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
// rather than an instruction fetch |
|
|
if ( !instruction[20] ) // Store |
write_data_wen_nxt = 1'd1; |
|
// LDM: load into user mode registers, when in priviledged mode |
|
// LDM: load into user mode registers, when in priviledged mode |
//if ( {instruction[22],instruction[20],mtrans_r15} == 3'b110 ) |
if ( {instruction[22:20],mtrans_r15} == 4'b1010 ) |
user_mode_regs_load_nxt = 1'd1; |
|
// SDM: store the user mode registers, when in priviledged mode |
//if ( {instruction[22],instruction[20]} == 2'b10 ) |
|
// SDM: store the user mode registers, when in priviledged mode |
//if ( {instruction[22],instruction[20]} == 2'b10 ) |
if ( {instruction[22:20]} == 3'b100 ) |
o_user_mode_regs_store_nxt = 1'd1; |
end |
end |
|
|
end |
end |
|
|
// third cycle of multiple load or store |
if ( control_state == MTRANS_EXEC2 ) |
begin |
address_sel_nxt = 4'd5; // o_address |
pc_wen_nxt = 1'd0; // hold current PC value |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
// rather than an instruction fetch |
barrel_shift_data_sel_nxt = 2'd1; // load word from memory |
|
|
// Load or Store |
if ( instruction[20] ) // Load |
begin |
1110,17 → 1131,17
end |
else // Store |
write_data_wen_nxt = 1'd1; |
|
// LDM: load into user mode registers, when in priviledged mode |
|
// LDM: load into user mode registers, when in priviledged mode |
if ( {instruction[22],instruction[20],mtrans_r15} == 3'b110 ) |
user_mode_regs_load_nxt = 1'd1; |
|
// SDM: store the user mode registers, when in priviledged mode |
if ( {instruction[22],instruction[20]} == 2'b10 ) |
|
// SDM: store the user mode registers, when in priviledged mode |
if ( {instruction[22],instruction[20]} == 2'b10 ) |
o_user_mode_regs_store_nxt = 1'd1; |
end |
|
|
|
|
// second or fourth cycle of multiple load or store |
if ( control_state == MTRANS_EXEC3 && instruction_execute ) |
begin |
1127,19 → 1148,19
address_sel_nxt = 4'd3; // pc (not pc + 4) |
pc_wen_nxt = 1'd0; // hold current PC value |
barrel_shift_data_sel_nxt = 2'd1; // load word from memory |
|
|
// Can never be loading the PC in this state, as the PC is always |
// the last register in the set to be loaded |
if ( instruction[20] && !dabt ) // Load |
reg_bank_wsel_nxt = mtrans_reg_d2; |
|
// LDM: load into user mode registers, when in priviledged mode |
|
// LDM: load into user mode registers, when in priviledged mode |
if ( {instruction[22],instruction[20],mtrans_r15} == 3'b110 ) |
user_mode_regs_load_nxt = 1'd1; |
|
// SDM: store the user mode registers, when in priviledged mode |
//if ( {instruction[22:20]} == 3'b100 ) |
if ( {instruction[22],instruction[20]} == 2'b10 ) |
|
// SDM: store the user mode registers, when in priviledged mode |
//if ( {instruction[22:20]} == 3'b100 ) |
if ( {instruction[22],instruction[20]} == 2'b10 ) |
o_user_mode_regs_store_nxt = 1'd1; |
end |
|
1149,23 → 1170,23
// Save the next instruction to execute later |
// Do this even if this instruction does not execute because of Condition |
pre_fetch_instruction_wen = 1'd1; |
|
|
address_sel_nxt = 4'd3; // pc (not pc + 4) |
pc_wen_nxt = 1'd0; // hold current PC value |
|
// LDM: load into user mode registers, when in priviledged mode |
|
// LDM: load into user mode registers, when in priviledged mode |
if ( {instruction[22],instruction[20],mtrans_r15} == 3'b110 ) |
user_mode_regs_load_nxt = 1'd1; |
|
// SDM: store the user mode registers, when in priviledged mode |
if ( {instruction[22],instruction[20]} == 2'b10 ) |
|
// SDM: store the user mode registers, when in priviledged mode |
if ( {instruction[22],instruction[20]} == 2'b10 ) |
o_user_mode_regs_store_nxt = 1'd1; |
end |
|
|
if ( control_state == MTRANS_EXEC4 ) |
begin |
barrel_shift_data_sel_nxt = 2'd1; // load word from memory |
|
|
if ( instruction[20] ) // Load |
begin |
if (!dabt) // dont overwrite registers or status if theres a data abort |
1175,18 → 1196,18
address_sel_nxt = 4'd1; // alu_out - read instructions using new PC value |
pc_sel_nxt = 2'd1; // alu_out |
pc_wen_nxt = 1'd1; // write PC |
|
|
// ldm with S bit and pc: the Status bits are updated |
// Node this must be done only at the end |
// so the register set is the set in the mode before it |
// gets changed. |
if ( instruction[22] ) |
// gets changed. |
if ( instruction[22] ) |
begin |
status_bits_sel_nxt = 3'd1; // alu out |
status_bits_flags_wen_nxt = 1'd1; |
|
|
// Can't change the mode or mask bits in User mode |
if ( i_execute_status_bits[1:0] != USR ) |
if ( i_execute_status_bits[1:0] != USR ) |
begin |
status_bits_mode_wen_nxt = 1'd1; |
status_bits_irq_mask_wen_nxt = 1'd1; |
1200,23 → 1221,23
end |
end |
end |
|
|
// we have a data abort interrupt |
if ( dabt ) |
begin |
begin |
pc_wen_nxt = 1'd0; // hold current PC value |
end |
|
// LDM: load into user mode registers, when in priviledged mode |
|
// LDM: load into user mode registers, when in priviledged mode |
if ( {instruction[22],instruction[20],mtrans_r15} == 3'b110 ) |
user_mode_regs_load_nxt = 1'd1; |
|
// SDM: store the user mode registers, when in priviledged mode |
if ( {instruction[22],instruction[20]} == 2'b10 ) |
|
// SDM: store the user mode registers, when in priviledged mode |
if ( {instruction[22],instruction[20]} == 2'b10 ) |
o_user_mode_regs_store_nxt = 1'd1; |
end |
|
|
|
|
// state is for when a data abort interrupt is triggered during an LDM |
if ( control_state == MTRANS5_ABORT ) |
begin |
1228,8 → 1249,8
reg_bank_wsel_nxt = instruction[19:16]; // to Rn |
end |
end |
|
|
|
|
// Multiply or Multiply-Accumulate |
if ( control_state == MULT_PROC1 && instruction_execute ) |
begin |
1240,7 → 1261,7
multiply_function_nxt = o_multiply_function; |
end |
|
|
|
// Multiply or Multiply-Accumulate |
// Do multiplication |
// Wait for done or accumulate signal |
1253,7 → 1274,7
multiply_function_nxt = o_multiply_function; |
end |
|
|
|
// Save RdLo |
// always last cycle of all multiply or multiply accumulate operations |
if ( control_state == MULT_STORE ) |
1260,19 → 1281,19
begin |
reg_write_sel_nxt = 3'd2; // multiply_out |
multiply_function_nxt = o_multiply_function; |
|
|
if ( itype == MULT ) // 32-bit |
reg_bank_wsel_nxt = instruction[19:16]; // Rd |
else // 64-bit / Long |
reg_bank_wsel_nxt = instruction[15:12]; // RdLo |
|
|
if ( instruction[20] ) // the 'S' bit |
begin |
status_bits_sel_nxt = 3'd4; // { multiply_flags, status_bits_flags[1:0] } |
status_bits_sel_nxt = 3'd4; // { multiply_flags, status_bits_flags[1:0] } |
status_bits_flags_wen_nxt = 1'd1; |
end |
end |
|
|
// Add lower 32 bits to multiplication product |
if ( control_state == MULT_ACCUMU ) |
begin |
1280,7 → 1301,7
pc_wen_nxt = 1'd0; // hold current PC value |
address_sel_nxt = 4'd3; // pc (not pc + 4) |
end |
|
|
// swp - do write request in 2nd cycle |
if ( control_state == SWAP_WRITE && instruction_execute ) |
begin |
1287,44 → 1308,44
barrel_shift_data_sel_nxt = 2'd2; // Shift value from Rm register |
address_sel_nxt = 4'd4; // Rn |
write_data_wen_nxt = 1'd1; |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
data_access_exec_nxt = 1'd1; // indicate that its a data read or write, |
// rather than an instruction fetch |
|
|
if ( instruction[22] ) |
byte_enable_sel_nxt = 2'd1; // Save byte |
|
|
if ( instruction_execute ) // conditional execution state |
pc_wen_nxt = 1'd0; // hold current PC value |
|
|
// Save the next instruction to execute later |
// Do this even if this instruction does not execute because of Condition |
pre_fetch_instruction_wen = 1'd1; |
|
|
end |
|
|
|
// swp - receive read response in 3rd cycle |
if ( control_state == SWAP_WAIT1 ) |
if ( control_state == SWAP_WAIT1 ) |
begin |
barrel_shift_data_sel_nxt = 2'd1; // load word from memory |
barrel_shift_amount_sel_nxt = 2'd3; // shift by address[1:0] x 8 |
|
|
// shift needed |
if ( i_execute_address[1:0] != 2'd0 ) |
barrel_shift_function_nxt = ROR; |
|
|
if ( instruction_execute ) // conditional execution state |
begin |
address_sel_nxt = 4'd3; // pc (not pc + 4) |
pc_wen_nxt = 1'd0; // hold current PC value |
end |
|
// load a byte |
|
// load a byte |
if ( instruction[22] ) |
alu_out_sel_nxt = 4'd3; // zero_extend8 |
|
|
if ( !dabt ) |
begin |
begin |
// Check is the load destination is the PC |
if ( instruction[15:12] == 4'd15 ) |
begin |
1331,26 → 1352,26
pc_sel_nxt = 2'd1; // alu_out |
address_sel_nxt = 4'd1; // alu_out |
end |
else |
else |
reg_bank_wsel_nxt = instruction[15:12]; |
end |
end |
|
|
// 1 cycle delay for Co-Processor Register access |
if ( control_state == COPRO_WAIT && instruction_execute ) |
begin |
pre_fetch_instruction_wen = 1'd1; |
|
|
if ( instruction[20] ) // mrc instruction |
begin |
// Check is the load destination is the PC |
if ( instruction[15:12] == 4'd15 ) |
begin |
// If r15 is specified for <Rd>, the condition code flags are |
// If r15 is specified for <Rd>, the condition code flags are |
// updated instead of a general-purpose register. |
status_bits_sel_nxt = 3'd3; // i_copro_data |
status_bits_flags_wen_nxt = 1'd1; |
|
|
// Can't change these in USR mode |
if ( i_execute_status_bits[1:0] != USR ) |
begin |
1359,25 → 1380,25
status_bits_firq_mask_wen_nxt = 1'd1; |
end |
end |
else |
else |
reg_bank_wsel_nxt = instruction[15:12]; |
|
|
reg_write_sel_nxt = 3'd5; // i_copro_data |
end |
else // mcr instruction |
begin |
copro_operation_nxt = 2'd2; // Register transfer to Co-Processor |
end |
copro_operation_nxt = 2'd2; // Register transfer to Co-Processor |
end |
end |
|
|
|
// Have just changed the status_bits mode but this |
// creates a 1 cycle gap with the old mode |
// coming back from execute into instruction_decode |
// So squash that old mode value during this |
// cycle of the interrupt transition |
if ( control_state == INT_WAIT1 ) |
status_bits_mode_nxt = o_status_bits_mode; // Supervisor mode |
// cycle of the interrupt transition |
if ( control_state == INT_WAIT1 ) |
status_bits_mode_nxt = status_bits_mode_r; // Supervisor mode |
|
end |
|
1392,12 → 1413,12
// ======================================================== |
|
// this replicates the current value of the execute signal in the execute stage |
assign instruction_execute = conditional_execute ( o_condition, i_execute_status_bits[31:28] ); |
assign instruction_execute = conditional_execute ( condition_r, i_execute_status_bits[31:28] ); |
|
assign instruction_valid = (control_state == EXECUTE || control_state == PRE_FETCH_EXEC) || |
// when last instruction was multi-cycle instruction but did not execute |
// because condition was false then act like you're in the execute state |
(!instruction_execute && (control_state == PC_STALL1 || |
(!instruction_execute && (control_state == PC_STALL1 || |
control_state == MEM_WAIT1 || |
control_state == COPRO_WAIT || |
control_state == SWAP_WRITE || |
1411,7 → 1432,7
begin |
// default is to hold the current state |
control_state_nxt = control_state; |
|
|
// Note: The order is important here |
if ( control_state == RST_WAIT1 ) control_state_nxt = RST_WAIT2; |
if ( control_state == RST_WAIT2 ) control_state_nxt = EXECUTE; |
1419,39 → 1440,39
if ( control_state == INT_WAIT2 ) control_state_nxt = EXECUTE; |
if ( control_state == COPRO_WAIT ) control_state_nxt = PRE_FETCH_EXEC; |
if ( control_state == PC_STALL1 ) control_state_nxt = PC_STALL2; |
if ( control_state == PC_STALL2 ) control_state_nxt = EXECUTE; |
if ( control_state == SWAP_WRITE ) control_state_nxt = SWAP_WAIT1; |
if ( control_state == SWAP_WAIT1 ) control_state_nxt = SWAP_WAIT2; |
if ( control_state == MULT_STORE ) control_state_nxt = PRE_FETCH_EXEC; |
if ( control_state == PC_STALL2 ) control_state_nxt = EXECUTE; |
if ( control_state == SWAP_WRITE ) control_state_nxt = SWAP_WAIT1; |
if ( control_state == SWAP_WAIT1 ) control_state_nxt = SWAP_WAIT2; |
if ( control_state == MULT_STORE ) control_state_nxt = PRE_FETCH_EXEC; |
if ( control_state == MTRANS5_ABORT ) control_state_nxt = PRE_FETCH_EXEC; |
|
if ( control_state == MEM_WAIT1 ) |
control_state_nxt = MEM_WAIT2; |
|
if ( control_state == MEM_WAIT2 || |
if ( control_state == MEM_WAIT2 || |
control_state == SWAP_WAIT2 ) |
begin |
if ( write_pc ) // writing to the PC!! |
if ( write_pc ) // writing to the PC!! |
control_state_nxt = PC_STALL1; |
else |
control_state_nxt = PRE_FETCH_EXEC; |
end |
|
if ( control_state == MTRANS_EXEC1 ) |
begin |
|
if ( control_state == MTRANS_EXEC1 ) |
begin |
if (mtrans_instruction_nxt[15:0] != 16'd0) |
control_state_nxt = MTRANS_EXEC2; |
else // if the register list holds a single register |
else // if the register list holds a single register |
control_state_nxt = MTRANS_EXEC3; |
end |
|
|
// Stay in State MTRANS_EXEC2 until the full list of registers to |
// load or store has been processed |
if ( control_state == MTRANS_EXEC2 && mtrans_num_registers == 5'd1 ) |
control_state_nxt = MTRANS_EXEC3; |
|
if ( control_state == MTRANS_EXEC3 ) control_state_nxt = MTRANS_EXEC4; |
|
|
if ( control_state == MTRANS_EXEC3 ) control_state_nxt = MTRANS_EXEC4; |
|
if ( control_state == MTRANS_EXEC3B ) control_state_nxt = MTRANS_EXEC4; |
|
if ( control_state == MTRANS_EXEC4 ) |
1458,12 → 1479,12
begin |
if ( dabt ) // data abort |
control_state_nxt = MTRANS5_ABORT; |
else if (write_pc) // writing to the PC!! |
else if (write_pc) // writing to the PC!! |
control_state_nxt = PC_STALL1; |
else |
control_state_nxt = PRE_FETCH_EXEC; |
end |
|
|
if ( control_state == MULT_PROC1 ) |
begin |
if (!instruction_execute) |
1471,23 → 1492,23
else |
control_state_nxt = MULT_PROC2; |
end |
|
|
if ( control_state == MULT_PROC2 ) |
begin |
if ( i_multiply_done ) |
if ( o_multiply_function[1] ) // Accumulate ? |
control_state_nxt = MULT_ACCUMU; |
else |
else |
control_state_nxt = MULT_STORE; |
end |
|
|
|
|
if ( control_state == MULT_ACCUMU ) |
begin |
control_state_nxt = MULT_STORE; |
end |
|
|
|
|
// This should come at the end, so that conditional execution works |
// correctly |
if ( instruction_valid ) |
1495,10 → 1516,10
// default is to stay in execute state, or to move into this |
// state from a conditional execute state |
control_state_nxt = EXECUTE; |
|
|
if ( mem_op ) // load or store word or byte |
control_state_nxt = MEM_WAIT1; |
if ( write_pc ) |
if ( write_pc ) |
control_state_nxt = PC_STALL1; |
if ( itype == MTRANS ) |
begin |
1510,7 → 1531,7
else |
control_state_nxt = MTRANS_EXEC1; |
end |
else |
else |
control_state_nxt = MTRANS_EXEC3; |
end |
|
1517,14 → 1538,14
if ( itype == MULT ) |
control_state_nxt = MULT_PROC1; |
|
if ( itype == SWAP ) |
if ( itype == SWAP ) |
control_state_nxt = SWAP_WRITE; |
|
if ( itype == CORTRANS && !und_request ) |
if ( itype == CORTRANS && !und_request ) |
control_state_nxt = COPRO_WAIT; |
|
// interrupt overrides everything else so its last |
if ( interrupt ) |
|
// interrupt overrides everything else so its last |
if ( interrupt ) |
control_state_nxt = INT_WAIT1; |
end |
end |
1534,30 → 1555,30
// Register Update |
// ======================================================== |
always @ ( posedge i_clk ) |
if (!i_fetch_stall) |
begin |
if (!i_fetch_stall) |
begin |
o_read_data <= i_read_data; |
o_read_data_alignment <= {i_execute_address[1:0], 3'd0}; |
o_read_data_alignment <= {i_execute_address[1:0], 3'd0}; |
abt_address_reg <= i_execute_address; |
iabt_reg <= i_iabt; |
adex_reg <= i_adex; |
abt_status_reg <= i_abt_status; |
o_status_bits_mode <= status_bits_mode_nxt; |
o_status_bits_irq_mask <= status_bits_irq_mask_nxt; |
o_status_bits_firq_mask <= status_bits_firq_mask_nxt; |
status_bits_mode_r <= status_bits_mode_nxt; |
status_bits_irq_mask_r <= status_bits_irq_mask_nxt; |
status_bits_firq_mask_r <= status_bits_firq_mask_nxt; |
o_imm32 <= imm32_nxt; |
o_imm_shift_amount <= imm_shift_amount_nxt; |
o_shift_imm_zero <= shift_imm_zero_nxt; |
|
|
// when have an interrupt, execute the interrupt operation |
// unconditionally in the execute stage |
// ensures that status_bits register gets updated correctly |
// Likewise when in middle of multi-cycle instructions |
// execute them unconditionally |
o_condition <= instruction_valid && !interrupt ? condition_nxt : AL; |
condition_r <= instruction_valid && !interrupt ? condition_nxt : AL; |
o_exclusive_exec <= exclusive_exec_nxt; |
o_data_access_exec <= data_access_exec_nxt; |
|
|
o_rm_sel <= o_rm_sel_nxt; |
o_rds_sel <= o_rds_sel_nxt; |
o_rn_sel <= o_rn_sel_nxt; |
1568,8 → 1589,8
o_use_carry_in <= use_carry_in_nxt; |
o_multiply_function <= multiply_function_nxt; |
o_interrupt_vector_sel <= next_interrupt; |
o_address_sel <= address_sel_nxt; |
o_pc_sel <= pc_sel_nxt; |
address_sel_r <= address_sel_nxt; |
pc_sel_r <= pc_sel_nxt; |
o_byte_enable_sel <= byte_enable_sel_nxt; |
o_status_bits_sel <= status_bits_sel_nxt; |
o_reg_write_sel <= reg_write_sel_nxt; |
1577,7 → 1598,7
o_firq_not_user_mode <= firq_not_user_mode_nxt; |
o_write_data_wen <= write_data_wen_nxt; |
o_base_address_wen <= base_address_wen_nxt; |
o_pc_wen <= pc_wen_nxt; |
pc_wen_r <= pc_wen_nxt; |
o_reg_bank_wsel <= reg_bank_wsel_nxt; |
o_reg_bank_wen <= decode ( reg_bank_wsel_nxt ); |
o_status_bits_flags_wen <= status_bits_flags_wen_nxt; |
1584,7 → 1605,7
o_status_bits_mode_wen <= status_bits_mode_wen_nxt; |
o_status_bits_irq_mask_wen <= status_bits_irq_mask_wen_nxt; |
o_status_bits_firq_mask_wen <= status_bits_firq_mask_wen_nxt; |
|
|
o_copro_opcode1 <= instruction[23:21]; |
o_copro_opcode2 <= instruction[7:5]; |
o_copro_crn <= instruction[19:16]; |
1610,7 → 1631,7
// then when its decoded, a copy is saved to the saved_current_instruction |
// register |
if (itype == MTRANS) |
begin |
begin |
saved_current_instruction <= mtrans_instruction_nxt; |
saved_current_instruction_iabt <= instruction_iabt; |
saved_current_instruction_adex <= instruction_adex; |
1617,8 → 1638,8
saved_current_instruction_address <= instruction_address; |
saved_current_instruction_iabt_status <= instruction_iabt_status; |
end |
else if (saved_current_instruction_wen) |
begin |
else if (saved_current_instruction_wen) |
begin |
saved_current_instruction <= instruction; |
saved_current_instruction_iabt <= instruction_iabt; |
saved_current_instruction_adex <= instruction_adex; |
1626,36 → 1647,36
saved_current_instruction_iabt_status <= instruction_iabt_status; |
end |
|
if (pre_fetch_instruction_wen) |
if (pre_fetch_instruction_wen) |
begin |
pre_fetch_instruction <= o_read_data; |
pre_fetch_instruction_iabt <= iabt_reg; |
pre_fetch_instruction_adex <= adex_reg; |
pre_fetch_instruction_address <= abt_address_reg; |
pre_fetch_instruction_iabt_status <= abt_status_reg; |
end |
pre_fetch_instruction <= o_read_data; |
pre_fetch_instruction_iabt <= iabt_reg; |
pre_fetch_instruction_adex <= adex_reg; |
pre_fetch_instruction_address <= abt_address_reg; |
pre_fetch_instruction_iabt_status <= abt_status_reg; |
end |
end |
|
|
|
|
always @ ( posedge i_clk ) |
if ( !i_fetch_stall ) |
begin |
irq <= i_irq; |
firq <= i_firq; |
|
if ( control_state == INT_WAIT1 && o_status_bits_mode == SVC ) |
irq <= i_irq; |
firq <= i_firq; |
|
if ( control_state == INT_WAIT1 && status_bits_mode_r == SVC ) |
begin |
dabt_reg <= 1'd0; |
end |
else |
begin |
dabt_reg <= dabt_reg || i_dabt; |
dabt_reg <= dabt_reg || i_dabt; |
end |
|
dabt_reg_d1 <= dabt_reg; |
end |
|
dabt_reg_d1 <= dabt_reg; |
end |
|
assign dabt = dabt_reg || i_dabt; |
|
|
1676,15 → 1697,15
.i_interrupt ( {3{interrupt}} & next_interrupt ), |
.i_interrupt_state ( control_state == INT_WAIT2 ), |
.i_instruction_undefined ( und_request ), |
.i_pc_sel ( o_pc_sel ), |
.i_pc_wen ( o_pc_wen ) |
); |
.i_pc_sel ( pc_sel_r ), |
.i_pc_wen ( pc_wen_r )); |
|
|
|
wire [(15*8)-1:0] xCONTROL_STATE; |
wire [(15*8)-1:0] xMODE; |
|
assign xCONTROL_STATE = |
assign xCONTROL_STATE = |
control_state == RST_WAIT1 ? "RST_WAIT1" : |
control_state == RST_WAIT2 ? "RST_WAIT2" : |
|
1713,7 → 1734,7
control_state == COPRO_WAIT ? "COPRO_WAIT" : |
"UNKNOWN " ; |
|
assign xMODE = mode_name ( o_status_bits_mode ); |
assign xMODE = mode_name ( status_bits_mode_r ); |
|
always @( posedge i_clk ) |
if (control_state == EXECUTE && ((instruction[0] === 1'bx) || (instruction[31] === 1'bx))) |
/a23_execute.v
57,7 → 57,7
|
output reg [31:0] o_copro_write_data = 'd0, |
output reg [31:0] o_write_data = 'd0, |
output reg [31:0] o_address = 32'hdead_dead, |
output wire [31:0] o_address, |
output reg o_adex = 'd0, // Address Exception |
output reg o_address_valid = 'd0, // Prevents the reset address value being a |
// wishbone access |
200,7 → 200,9
|
wire carry_in; |
|
reg [31:0] address_r = 32'hdead_dead; |
|
|
// ======================================================== |
// Status Bits in PC register |
// ======================================================== |
264,10 → 266,11
// ======================================================== |
assign pc_plus4 = pc + 32'd4; |
assign pc_minus4 = pc - 32'd4; |
assign address_plus4 = o_address + 32'd4; |
assign address_plus4 = address_r + 32'd4; |
assign alu_plus4 = alu_out + 32'd4; |
assign rn_plus4 = rn + 32'd4; |
|
|
// ======================================================== |
// Barrel Shift Amount Select |
// ======================================================== |
456,7 → 459,7
o_data_access <= data_access_update ? i_data_access_exec : o_data_access; |
o_write_enable <= write_enable_update ? write_enable_nxt : o_write_enable; |
o_write_data <= write_data_update ? write_data_nxt : o_write_data; |
o_address <= address_update ? o_address_nxt : o_address; |
address_r <= address_update ? o_address_nxt : address_r; |
o_adex <= address_update ? adex_nxt : o_adex; |
o_address_valid <= address_update ? 1'd1 : o_address_valid; |
o_byte_enable <= byte_enable_update ? byte_enable_nxt : o_byte_enable; |
472,7 → 475,9
status_bits_firq_mask <= status_bits_firq_mask_update ? status_bits_firq_mask_nxt : status_bits_firq_mask; |
end |
|
assign o_address = address_r; |
|
|
// ======================================================== |
// Instantiate Barrel Shift |
// ======================================================== |