URL https://opencores.org/ocsvn/rtf65002/rtf65002/trunk

Subversion Repositories rtf65002

[/] [rtf65002/] [trunk/] [rtl/] [verilog/] [rtf65002d.v] - Blame information for rev 38

Details | Compare with Previous | View Log


`timescale 1ns / 1ps
// ============================================================================
//        __
//   \\__/ o\    (C) 2013, 2014  Robert Finch, Stratford
//    \  __ /    All rights reserved.
//     \/_//     robfinch<remove>@opencores.org
//       ||
//
// rtf65002.v
//  - 32 bit CPU
//
// This source file is free software: you can redistribute it and/or modify 
// it under the terms of the GNU Lesser General Public License as published 
// by the Free Software Foundation, either version 3 of the License, or     
// (at your option) any later version.                                      
//                                                                          
// This source file is distributed in the hope that it will be useful,      
// but WITHOUT ANY WARRANTY; without even the implied warranty of           
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            
// GNU General Public License for more details.                             
//                                                                          
// You should have received a copy of the GNU General Public License        
// along with this program.  If not, see <http://www.gnu.org/licenses/>.    
//                                                                          
// ============================================================================
//
`include "rtf65002_defines.v"
 
module rtf65002d(rst_md, rst_i, clk_i, nmi_i, irq_i, irq_vect, bte_o, cti_o, bl_o, lock_o, cyc_o, stb_o, ack_i, rty_i, err_i, we_o, sel_o, adr_o, dat_i, dat_o, km_o);
parameter RESET1 = 6'd0;
parameter IFETCH = 6'd1;
parameter DECODE = 6'd2;
parameter STORE1 = 6'd3;
parameter STORE2 = 6'd4;
parameter CALC = 6'd5;
parameter JSR161 = 6'd6;
parameter RTS1 = 6'd7;
parameter IY3 = 6'd8;
parameter BSR1 = 6'd9;
parameter BYTE_IX5 = 6'd10;
parameter BYTE_IY5 = 6'd11;
parameter WAIT_DHIT = 6'd12;
parameter RESET2 = 6'd13;
parameter MULDIV1 = 6'd14;
parameter MULDIV2 = 6'd15;
parameter BYTE_DECODE = 6'd16;
parameter BYTE_CALC = 6'd17;
parameter BUS_ERROR = 6'd18;
parameter LOAD_MAC1 = 6'd19;
parameter LOAD_MAC2 = 6'd20;
parameter LOAD_MAC3 = 6'd21;
parameter MVN3 = 6'd22;
parameter PUSHA1 = 6'd23;
parameter POPA1 = 6'd24;
parameter BYTE_IFETCH = 6'd25;
parameter LOAD_DCACHE = 6'd26;
parameter LOAD_ICACHE = 6'd27;
parameter LOAD_IBUF1 = 6'd28;
parameter LOAD_IBUF2 = 6'd29;
parameter LOAD_IBUF3 = 6'd30;
parameter ICACHE1 = 6'd31;
parameter IBUF1 = 6'd32;
parameter DCACHE1 = 6'd33;
parameter CMPS1 = 6'd34;
parameter HALF_CALC = 6'd35;
parameter MVN816 = 6'd36;
 
parameter SPIN_CYCLES = 8'd30;
 
input rst_md;           // reset mode, 1=emulation mode, 0=native mode
input rst_i;
input clk_i;
input nmi_i;
input irq_i;
input [8:0] irq_vect;
output reg [1:0] bte_o;
output reg [2:0] cti_o;
output reg [5:0] bl_o;
output reg lock_o;
output reg cyc_o;
output reg stb_o;
input ack_i;
input rty_i;
input err_i;
output reg we_o;
output reg [3:0] sel_o;
output reg [33:0] adr_o;
input [31:0] dat_i;
output reg [31:0] dat_o;
 
output km_o;
 
reg [5:0] state;
reg [5:0] retstate;
wire [63:0] insn;
reg [63:0] ibuf;
reg [31:0] bufadr;
reg [63:0] exbuf;
 
integer n;
reg cf,nf,zf,vf,bf,im,df,em;
reg tf;         // trace mode flag
reg ttrig;      // trace trigger
reg em1;
reg gie;        // global interrupt enable (set when sp is loaded)
reg hwi;        // hardware interrupt indicator
reg nmoi;       // native mode on interrupt
wire [31:0] sr = {nf,vf,em,tf,17'b0,m816,m_bit,x_bit,3'b0,bf,df,im,zf,cf};
reg m_bit;      // acc/mem is 16 bit
reg x_bit;      // index regs are 16 bit
reg m816;       // 816 mode
wire m16 = m816 & ~m_bit;
wire xb16 = m816 & ~x_bit;
wire [7:0] sr8 = m816 ? {nf,vf,m_bit,x_bit,df,im,zf,cf} : {nf,vf,1'b0,bf,df,im,zf,cf};
reg nmi1,nmi_edge;
reg wai;
reg spi;                // spinlock interrupt
reg [7:0] spi_cnt;
reg wrrf;               // write register file
reg [31:0] acc;
reg [31:0] x;
reg [31:0] y;
reg [15:0] sp;
reg [15:0] dpr;          // direct page register
reg [7:0] dbr;           // data bank register
reg [31:0] spage;        // stack page
wire [7:0] acc8 = acc[7:0];
wire [7:0] x8 = x[7:0];
wire [7:0] y8 = y[7:0];
wire [15:0] acc16 = acc[15:0];
wire [15:0] x16 = x[15:0];
wire [15:0] y16 = y[15:0];
wire [31:0] x_dec = x - 32'd1;
wire [31:0] x_inc = x + 32'd1;
wire [31:0] y_dec = y - 32'd1;
wire [31:0] y_inc = y + 32'd1;
wire [31:0] acc_dec = acc - 32'd1;
wire [31:0] acc_inc = acc + 32'd1;
reg [31:0] isp;          // interrupt stack pointer
reg [31:0] oisp; // original isp for bus retry
wire [63:0] prod;
reg [15:0] tmp16;
wire [31:0] q,r;
reg [31:0] tick;
wire [15:0] sp_dec = sp - 16'd1;
wire [15:0] sp_inc = sp + 16'd1;
wire [15:0] sp_dec2 = sp - 16'd2;
wire [31:0] isp_dec = isp - 32'd1;
wire [31:0] isp_inc = isp + 32'd1;
reg [3:0] suppress_pcinc;
reg [31:0] pc;
reg [31:0] opc;
wire [3:0] pc_inc;
reg [3:0] pc_inc2;
wire [3:0] pc_inc8;
wire [31:0] pcp2 = pc + (32'd2 & suppress_pcinc);        // for branches
wire [31:0] pcp4 = pc + (32'd4 & suppress_pcinc);        // for branches
wire [31:0] pcp8 = pc + 32'd8;                                           // cache controller needs this
reg [31:0] abs8; // 8 bit mode absolute address register
reg [31:0] vbr;          // vector table base register
wire bhit=pc==bufadr;
reg [2:0] bcnt;          // burst count for cache controller
reg [31:0] regfile [15:0];
reg [63:0] ir;
reg pg2;
wire [8:0] ir9 = {pg2,ir[7:0]};
wire [3:0] Ra = ir[11:8];
wire [3:0] Rb = ir[15:12];
reg [31:0] rfoa;
reg [31:0] rfob;
always @(Ra or x or y or acc)
case(Ra)
4'h0:   rfoa <= 32'd0;
4'h1:   rfoa <= acc;
4'h2:   rfoa <= x;
4'h3:   rfoa <= y;
default:        rfoa <= regfile[Ra];
endcase
always @(Rb or x or y or acc)
case(Rb)
4'h0:   rfob <= 32'd0;
4'h1:   rfob <= acc;
4'h2:   rfob <= x;
4'h3:   rfob <= y;
default:        rfob <= regfile[Rb];
endcase
reg [3:0] Rt;
reg [33:0] ea;
reg first_ifetch;
reg [5:0] ic_whence;
reg [31:0] lfsr;
wire lfsr_fb;
xnor(lfsr_fb,lfsr[0],lfsr[1],lfsr[21],lfsr[31]);
reg [31:0] a, b;
wire signed [31:0] as = a;
wire signed [31:0] bs = b;
wire lt = as < bs;
wire eq = a==b;
wire ltu = a < b;
 
reg [7:0] b8;
reg [15:0] b16;
wire [32:0] alu_out;
reg [32:0] res;
reg [16:0] res16;
reg [8:0] res8;
wire resv8,resv16,resv32;
wire resc8 = res8[8];
wire resc16 = res16[16];
wire resc32 = res[32];
wire resz8 = ~|res8[7:0];
wire resz16 = ~|res16[15:0];
wire resz32 = ~|res[31:0];
wire resn8 = res8[7];
wire resn16 = res16[15];
wire resn32 = res[31];
 
reg [33:0] vect;
reg [31:0] ia;                   // temporary reg to hold indirect address
reg isInsnCacheLoad;
reg isDataCacheLoad;
reg isCacheReset;
wire hit0,hit1;
`ifdef SUPPORT_DCACHE
wire dhit;
`else
wire dhit = 1'b0;
`endif
reg write_allocate;
wire wr;
reg [3:0] wrsel;
reg [31:0] radr;
reg [1:0] radr2LSB;
wire [33:0] radr34 = {radr,radr2LSB};
wire [33:0] radr34p1 = radr34 + 34'd1;
reg [31:0] wadr;
reg [1:0] wadr2LSB;
reg [31:0] wdat;
wire [31:0] rdat;
reg [4:0] load_what;
reg [5:0] store_what;
reg [8:0] intno;                 // interrupt number to take
reg [31:0] derr_address;
reg imiss;
reg dmiss;
reg icacheOn,dcacheOn;
`ifdef SUPPORT_DCACHE
wire unCachedData = radr[31:20]==12'hFFD || !dcacheOn;  // I/O area is uncached
`else
wire unCachedData = 1'b1;
`endif
`ifdef SUPPORT_ICACHE
wire unCachedInsn = pc[31:13]==19'h0 || !icacheOn;              // The lowest 8kB is uncached.
`else
wire unCachedInsn = 1'b1;
`endif
`ifdef ICACHE_2WAY
reg [31:0] clfsr;
wire clfsr_fb;
xnor(clfsr_fb,clfsr[0],clfsr[1],clfsr[21],clfsr[31]);
wire [1:0] whichrd;
wire whichwr=clfsr[0];
`endif
reg [31:0] ilfsr;
wire ilfsr_fb;
xnor(ilfsr_fb,ilfsr[0],ilfsr[1],ilfsr[21],ilfsr[31]);
reg km;                 // kernel mode indicator
assign km_o = km;
 
`ifdef DEBUG
reg [31:0] history_buf [127:0];
reg [6:0] history_ndx;
reg hist_capture;
`endif
 
reg isBusErr;
reg isBrk,isMove,isSts;
reg isMove816;
reg isRTI,isRTL,isRTS;
reg isOrb,isStb;
reg isRMW;
reg isSub,isSub8;
reg isJsrIndx,isJsrInd;
reg ldMuldiv;
reg isPusha,isPopa;
 
wire isCmp = ir9==`CPX_ZPX || ir9==`CPX_ABS || ir9==`CPX_IMM32 ||
                         ir9==`CPY_ZPX || ir9==`CPY_ABS || ir9==`CPY_IMM32;
wire isRMW32 =
                         ir9==`ASL_ZPX || ir9==`ROL_ZPX || ir9==`LSR_ZPX || ir9==`ROR_ZPX || ir9==`INC_ZPX || ir9==`DEC_ZPX ||
                         ir9==`ASL_ABS || ir9==`ROL_ABS || ir9==`LSR_ABS || ir9==`ROR_ABS || ir9==`INC_ABS || ir9==`DEC_ABS ||
                         ir9==`ASL_ABSX || ir9==`ROL_ABSX || ir9==`LSR_ABSX || ir9==`ROR_ABSX || ir9==`INC_ABSX || ir9==`DEC_ABSX ||
                         ir9==`TRB_ZP || ir9==`TRB_ZPX || ir9==`TRB_ABS || ir9==`TSB_ZP || ir9==`TSB_ZPX || ir9==`TSB_ABS ||
                         ir9==`BMS_ZPX || ir9==`BMS_ABS || ir9==`BMS_ABSX ||
                         ir9==`BMC_ZPX || ir9==`BMC_ABS || ir9==`BMC_ABSX ||
                         ir9==`BMF_ZPX || ir9==`BMF_ABS || ir9==`BMF_ABSX
                         ;
wire isRMW8 =
                         ir9==`ASL_ZP || ir9==`ROL_ZP || ir9==`LSR_ZP || ir9==`ROR_ZP || ir9==`INC_ZP || ir9==`DEC_ZP ||
                         ir9==`ASL_ZPX || ir9==`ROL_ZPX || ir9==`LSR_ZPX || ir9==`ROR_ZPX || ir9==`INC_ZPX || ir9==`DEC_ZPX ||
                         ir9==`ASL_ABS || ir9==`ROL_ABS || ir9==`LSR_ABS || ir9==`ROR_ABS || ir9==`INC_ABS || ir9==`DEC_ABS ||
                         ir9==`ASL_ABSX || ir9==`ROL_ABSX || ir9==`LSR_ABSX || ir9==`ROR_ABSX || ir9==`INC_ABSX || ir9==`DEC_ABSX ||
                         ir9==`TRB_ZP || ir9==`TRB_ZPX || ir9==`TRB_ABS || ir9==`TSB_ZP || ir9==`TSB_ZPX || ir9==`TSB_ABS;
                         ;
 
// Registerable decodes
// The following decodes can be registered because they aren't needed until at least the cycle after
// the DECODE stage.
 
always @(posedge clk)
        if (state==DECODE||state==BYTE_DECODE) begin
                isSub <= ir9==`SUB_ZPX || ir9==`SUB_IX || ir9==`SUB_IY ||
                         ir9==`SUB_ABS || ir9==`SUB_ABSX || ir9==`SUB_IMM8 || ir9==`SUB_IMM16 || ir9==`SUB_IMM32;
                isSub8 <= ir9==`SBC_ZP || ir9==`SBC_ZPX || ir9==`SBC_IX || ir9==`SBC_IY || ir9==`SBC_I ||
                         ir9==`SBC_ABS || ir9==`SBC_ABSX || ir9==`SBC_ABSY || ir9==`SBC_IMM;
                isRMW <= em ? isRMW8 : isRMW32;
                isOrb <= ir9==`ORB_ZPX || ir9==`ORB_IX || ir9==`ORB_IY || ir9==`ORB_ABS || ir9==`ORB_ABSX;
                isStb <= ir9==`STB_ZPX || ir9==`STB_ABS || ir9==`STB_ABSX;
                isRTI <= ir9==`RTI;
                isRTL <= ir9==`RTL;
                isRTS <= ir9==`RTS;
                isBrk <= ir9==`BRK;
                isMove <= ir9==`MVP || ir9==`MVN;
                isSts <= ir9==`STS;
                isJsrIndx <= ir9==`JSR_INDX;
                isJsrInd <= ir9==`JSR_IND;
                ldMuldiv <= ir9==`MUL_IMM8 || ir9==`MUL_IMM16 || ir9==`MUL_IMM32 ||
                        ir9==`DIV_IMM8 || ir9==`MOD_IMM8 || ir9==`DIV_IMM16 || ir9==`DIV_IMM32 || ir9==`MOD_IMM16 || ir9==`MOD_IMM32 ||
                        (ir9==`RR && (
                        ir[23:20]==`MUL_RR || ir[23:20]==`MULS_RR || ir[23:20]==`DIV_RR || ir[23:20]==`DIVS_RR || ir[23:20]==`MOD_RR || ir[23:20]==`MODS_RR));
                isPusha <= ir9==`PUSHA;
                isPopa <= ir9==`POPA;
        end
        else
                ldMuldiv <= 1'b0;
 
`ifdef SUPPORT_EXEC
wire isExec = ir9==`EXEC;
wire isAtni = ir9==`ATNI;
`else
wire isExec = 1'b0;
wire isAtni = 1'b0;
`endif
wire md_done;
wire clk;
reg isIY;
reg isIY24;
reg isI24;
 
rtf65002_pcinc upci1
(
        .opcode(ir9),
        .suppress_pcinc(suppress_pcinc),
        .inc(pc_inc)
);
 
rtf65002_pcinc8 upci2
(
        .opcode(ir[7:0]),
        .suppress_pcinc(suppress_pcinc),
        .inc(pc_inc8),
        .m16(m16),
        .xb16(xb16)
);
 
mult_div umd1
(
        .rst(rst_i),
        .clk(clk),
        .ld(ldMuldiv),
        .op(ir9),
        .fn(ir[23:20]),
        .a(a),
        .b(b),
        .p(prod),
        .q(q),
        .r(r),
        .done(md_done)
);
 
`ifdef SUPPORT_ICACHE
`ifdef ICACHE_2WAY
rtf65002_icachemem2way icm0 (
        .whichrd(whichrd),
        .whichwr(whichwr),
        .wclk(clk),
        .wr(ack_i & isInsnCacheLoad),
        .adr(adr_o),
        .dat(dat_i),
        .rclk(~clk),
        .pc(pc),
        .insn(insn)
);
 
rtf65002_itagmem2way tgm0 (
        .whichrd(whichrd),
        .whichwr(isCacheReset ? adr_o[13]: whichwr),
        .wclk(clk),
        .wr((ack_i & isInsnCacheLoad)|isCacheReset),
        .adr({adr_o[31:1],!isCacheReset}),
        .rclk(~clk),
        .pc(pc),
        .hit0(hit0),
        .hit1(hit1)
);
`else
`ifdef ICACHE_4K
rtf65002_icachemem4k icm0 (
        .wclk(clk),
        .wr(ack_i & isInsnCacheLoad),
        .adr(adr_o),
        .dat(dat_i),
        .rclk(~clk),
        .pc(pc),
        .insn(insn)
);
 
rtf65002_itagmem4k tgm0 (
        .wclk(clk),
        .wr((ack_i & isInsnCacheLoad)|isCacheReset),
        .adr({adr_o[33:1],!isCacheReset}),
        .rclk(~clk),
        .pc(pc),
        .hit0(hit0),
        .hit1(hit1)
);
`endif
`ifdef ICACHE_8K
rtf65002_icachemem8k icm0 (
        .wclk(clk),
        .wr(ack_i & isInsnCacheLoad),
        .adr(adr_o),
        .dat(dat_i),
        .rclk(~clk),
        .pc(pc),
        .insn(insn)
);
 
rtf65002_itagmem8k tgm0 (
        .wclk(clk),
        .wr((ack_i & isInsnCacheLoad)|isCacheReset),
        .adr({adr_o[33:1],!isCacheReset}),
        .rclk(~clk),
        .pc(pc),
        .hit0(hit0),
        .hit1(hit1)
);
`endif
`ifdef ICACHE_16K
rtf65002_icachemem icm0 (
        .wclk(clk),
        .wr(ack_i & isInsnCacheLoad),
        .adr(adr_o),
        .dat(dat_i),
        .rclk(~clk),
        .pc(pc),
        .insn(insn)
);
 
rtf65002_itagmem tgm0 (
        .wclk(clk),
        .wr((ack_i & isInsnCacheLoad)|isCacheReset),
        .adr({adr_o[31:1],!isCacheReset}),
        .rclk(~clk),
        .pc(pc),
        .hit0(hit0),
        .hit1(hit1)
);
`endif
`endif  // ICACHE_2WAY
 
wire ihit = (hit0 & hit1);//(pc[2:0] > 3'd1 ? hit1 : 1'b1));
`else
wire ihit = 1'b0;
`endif
 
`ifdef SUPPORT_DCACHE
assign wr = state==STORE2 && dhit && ack_i;
 
rtf65002_dcachemem dcm0 (
        .wclk(clk),
        .wr(wr | (ack_i & isDataCacheLoad)),
        .sel(sel_o),
        .wadr(adr_o[33:2]),
        .wdat(wr ? dat_o : dat_i),
        .rclk(~clk),
        .radr(radr),
        .rdat(rdat)
);
 
rtf65002_dtagmem dtm0 (
        .wclk(clk),
        .wr(wr | (ack_i & isDataCacheLoad) | isCacheReset),
        .wadr(adr_o[33:2]),
        .cr(!isCacheReset),
        .rclk(~clk),
        .radr(radr),
        .hit(dhit)
);
`endif
 
overflow uovr1 (
        .op(isSub),
        .a(a[31]),
        .b(b[31]),
        .s(res[31]),
        .v(resv32)
);
 
overflow uovr2 (
        .op(isSub8),
        .a(acc8[7]),
        .b(b8[7]),
        .s(res8[7]),
        .v(resv8)
);
 
wire [15:0] bcaio;
wire [15:0] bcao;
wire [15:0] bcsio;
wire [15:0] bcso;
wire bcaico,bcaco,bcsico,bcsco;
wire bcaico8,bcaco8,bcsico8,bcsco8;
 
`ifdef SUPPORT_BCD
BCDAdd4 ubcdai1 (.ci(cf),.a(acc16),.b(ir[23:8]),.o(bcaio),.c(bcaico),.c8(bcaico8));
BCDAdd4 ubcda2 (.ci(cf),.a(acc16),.b(b8),.o(bcao),.c(bcaco),.c8(bcaco8));
BCDSub4 ubcdsi1 (.ci(cf),.a(acc16),.b(ir[23:8]),.o(bcsio),.c(bcsico),.c8(bcsico8));
BCDSub4 ubcds2 (.ci(cf),.a(acc16),.b(b8),.o(bcso),.c(bcsco),.c8(bcsco8));
`endif
 
reg [7:0] dati;
always @(radr2LSB or dat_i)
case(radr2LSB)
2'd0:   dati <= dat_i[7:0];
2'd1:   dati <= dat_i[15:8];
2'd2:   dati <= dat_i[23:16];
2'd3:   dati <= dat_i[31:24];
endcase
`ifdef SUPPORT_DCACHE
reg [7:0] rdat8;
always @(radr2LSB or rdat)
case(radr2LSB)
2'd0:   rdat8 <= rdat[7:0];
2'd1:   rdat8 <= rdat[15:8];
2'd2:   rdat8 <= rdat[23:16];
2'd3:   rdat8 <= rdat[31:24];
endcase
`endif
 
// Evaluate branches
// 
reg takb;
always @(ir9 or cf or vf or nf or zf)
case(ir9)
`BEQ:   takb <= zf;
`BNE:   takb <= !zf;
`BPL:   takb <= !nf;
`BMI:   takb <= nf;
`BCS:   takb <= cf;
`BCC:   takb <= !cf;
`BVS:   takb <= vf;
`BVC:   takb <= !vf;
`BRA:   takb <= 1'b1;
`BRL:   takb <= 1'b1;
`BHI:   takb <= cf & !zf;
`BLS:   takb <= !cf | zf;
`BGE:   takb <= (nf & vf)|(!nf & !vf);
`BLT:   takb <= (nf & !vf)|(!nf & vf);
`BGT:   takb <= (nf & vf & !zf) + (!nf & !vf & !zf);
`BLE:   takb <= zf | (nf & !vf)|(!nf & vf);
default:        takb <= 1'b0;
endcase
 
wire [31:0] mvnsrc_address       = {abs8[31:24],ir[23:16],x16};
wire [31:0] mvndst_address       = {abs8[31:24],ir[15: 8],y16};
wire [31:0] iapy8                        = ia + y16;             // Don't add in abs8, already included with ia
wire [31:0] zp_address           = {abs8[31:16],8'h00,ir[15:8]} + dpr;
wire [31:0] zpx_address  = {abs8[31:16],{8'h00,ir[15:8]} + x16} + dpr;
wire [31:0] zpy_address          = {abs8[31:16],{8'h00,ir[15:8]} + y16} + dpr;
wire [31:0] abs_address  = {abs8[31:24],dbr,ir[23:8]};
wire [31:0] absx_address         = {abs8[31:24],dbr,ir[23:8] + x16};     // simulates 64k bank wrap-around
wire [31:0] absy_address         = {abs8[31:24],dbr,ir[23:8] + y16};
wire [31:0] al_address           = {abs8[31:24],ir[31:8]};
wire [31:0] alx_address          = {abs8[31:24],ir[31:8] + x16};
wire [31:0] zpx32xy_address      = ir[23:12] + rfoa;
wire [31:0] absx32xy_address     = ir[47:16] + rfob;
wire [31:0] zpx32_address                = ir[31:20] + rfob;
wire [31:0] absx32_address               = ir[55:24] + rfob;
 
wire [31:0] dsp_address = m816 ? {abs8[31:24],8'h00,sp + ir[15:8]} : {abs8[31:16],8'h01,sp[7:0]+ir[15:8]};
 
rtf65002_alu ualu1
(
        .clk(clk),
        .state(state),
        .resin(res),
        .pg2(pg2),
        .ir(ir),
        .acc(acc),
        .x(x),
        .y(y),
        .isp(isp),
        .rfoa(rfoa),
        .rfob(rfob),
        .a(a),
        .b(b),
        .b8(b8),
        .Rt(Rt),
        .icacheOn(icacheOn),
        .dcacheOn(dcacheOn),
        .write_allocate(write_allocate),
        .prod(prod),
        .tick(tick),
        .lfsr(lfsr),
        .abs8(abs8),
        .vbr(vbr),
        .nmoi(nmoi),
        .derr_address(derr_address),
        .history_buf(history_buf[history_ndx]),
        .spage(spage),
        .sp(sp),
        .df(df),
        .cf(cf),
        .res(alu_out)
);
 
 
//-----------------------------------------------------------------------------
// Clock control
// - reset or NMI reenables the clock
// - this circuit must be under the clk_i domain
//-----------------------------------------------------------------------------
//
reg cpu_clk_en;
reg clk_en;
BUFGCE u20 (.CE(cpu_clk_en), .I(clk_i), .O(clk) );
 
always @(posedge clk_i)
if (rst_i) begin
        cpu_clk_en <= 1'b1;
        nmi1 <= 1'b0;
end
else begin
        nmi1 <= nmi_i;
        if (nmi_i)
                cpu_clk_en <= 1'b1;
        else
                cpu_clk_en <= clk_en;
end
 
always @(posedge clk)
if (rst_i) begin
        bte_o <= 2'b00;
        cti_o <= 3'b000;
        bl_o <= 6'd0;
        cyc_o <= 1'b0;
        stb_o <= 1'b0;
        we_o <= 1'b0;
        sel_o <= 4'h0;
        adr_o <= 34'd0;
        dat_o <= 32'd0;
        nmi_edge <= 1'b0;
        wai <= 1'b0;
        spi <= 1'b0;
        spi_cnt <= SPIN_CYCLES;
        cf <= 1'b0;
        ir <= 64'hEAEAEAEAEAEAEAEA;
        imiss <= `FALSE;
        dmiss <= `FALSE;
        dcacheOn <= 1'b0;
        icacheOn <= 1'b1;
        write_allocate <= 1'b0;
        nmoi <= 1'b1;
        state <= RESET1;
        m816 <= 1'b0;
        m_bit <= 1'b1;
        x_bit <= 1'b1;
        if (rst_md) begin
                pc <= 32'h0000FFF0;             // set high-order pc to zero
                vect <= `BYTE_RST_VECT;
                em <= 1'b1;
        end
        else begin
                vect <= `RST_VECT;
                em <= 1'b0;
                pc <= 32'hFFFFFFF0;
        end
        suppress_pcinc <= 4'hF;
        exbuf <= 64'd0;
        dbr <= 8'h00;
        dpr <= 16'h0000;
        spage <= 32'h00000100;
        bufadr <= 32'd0;
        abs8 <= 32'd0;
        clk_en <= 1'b1;
        isCacheReset <= `TRUE;
        gie <= 1'b0;
        tick <= 32'd0;
        isIY <= 1'b0;
        isIY24 <= 1'b0;
        isI24 <= `FALSE;
        load_what <= `NOTHING;
`ifdef DEBUG
        hist_capture <= `TRUE;
        history_ndx <= 6'd0;
`endif
        pg2 <= `FALSE;
        tf <= `FALSE;
        km <= `TRUE;
        wrrf <= 1'b0;
end
else begin
wrrf <= 1'b0;
tick <= tick + 32'd1;
ilfsr <= {ilfsr,ilfsr_fb};
if (nmi_i & !nmi1)
        nmi_edge <= 1'b1;
if (nmi_i|nmi1)
        clk_en <= 1'b1;
case(state)
// Loop in this state until all the cache address tage have been flagged as
// invalid.
//
RESET1:
        begin
                adr_o <= adr_o + 32'd4;
                if (adr_o[13:4]==10'h3FF) begin
                        state <= RESET2;
                        isCacheReset <= `FALSE;
                end
        end
RESET2:
        begin
                radr <= vect[31:2];
                radr2LSB <= vect[1:0];
                load_what <= em ? `PC_70 : `PC_310;
                state <= LOAD_MAC1;
        end
 
`include "ifetch.v"
`ifdef SUPPORT_EM8
`include "byte_ifetch.v"
`include "byte_decode.v"
`include "byte_calc.v"
`ifdef SUPPORT_816
`include "half_calc.v"
`endif
`endif
 
`include "load_mac.v"
`include "store.v"
 
// This state waits for a data hit before continuing. It's used after a store 
// operation when write allocation is taking place.
WAIT_DHIT:
        if (dhit)
                state <= retstate;
 
DECODE: decode_tsk();
CALC:   calc_tsk();
 
MULDIV1:        state <= MULDIV2;
MULDIV2:
        if (md_done) begin
                state <= IFETCH;
                case(ir9)
                `RR:
                        case(ir[23:20])
                        `MUL_RR:        begin res <= prod[31:0]; end
                        `MULS_RR:       begin res <= prod[31:0]; end
`ifdef SUPPORT_DIVMOD
                        `DIV_RR:        begin res <= q; end
                        `DIVS_RR:       begin res <= q; end
                        `MOD_RR:        begin res <= r; end
                        `MODS_RR:       begin res <= r; end
`endif
                        endcase
                `MUL_IMM8,`MUL_IMM16,`MUL_IMM32:        res <= prod[31:0];
`ifdef SUPPORT_DIVMOD
                `DIV_IMM8,`DIV_IMM16,`DIV_IMM32:        res <= q;
                `MOD_IMM8,`MOD_IMM16,`MOD_IMM32:        res <= r;
`endif
                endcase
        end
 
`ifdef SUPPORT_BERR
BUS_ERROR:
        begin
                pg2 <= `FALSE;
                ir <= {8{`BRK}};
`ifdef DEBUG
                hist_capture <= `FALSE;
`endif
                radr <= isp_dec;
                wadr <= isp_dec;
                isp <= isp_dec;
                store_what <= `STW_OPC;
                vect <= {vbr[31:9],intno,2'b00};
                hwi <= `TRUE;
                isBusErr <= `TRUE;
                next_state(STORE1);
        end
`endif
 
`include "rtf65002_string.v"
`include "cache_controller.v"
 
endcase
 
if (wrrf || state==IFETCH || state==LOAD_MAC3) begin
        regfile[Rt] <= res[31:0];
        case(Rt)
        4'h1:   acc <= res[31:0];
        4'h2:   x <= res[31:0];
        4'h3:   y <= res[31:0];
        default:        ;
        endcase
end
 
end
 
 
`include "decode.v"
`include "calc.v"
`include "load_tsk.v"
`include "wb_task.v"
`include "misc_task.v"
 
task next_state;
input [5:0] nxt;
begin
        state <= nxt;
end
endtask
 
function [127:0] fnStateName;
input [5:0] state;
case(state)
RESET1: fnStateName = "RESET1     ";
RESET2: fnStateName = "RESET2     ";
IFETCH: fnStateName = "IFETCH     ";
DECODE: fnStateName = "DECODE     ";
STORE1: fnStateName = "STORE1     ";
STORE2: fnStateName = "STORE2     ";
CALC:   fnStateName = "CALC       ";
RTS1:   fnStateName = "RTS1       ";
IY3:    fnStateName = "IY3        ";
BYTE_IX5:       fnStateName = "BYTE_IX5   ";
BYTE_IY5:       fnStateName = "BYTE_IY5   ";
WAIT_DHIT:      fnStateName = "WAIT_DHIT  ";
MULDIV1:        fnStateName = "MULDIV1    ";
MULDIV2:        fnStateName = "MULDIV2    ";
BYTE_DECODE:    fnStateName = "BYTE_DECODE";
BYTE_CALC:      fnStateName = "BYTE_CALC  ";
BUS_ERROR:      fnStateName = "BUS_ERROR  ";
LOAD_MAC1:      fnStateName = "LOAD_MAC1  ";
LOAD_MAC2:      fnStateName = "LOAD_MAC2  ";
LOAD_MAC3:      fnStateName = "LOAD_MAC3  ";
MVN3:           fnStateName = "MVN3       ";
PUSHA1:         fnStateName = "PUSHA1     ";
POPA1:          fnStateName = "POPA1      ";
BYTE_IFETCH:    fnStateName = "BYTE_IFETCH";
LOAD_DCACHE:    fnStateName = "LOAD_DCACHE";
LOAD_ICACHE:    fnStateName = "LOAD_ICACHE";
LOAD_IBUF1:             fnStateName = "LOAD_IBUF1 ";
LOAD_IBUF2:             fnStateName = "LOAD_IBUF2 ";
LOAD_IBUF3:             fnStateName = "LOAD_IBUF3 ";
ICACHE1:                fnStateName = "ICACHE1    ";
IBUF1:                  fnStateName = "IBUF1      ";
DCACHE1:                fnStateName = "DCACHE1    ";
CMPS1:                  fnStateName = "CMPS1      ";
HALF_CALC:              fnStateName = "HALF_CALC  ";
default:                fnStateName = "UNKNOWN    ";
endcase
endfunction
 
endmodule

Line No.	Rev	Author	Line
1	10	robfinch	`timescale 1ns / 1ps
2			`// ============================================================================`
3			`// __`
4	38	robfinch	`// \\__/ o\ (C) 2013, 2014 Robert Finch, Stratford`
5	10	robfinch	`// \ __ / All rights reserved.`
6			`// \/_// robfinch<remove>@opencores.org`
7			`// \|\|`
8			`//`
9			`// rtf65002.v`
10			`// - 32 bit CPU`
11			`//`
12			`// This source file is free software: you can redistribute it and/or modify`
13			`// it under the terms of the GNU Lesser General Public License as published`
14			`// by the Free Software Foundation, either version 3 of the License, or`
15			`// (at your option) any later version.`
16			`//`
17			`// This source file is distributed in the hope that it will be useful,`
18			`// but WITHOUT ANY WARRANTY; without even the implied warranty of`
19			`// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
20			`// GNU General Public License for more details.`
21			`//`
22			`// You should have received a copy of the GNU General Public License`
23			`// along with this program. If not, see <http://www.gnu.org/licenses/>.`
24			`//`
25			`// ============================================================================`
26			`//`
27	30	robfinch	`include "rtf65002_defines.v"
28	5	robfinch
29	35	robfinch	`module rtf65002d(rst_md, rst_i, clk_i, nmi_i, irq_i, irq_vect, bte_o, cti_o, bl_o, lock_o, cyc_o, stb_o, ack_i, rty_i, err_i, we_o, sel_o, adr_o, dat_i, dat_o, km_o);`
30	30	robfinch	`parameter RESET1 = 6'd0;`
31			`parameter IFETCH = 6'd1;`
32			`parameter DECODE = 6'd2;`
33			`parameter STORE1 = 6'd3;`
34			`parameter STORE2 = 6'd4;`
35	32	robfinch	`parameter CALC = 6'd5;`
36			`parameter JSR161 = 6'd6;`
37			`parameter RTS1 = 6'd7;`
38			`parameter IY3 = 6'd8;`
39			`parameter BSR1 = 6'd9;`
40			`parameter BYTE_IX5 = 6'd10;`
41			`parameter BYTE_IY5 = 6'd11;`
42			`parameter WAIT_DHIT = 6'd12;`
43			`parameter RESET2 = 6'd13;`
44			`parameter MULDIV1 = 6'd14;`
45			`parameter MULDIV2 = 6'd15;`
46			`parameter BYTE_DECODE = 6'd16;`
47			`parameter BYTE_CALC = 6'd17;`
48			`parameter BUS_ERROR = 6'd18;`
49	35	robfinch	`parameter LOAD_MAC1 = 6'd19;`
50			`parameter LOAD_MAC2 = 6'd20;`
51			`parameter LOAD_MAC3 = 6'd21;`
52			`parameter MVN3 = 6'd22;`
53			`parameter PUSHA1 = 6'd23;`
54			`parameter POPA1 = 6'd24;`
55			`parameter BYTE_IFETCH = 6'd25;`
56			`parameter LOAD_DCACHE = 6'd26;`
57			`parameter LOAD_ICACHE = 6'd27;`
58			`parameter LOAD_IBUF1 = 6'd28;`
59			`parameter LOAD_IBUF2 = 6'd29;`
60			`parameter LOAD_IBUF3 = 6'd30;`
61			`parameter ICACHE1 = 6'd31;`
62			`parameter IBUF1 = 6'd32;`
63			`parameter DCACHE1 = 6'd33;`
64			`parameter CMPS1 = 6'd34;`
65	38	robfinch	`parameter HALF_CALC = 6'd35;`
66			`parameter MVN816 = 6'd36;`
67	5	robfinch
68	38	robfinch	`parameter SPIN_CYCLES = 8'd30;`
69
70	21	robfinch	`input rst_md; // reset mode, 1=emulation mode, 0=native mode`
71	5	robfinch	`input rst_i;`
72			`input clk_i;`
73			`input nmi_i;`
74			`input irq_i;`
75	13	robfinch	`input [8:0] irq_vect;`
76	5	robfinch	`output reg [1:0] bte_o;`
77			`output reg [2:0] cti_o;`
78			`output reg [5:0] bl_o;`
79			`output reg lock_o;`
80			`output reg cyc_o;`
81			`output reg stb_o;`
82			`input ack_i;`
83	35	robfinch	`input rty_i;`
84	21	robfinch	`input err_i;`
85	5	robfinch	`output reg we_o;`
86			`output reg [3:0] sel_o;`
87			`output reg [33:0] adr_o;`
88			`input [31:0] dat_i;`
89			`output reg [31:0] dat_o;`
90
91	32	robfinch	`output km_o;`
92
93	30	robfinch	`reg [5:0] state;`
94			`reg [5:0] retstate;`
95	21	robfinch	`wire [63:0] insn;`
96			`reg [63:0] ibuf;`
97	5	robfinch	`reg [31:0] bufadr;`
98	25	robfinch	`reg [63:0] exbuf;`
99	5	robfinch
100	35	robfinch	`integer n;`
101	5	robfinch	`reg cf,nf,zf,vf,bf,im,df,em;`
102	32	robfinch	`reg tf; // trace mode flag`
103			`reg ttrig; // trace trigger`
104	5	robfinch	`reg em1;`
105	32	robfinch	`reg gie; // global interrupt enable (set when sp is loaded)`
106	25	robfinch	`reg hwi; // hardware interrupt indicator`
107	5	robfinch	`reg nmoi; // native mode on interrupt`
108	38	robfinch	`wire [31:0] sr = {nf,vf,em,tf,17'b0,m816,m_bit,x_bit,3'b0,bf,df,im,zf,cf};`
109			`reg m_bit; // acc/mem is 16 bit`
110			`reg x_bit; // index regs are 16 bit`
111			`reg m816; // 816 mode`
112			`wire m16 = m816 & ~m_bit;`
113			`wire xb16 = m816 & ~x_bit;`
114			`wire [7:0] sr8 = m816 ? {nf,vf,m_bit,x_bit,df,im,zf,cf} : {nf,vf,1'b0,bf,df,im,zf,cf};`
115	5	robfinch	`reg nmi1,nmi_edge;`
116			`reg wai;`
117	38	robfinch	`reg spi; // spinlock interrupt`
118			`reg [7:0] spi_cnt;`
119	36	robfinch	`reg wrrf; // write register file`
120	5	robfinch	`reg [31:0] acc;`
121			`reg [31:0] x;`
122			`reg [31:0] y;`
123	38	robfinch	`reg [15:0] sp;`
124			`reg [15:0] dpr; // direct page register`
125			`reg [7:0] dbr; // data bank register`
126	13	robfinch	`reg [31:0] spage; // stack page`
127	5	robfinch	`wire [7:0] acc8 = acc[7:0];`
128			`wire [7:0] x8 = x[7:0];`
129			`wire [7:0] y8 = y[7:0];`
130	38	robfinch	`wire [15:0] acc16 = acc[15:0];`
131			`wire [15:0] x16 = x[15:0];`
132			`wire [15:0] y16 = y[15:0];`
133			`wire [31:0] x_dec = x - 32'd1;`
134			`wire [31:0] x_inc = x + 32'd1;`
135			`wire [31:0] y_dec = y - 32'd1;`
136			`wire [31:0] y_inc = y + 32'd1;`
137			`wire [31:0] acc_dec = acc - 32'd1;`
138			`wire [31:0] acc_inc = acc + 32'd1;`
139	5	robfinch	`reg [31:0] isp; // interrupt stack pointer`
140	35	robfinch	`reg [31:0] oisp; // original isp for bus retry`
141	12	robfinch	`wire [63:0] prod;`
142	38	robfinch	`reg [15:0] tmp16;`
143	12	robfinch	`wire [31:0] q,r;`
144			`reg [31:0] tick;`
145	38	robfinch	`wire [15:0] sp_dec = sp - 16'd1;`
146			`wire [15:0] sp_inc = sp + 16'd1;`
147			`wire [15:0] sp_dec2 = sp - 16'd2;`
148	5	robfinch	`wire [31:0] isp_dec = isp - 32'd1;`
149			`wire [31:0] isp_inc = isp + 32'd1;`
150	25	robfinch	`reg [3:0] suppress_pcinc;`
151	5	robfinch	`reg [31:0] pc;`
152	23	robfinch	`reg [31:0] opc;`
153	35	robfinch	`wire [3:0] pc_inc;`
154	38	robfinch	`reg [3:0] pc_inc2;`
155	35	robfinch	`wire [3:0] pc_inc8;`
156	30	robfinch	`wire [31:0] pcp2 = pc + (32'd2 & suppress_pcinc); // for branches`
157			`wire [31:0] pcp4 = pc + (32'd4 & suppress_pcinc); // for branches`
158			`wire [31:0] pcp8 = pc + 32'd8; // cache controller needs this`
159	13	robfinch	`reg [31:0] abs8; // 8 bit mode absolute address register`
160			`reg [31:0] vbr; // vector table base register`
161	5	robfinch	`wire bhit=pc==bufadr;`
162	35	robfinch	`reg [2:0] bcnt; // burst count for cache controller`
163	5	robfinch	`reg [31:0] regfile [15:0];`
164	21	robfinch	`reg [63:0] ir;`
165	32	robfinch	`reg pg2;`
166			`wire [8:0] ir9 = {pg2,ir[7:0]};`
167	5	robfinch	`wire [3:0] Ra = ir[11:8];`
168			`wire [3:0] Rb = ir[15:12];`
169			`reg [31:0] rfoa;`
170			`reg [31:0] rfob;`
171			`always @(Ra or x or y or acc)`
172			`case(Ra)`
173			`4'h0: rfoa <= 32'd0;`
174			`4'h1: rfoa <= acc;`
175			`4'h2: rfoa <= x;`
176			`4'h3: rfoa <= y;`
177			`default: rfoa <= regfile[Ra];`
178			`endcase`
179			`always @(Rb or x or y or acc)`
180			`case(Rb)`
181			`4'h0: rfob <= 32'd0;`
182			`4'h1: rfob <= acc;`
183			`4'h2: rfob <= x;`
184			`4'h3: rfob <= y;`
185			`default: rfob <= regfile[Rb];`
186			`endcase`
187			`reg [3:0] Rt;`
188			`reg [33:0] ea;`
189			`reg first_ifetch;`
190	38	robfinch	`reg [5:0] ic_whence;`
191	12	robfinch	`reg [31:0] lfsr;`
192			`wire lfsr_fb;`
193			`xnor(lfsr_fb,lfsr[0],lfsr[1],lfsr[21],lfsr[31]);`
194	5	robfinch	`reg [31:0] a, b;`
195	32	robfinch	`wire signed [31:0] as = a;`
196			`wire signed [31:0] bs = b;`
197			`wire lt = as < bs;`
198			`wire eq = a==b;`
199			`wire ltu = a < b;`
200
201	5	robfinch	`reg [7:0] b8;`
202	38	robfinch	`reg [15:0] b16;`
203	32	robfinch	`wire [32:0] alu_out;`
204	5	robfinch	`reg [32:0] res;`
205	38	robfinch	`reg [16:0] res16;`
206	5	robfinch	`reg [8:0] res8;`
207	38	robfinch	`wire resv8,resv16,resv32;`
208	5	robfinch	`wire resc8 = res8[8];`
209	38	robfinch	`wire resc16 = res16[16];`
210	5	robfinch	`wire resc32 = res[32];`
211	38	robfinch	`wire resz8 = ~\|res8[7:0];`
212			`wire resz16 = ~\|res16[15:0];`
213			`wire resz32 = ~\|res[31:0];`
214	5	robfinch	`wire resn8 = res8[7];`
215	38	robfinch	`wire resn16 = res16[15];`
216	5	robfinch	`wire resn32 = res[31];`
217
218	35	robfinch	`reg [33:0] vect;`
219	5	robfinch	`reg [31:0] ia; // temporary reg to hold indirect address`
220			`reg isInsnCacheLoad;`
221			`reg isDataCacheLoad;`
222	10	robfinch	`reg isCacheReset;`
223	5	robfinch	`wire hit0,hit1;`
224	30	robfinch	`ifdef SUPPORT_DCACHE
225	5	robfinch	`wire dhit;`
226	30	robfinch	`else
227			`wire dhit = 1'b0;`
228			`endif
229	10	robfinch	`reg write_allocate;`
230	32	robfinch	`wire wr;`
231	5	robfinch	`reg [3:0] wrsel;`
232			`reg [31:0] radr;`
233			`reg [1:0] radr2LSB;`
234			`wire [33:0] radr34 = {radr,radr2LSB};`
235			`wire [33:0] radr34p1 = radr34 + 34'd1;`
236			`reg [31:0] wadr;`
237			`reg [1:0] wadr2LSB;`
238			`reg [31:0] wdat;`
239			`wire [31:0] rdat;`
240	32	robfinch	`reg [4:0] load_what;`
241			`reg [5:0] store_what;`
242	35	robfinch	`reg [8:0] intno; // interrupt number to take`
243	23	robfinch	`reg [31:0] derr_address;`
244	5	robfinch	`reg imiss;`
245			`reg dmiss;`
246			`reg icacheOn,dcacheOn;`
247	30	robfinch	`ifdef SUPPORT_DCACHE
248	20	robfinch	`wire unCachedData = radr[31:20]==12'hFFD \|\| !dcacheOn; // I/O area is uncached`
249	30	robfinch	`else
250			`wire unCachedData = 1'b1;`
251			`endif
252			`ifdef SUPPORT_ICACHE
253	20	robfinch	`wire unCachedInsn = pc[31:13]==19'h0 \|\| !icacheOn; // The lowest 8kB is uncached.`
254	30	robfinch	`else
255			`wire unCachedInsn = 1'b1;`
256			`endif
257	32	robfinch	`ifdef ICACHE_2WAY
258			`reg [31:0] clfsr;`
259			`wire clfsr_fb;`
260			`xnor(clfsr_fb,clfsr[0],clfsr[1],clfsr[21],clfsr[31]);`
261			`wire [1:0] whichrd;`
262			`wire whichwr=clfsr[0];`
263			`endif
264	35	robfinch	`reg [31:0] ilfsr;`
265			`wire ilfsr_fb;`
266			`xnor(ilfsr_fb,ilfsr[0],ilfsr[1],ilfsr[21],ilfsr[31]);`
267	32	robfinch	`reg km; // kernel mode indicator`
268			`assign km_o = km;`
269	5	robfinch
270	35	robfinch	`ifdef DEBUG
271	32	robfinch	`reg [31:0] history_buf [127:0];`
272			`reg [6:0] history_ndx;`
273	30	robfinch	`reg hist_capture;`
274	35	robfinch	`endif
275	30	robfinch
276	32	robfinch	`reg isBusErr;`
277	30	robfinch	`reg isBrk,isMove,isSts;`
278	38	robfinch	`reg isMove816;`
279	30	robfinch	`reg isRTI,isRTL,isRTS;`
280			`reg isOrb,isStb;`
281			`reg isRMW;`
282			`reg isSub,isSub8;`
283	32	robfinch	`reg isJsrIndx,isJsrInd;`
284			`reg ldMuldiv;`
285			`reg isPusha,isPopa;`
286	30	robfinch
287	32	robfinch	wire isCmp = ir9==`CPX_ZPX \|\| ir9==`CPX_ABS \|\| ir9==`CPX_IMM32 \|\|
288			ir9==`CPY_ZPX \|\| ir9==`CPY_ABS \|\| ir9==`CPY_IMM32;
289	5	robfinch	`wire isRMW32 =`
290	32	robfinch	ir9==`ASL_ZPX \|\| ir9==`ROL_ZPX \|\| ir9==`LSR_ZPX \|\| ir9==`ROR_ZPX \|\| ir9==`INC_ZPX \|\| ir9==`DEC_ZPX \|\|
291			ir9==`ASL_ABS \|\| ir9==`ROL_ABS \|\| ir9==`LSR_ABS \|\| ir9==`ROR_ABS \|\| ir9==`INC_ABS \|\| ir9==`DEC_ABS \|\|
292			ir9==`ASL_ABSX \|\| ir9==`ROL_ABSX \|\| ir9==`LSR_ABSX \|\| ir9==`ROR_ABSX \|\| ir9==`INC_ABSX \|\| ir9==`DEC_ABSX \|\|
293			ir9==`TRB_ZP \|\| ir9==`TRB_ZPX \|\| ir9==`TRB_ABS \|\| ir9==`TSB_ZP \|\| ir9==`TSB_ZPX \|\| ir9==`TSB_ABS \|\|
294			ir9==`BMS_ZPX \|\| ir9==`BMS_ABS \|\| ir9==`BMS_ABSX \|\|
295			ir9==`BMC_ZPX \|\| ir9==`BMC_ABS \|\| ir9==`BMC_ABSX \|\|
296			ir9==`BMF_ZPX \|\| ir9==`BMF_ABS \|\| ir9==`BMF_ABSX
297	5	robfinch	`;`
298			`wire isRMW8 =`
299	32	robfinch	ir9==`ASL_ZP \|\| ir9==`ROL_ZP \|\| ir9==`LSR_ZP \|\| ir9==`ROR_ZP \|\| ir9==`INC_ZP \|\| ir9==`DEC_ZP \|\|
300			ir9==`ASL_ZPX \|\| ir9==`ROL_ZPX \|\| ir9==`LSR_ZPX \|\| ir9==`ROR_ZPX \|\| ir9==`INC_ZPX \|\| ir9==`DEC_ZPX \|\|
301			ir9==`ASL_ABS \|\| ir9==`ROL_ABS \|\| ir9==`LSR_ABS \|\| ir9==`ROR_ABS \|\| ir9==`INC_ABS \|\| ir9==`DEC_ABS \|\|
302			ir9==`ASL_ABSX \|\| ir9==`ROL_ABSX \|\| ir9==`LSR_ABSX \|\| ir9==`ROR_ABSX \|\| ir9==`INC_ABSX \|\| ir9==`DEC_ABSX \|\|
303			ir9==`TRB_ZP \|\| ir9==`TRB_ZPX \|\| ir9==`TRB_ABS \|\| ir9==`TSB_ZP \|\| ir9==`TSB_ZPX \|\| ir9==`TSB_ABS;
304	5	robfinch	`;`
305	30	robfinch
306			`// Registerable decodes`
307			`// The following decodes can be registered because they aren't needed until at least the cycle after`
308			`// the DECODE stage.`
309
310			`always @(posedge clk)`
311	32	robfinch	`if (state==DECODE\|\|state==BYTE_DECODE) begin`
312			isSub <= ir9==`SUB_ZPX \|\| ir9==`SUB_IX \|\| ir9==`SUB_IY \|\|
313			ir9==`SUB_ABS \|\| ir9==`SUB_ABSX \|\| ir9==`SUB_IMM8 \|\| ir9==`SUB_IMM16 \|\| ir9==`SUB_IMM32;
314			isSub8 <= ir9==`SBC_ZP \|\| ir9==`SBC_ZPX \|\| ir9==`SBC_IX \|\| ir9==`SBC_IY \|\| ir9==`SBC_I \|\|
315			ir9==`SBC_ABS \|\| ir9==`SBC_ABSX \|\| ir9==`SBC_ABSY \|\| ir9==`SBC_IMM;
316	30	robfinch	`isRMW <= em ? isRMW8 : isRMW32;`
317	32	robfinch	isOrb <= ir9==`ORB_ZPX \|\| ir9==`ORB_IX \|\| ir9==`ORB_IY \|\| ir9==`ORB_ABS \|\| ir9==`ORB_ABSX;
318			isStb <= ir9==`STB_ZPX \|\| ir9==`STB_ABS \|\| ir9==`STB_ABSX;
319			isRTI <= ir9==`RTI;
320			isRTL <= ir9==`RTL;
321			isRTS <= ir9==`RTS;
322			isBrk <= ir9==`BRK;
323			isMove <= ir9==`MVP \|\| ir9==`MVN;
324			isSts <= ir9==`STS;
325			isJsrIndx <= ir9==`JSR_INDX;
326			isJsrInd <= ir9==`JSR_IND;
327	35	robfinch	ldMuldiv <= ir9==`MUL_IMM8 \|\| ir9==`MUL_IMM16 \|\| ir9==`MUL_IMM32 \|\|
328			ir9==`DIV_IMM8 \|\| ir9==`MOD_IMM8 \|\| ir9==`DIV_IMM16 \|\| ir9==`DIV_IMM32 \|\| ir9==`MOD_IMM16 \|\| ir9==`MOD_IMM32 \|\|
329			(ir9==`RR && (
330	32	robfinch	ir[23:20]==`MUL_RR \|\| ir[23:20]==`MULS_RR \|\| ir[23:20]==`DIV_RR \|\| ir[23:20]==`DIVS_RR \|\| ir[23:20]==`MOD_RR \|\| ir[23:20]==`MODS_RR));
331			isPusha <= ir9==`PUSHA;
332			isPopa <= ir9==`POPA;
333	30	robfinch	`end`
334	32	robfinch	`else`
335			`ldMuldiv <= 1'b0;`
336	30	robfinch
337			`ifdef SUPPORT_EXEC
338	32	robfinch	wire isExec = ir9==`EXEC;
339			wire isAtni = ir9==`ATNI;
340	30	robfinch	`else
341			`wire isExec = 1'b0;`
342			`wire isAtni = 1'b0;`
343			`endif
344	12	robfinch	`wire md_done;`
345			`wire clk;`
346	21	robfinch	`reg isIY;`
347	38	robfinch	`reg isIY24;`
348			`reg isI24;`
349	12	robfinch
350	30	robfinch	`rtf65002_pcinc upci1`
351			`(`
352	32	robfinch	`.opcode(ir9),`
353	30	robfinch	`.suppress_pcinc(suppress_pcinc),`
354			`.inc(pc_inc)`
355			`);`
356
357	32	robfinch	`rtf65002_pcinc8 upci2`
358			`(`
359			`.opcode(ir[7:0]),`
360			`.suppress_pcinc(suppress_pcinc),`
361	38	robfinch	`.inc(pc_inc8),`
362			`.m16(m16),`
363			`.xb16(xb16)`
364	32	robfinch	`);`
365	35	robfinch
366	12	robfinch	`mult_div umd1`
367			`(`
368	30	robfinch	`.rst(rst_i),`
369	12	robfinch	`.clk(clk),`
370	32	robfinch	`.ld(ldMuldiv),`
371			`.op(ir9),`
372			`.fn(ir[23:20]),`
373			`.a(a),`
374			`.b(b),`
375	12	robfinch	`.p(prod),`
376			`.q(q),`
377			`.r(r),`
378			`.done(md_done)`
379			`);`
380	30	robfinch
381	32	robfinch	`ifdef SUPPORT_ICACHE
382			`ifdef ICACHE_2WAY
383			`rtf65002_icachemem2way icm0 (`
384			`.whichrd(whichrd),`
385			`.whichwr(whichwr),`
386			`.wclk(clk),`
387			`.wr(ack_i & isInsnCacheLoad),`
388			`.adr(adr_o),`
389			`.dat(dat_i),`
390			`.rclk(~clk),`
391			`.pc(pc),`
392			`.insn(insn)`
393			`);`
394
395			`rtf65002_itagmem2way tgm0 (`
396			`.whichrd(whichrd),`
397			`.whichwr(isCacheReset ? adr_o[13]: whichwr),`
398			`.wclk(clk),`
399			`.wr((ack_i & isInsnCacheLoad)\|isCacheReset),`
400			`.adr({adr_o[31:1],!isCacheReset}),`
401			`.rclk(~clk),`
402			`.pc(pc),`
403			`.hit0(hit0),`
404			`.hit1(hit1)`
405			`);`
406			`else
407			`ifdef ICACHE_4K
408			`rtf65002_icachemem4k icm0 (`
409			`.wclk(clk),`
410			`.wr(ack_i & isInsnCacheLoad),`
411			`.adr(adr_o),`
412			`.dat(dat_i),`
413			`.rclk(~clk),`
414			`.pc(pc),`
415			`.insn(insn)`
416			`);`
417
418			`rtf65002_itagmem4k tgm0 (`
419			`.wclk(clk),`
420			`.wr((ack_i & isInsnCacheLoad)\|isCacheReset),`
421	35	robfinch	`.adr({adr_o[33:1],!isCacheReset}),`
422	32	robfinch	`.rclk(~clk),`
423			`.pc(pc),`
424			`.hit0(hit0),`
425			`.hit1(hit1)`
426			`);`
427			`endif
428			`ifdef ICACHE_8K
429			`rtf65002_icachemem8k icm0 (`
430			`.wclk(clk),`
431			`.wr(ack_i & isInsnCacheLoad),`
432			`.adr(adr_o),`
433			`.dat(dat_i),`
434			`.rclk(~clk),`
435			`.pc(pc),`
436			`.insn(insn)`
437			`);`
438
439			`rtf65002_itagmem8k tgm0 (`
440			`.wclk(clk),`
441			`.wr((ack_i & isInsnCacheLoad)\|isCacheReset),`
442	35	robfinch	`.adr({adr_o[33:1],!isCacheReset}),`
443	32	robfinch	`.rclk(~clk),`
444			`.pc(pc),`
445			`.hit0(hit0),`
446			`.hit1(hit1)`
447			`);`
448			`endif
449			`ifdef ICACHE_16K
450	30	robfinch	`rtf65002_icachemem icm0 (`
451	12	robfinch	`.wclk(clk),`
452	5	robfinch	`.wr(ack_i & isInsnCacheLoad),`
453			`.adr(adr_o),`
454			`.dat(dat_i),`
455	30	robfinch	`.rclk(~clk),`
456	5	robfinch	`.pc(pc),`
457			`.insn(insn)`
458			`);`
459
460	30	robfinch	`rtf65002_itagmem tgm0 (`
461	12	robfinch	`.wclk(clk),`
462	10	robfinch	`.wr((ack_i & isInsnCacheLoad)\|isCacheReset),`
463			`.adr({adr_o[31:1],!isCacheReset}),`
464	30	robfinch	`.rclk(~clk),`
465	5	robfinch	`.pc(pc),`
466			`.hit0(hit0),`
467			`.hit1(hit1)`
468			`);`
469	32	robfinch	`endif
470			`endif // ICACHE_2WAY
471	5	robfinch
472			`wire ihit = (hit0 & hit1);//(pc[2:0] > 3'd1 ? hit1 : 1'b1));`
473	30	robfinch	`else
474			`wire ihit = 1'b0;`
475			`endif
476	5	robfinch
477	30	robfinch	`ifdef SUPPORT_DCACHE
478	32	robfinch	`assign wr = state==STORE2 && dhit && ack_i;`
479
480	30	robfinch	`rtf65002_dcachemem dcm0 (`
481	12	robfinch	`.wclk(clk),`
482	5	robfinch	`.wr(wr \| (ack_i & isDataCacheLoad)),`
483	32	robfinch	`.sel(sel_o),`
484			`.wadr(adr_o[33:2]),`
485			`.wdat(wr ? dat_o : dat_i),`
486	30	robfinch	`.rclk(~clk),`
487	5	robfinch	`.radr(radr),`
488			`.rdat(rdat)`
489			`);`
490
491	30	robfinch	`rtf65002_dtagmem dtm0 (`
492	12	robfinch	`.wclk(clk),`
493	32	robfinch	`.wr(wr \| (ack_i & isDataCacheLoad) \| isCacheReset),`
494			`.wadr(adr_o[33:2]),`
495			`.cr(!isCacheReset),`
496	30	robfinch	`.rclk(~clk),`
497	5	robfinch	`.radr(radr),`
498			`.hit(dhit)`
499			`);`
500	30	robfinch	`endif

Browse

Tools

Subversion Repositories rtf65002

[/] [rtf65002/] [trunk/] [rtl/] [verilog/] [rtf65002d.v] - Blame information for rev 38