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

Subversion Repositories t6507lp

[/] [t6507lp/] [trunk/] [rtl/] [verilog/] [t6507lp_fsm.v] - Blame information for rev 103

Go to most recent revision | Details | Compare with Previous | View Log


////////////////////////////////////////////////////////////////////////////
////                                                                    ////
//// T6507LP IP Core                                                    ////
////                                                                    ////
//// This file is part of the T6507LP project                           ////
//// http://www.opencores.org/cores/t6507lp/                            ////
////                                                                    ////
//// Description                                                        ////
//// 6507 FSM                                                           ////
////                                                                    ////
//// TODO:                                                              ////
//// - Fix relative mode, bit 7 means negative                          ////
//// - Code the indirect indexed mode                                   ////
//// - Code the absolute indirect mode                                  ////
////                                                                    ////
//// Author(s):                                                         ////
//// - Gabriel Oshiro Zardo, gabrieloshiro@gmail.com                    ////
//// - Samuel Nascimento Pagliarini (creep), snpagliarini@gmail.com     ////
////                                                                    ////
////////////////////////////////////////////////////////////////////////////
////                                                                    ////
//// Copyright (C) 2001 Authors and OPENCORES.ORG                       ////
////                                                                    ////
//// This source file may be used and distributed without               ////
//// restriction provided that this copyright statement is not          ////
//// removed from the file and that any derivative work contains        ////
//// the original copyright notice and the associated disclaimer.       ////
////                                                                    ////
//// 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 2.1 of the License, or (at your option) any         ////
//// later version.                                                     ////
////                                                                    ////
//// This source 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 Lesser General Public License for more        ////
//// details.                                                           ////
////                                                                    ////
//// You should have received a copy of the GNU Lesser General          ////
//// Public License along with this source; if not, download it         ////
//// from http://www.opencores.org/lgpl.shtml                           ////
////                                                                    ////
////////////////////////////////////////////////////////////////////////////
 
`timescale 1ns / 1ps
 
module t6507lp_fsm(clk, reset_n, alu_result, alu_status, data_in, address, control, data_out, alu_opcode, alu_a, alu_enable, alu_x, alu_y);
        parameter DATA_SIZE = 8;
        parameter ADDR_SIZE = 13;
 
        localparam DATA_SIZE_ = DATA_SIZE - 4'b0001;
        localparam ADDR_SIZE_ = ADDR_SIZE - 4'b0001;
 
        input clk;
        input reset_n;
        input [DATA_SIZE_:0] alu_result;
        input [DATA_SIZE_:0] alu_status;
        input [DATA_SIZE_:0] data_in;
        output reg [ADDR_SIZE_:0] address;
        output reg control; // one bit is enough? read = 0, write = 1
        output reg [DATA_SIZE_:0] data_out;
        output reg [DATA_SIZE_:0] alu_opcode;
        output reg [DATA_SIZE_:0] alu_a;
        output reg alu_enable;
 
        input [DATA_SIZE_:0] alu_x;
        input [DATA_SIZE_:0] alu_y;
 
        // FSM states
        localparam FETCH_OP = 5'b00000;
        localparam FETCH_OP_CALC = 5'b00001;
        localparam FETCH_LOW = 5'b00010;
        localparam FETCH_HIGH = 5'b00011;
        localparam READ_MEM = 5'b00100;
        localparam DUMMY_WRT_CALC = 5'b00101;
        localparam WRITE_MEM = 5'b00110;
        localparam FETCH_OP_CALC_PARAM = 5'b00111;
        localparam READ_MEM_CALC_INDEX = 5'b01000;
        localparam FETCH_HIGH_CALC_INDEX = 5'b01001;
        localparam READ_MEM_FIX_ADDR = 5'b01010;
        localparam FETCH_OP_EVAL_BRANCH = 5'b01011;
        localparam FETCH_OP_FIX_PC = 5'b01100;
        localparam READ_FROM_POINTER = 5'b01101;
        localparam READ_FROM_POINTER_X = 5'b01110;
        localparam READ_FROM_POINTER_X1 = 5'b01111;
 
        localparam RESET = 5'b11111;
 
        // OPCODES TODO: verify how this get synthesised
        `include "../T6507LP_Package.v"
 
        // control signals
        localparam MEM_READ = 1'b0;
        localparam MEM_WRITE = 1'b1;
 
        reg [ADDR_SIZE_:0] pc;           // program counter
        reg [ADDR_SIZE_:0] sp;           // stack pointer
        reg [DATA_SIZE_:0] ir;           // instruction register
        reg [ADDR_SIZE_:0] temp_addr;    // temporary address
        reg [DATA_SIZE_:0] temp_data;    // temporary data
 
        reg [4:0] state, next_state; // current and next state registers
        // TODO: not sure if this will be 4 bits wide. as of march 9th this was 4bit wide.
 
        // wiring that simplifies the FSM logic
        reg absolute;
        reg absolute_indexed;
        reg accumulator;
        reg immediate;
        reg implied;
        reg indirectx;
        reg indirecty;
        reg relative;
        reg zero_page;
        reg zero_page_indexed;
        reg [DATA_SIZE_:0] index; // will be assigned with either X or Y
 
        // regs that store the type of operation. again, this simplifies the FSM a lot.
        reg read;
        reg read_modify_write;
        reg write;
        reg jump;
        reg jump_indirect;
 
        wire [ADDR_SIZE_:0] next_pc;
        assign next_pc = pc + 13'b0000000000001;
 
        reg [ADDR_SIZE_:0] address_plus_index; // this would update more times than actually needed, consuming power.
        reg page_crossed;                       // so the simple assign was changed into a combinational always block
 
        reg branch;
 
        always @(*) begin
                address_plus_index = 0;
                page_crossed = 0;
 
                if (state == READ_MEM_CALC_INDEX || state == READ_MEM_FIX_ADDR || state == FETCH_HIGH_CALC_INDEX) begin
                        {page_crossed, address_plus_index[7:0]} = temp_addr[7:0] + index;
                        address_plus_index[12:8] = temp_addr[12:8] + page_crossed;
                end
                else if (branch) begin
                        if (state == FETCH_OP_FIX_PC || state == FETCH_OP_EVAL_BRANCH) begin
                                {page_crossed, address_plus_index[7:0]} = pc[7:0] + index;
                                address_plus_index[12:8] = pc[12:8] + page_crossed;// warning: pc might feed these lines twice and cause branch failure
                        end                                                             // solution: add a temp reg i guess
                end
                else if (state == READ_FROM_POINTER) begin
                        if (indirectx) begin
                                {page_crossed, address_plus_index[7:0]} = temp_data + index;
                                address_plus_index[12:8] = 5'b00000;
                        end
                        else if (jump_indirect) begin
                                address_plus_index[7:0] = temp_addr + 8'h01;
                                address_plus_index[12:8] = 5'b00000;
                        end
                        else begin // indirecty falls here
                                address_plus_index[7:0] = temp_data + 8'h01;
                                address_plus_index[12:8] = 5'b00000;
                        end
                end
                else if (state == READ_FROM_POINTER_X) begin
                        {page_crossed, address_plus_index[7:0]} = temp_data + index + 8'h01;
                        address_plus_index[12:8] = 5'b00000;
                end
                else if (state == READ_FROM_POINTER_X1) begin
                        {page_crossed, address_plus_index[7:0]} = temp_addr[7:0] + index;
                        address_plus_index[12:8] = temp_addr[12:8] + page_crossed;
                end
        end
 
        wire [8:0] sp_plus_one;
        assign sp_plus_one = sp + 9'b000000001;
 
        wire [8:0] sp_minus_one;
        assign sp_minus_one = sp - 9'b000000001;
 
        always @ (posedge clk or negedge reset_n) begin // sequencial always block
                if (reset_n == 1'b0) begin
                        // all registers must assume default values
                        pc <= 0; // TODO: this is written somewhere. something about a reset vector. must be checked.
                        sp <= 9'b100000000; // the default is 'h100 
                        ir <= 8'h00;
                        temp_addr <= 13'h00;
                        temp_data <= 8'h00;
                        state <= RESET;
                        // registered outputs also receive default values
                        address <= 0;
                        control <= MEM_READ;
                        data_out <= 8'h00;
                end
                else begin
                        state <= next_state;
 
                        case (state)
                                RESET: begin
                                        // The processor was reset
                                        $write("under reset");
                                end
                                FETCH_OP: begin // this state is the simplest one. it is a simple fetch that must be done when the cpu was reset or
                                                // the last cycle was a memory write.
                                        pc <= next_pc;
                                        address <= next_pc;
                                        control <= MEM_READ;
                                        ir <= data_in;
                                end
                                FETCH_OP_CALC, FETCH_OP_CALC_PARAM: begin // this is the pipeline happening!
                                        pc <= next_pc;
                                        address <= next_pc;
                                        control <= MEM_READ;
                                        ir <= data_in;
                                end
                                FETCH_LOW: begin // in this state the opcode is already known so truly execution begins
                                        if (accumulator || implied) begin
                                                pc <= pc; // is this better?
                                                address <= pc;
                                                control <= MEM_READ;
                                        end
                                        else if (immediate || relative) begin
                                                pc <= next_pc;
                                                address <= next_pc;
                                                control <= MEM_READ;
                                                temp_data <= data_in; // the follow-up byte is saved in temp_data 
                                        end
                                        else if (absolute || absolute_indexed || jump_indirect) begin
                                                pc <= next_pc;
                                                address <= next_pc;
                                                control <= MEM_READ;
                                                temp_addr <= {{5{1'b0}},data_in};
                                                temp_data <= 8'h00;
                                        end
                                        else if (zero_page) begin
                                                pc <= next_pc;
                                                address <= {{5{1'b0}},data_in};
                                                temp_addr <= {{5{1'b0}},data_in};
 
                                                if (write) begin
                                                        control <= MEM_WRITE;
                                                        data_out <= alu_result;
                                                end
                                                else begin
                                                        control <= MEM_READ;
                                                        data_out <= 8'h00;
                                                end
                                        end
                                        else if (zero_page_indexed) begin
                                                pc <= next_pc;
                                                address <= {{5{1'b0}}, data_in};
                                                temp_addr <= {{5{1'b0}}, data_in};
                                                control <= MEM_READ;
                                        end
                                        else if (indirectx || indirecty) begin
                                                pc <= next_pc;
                                                address <= data_in;
                                                temp_data <= data_in;
                                                control <= MEM_READ;
                                        end
                                        else begin // the special instructions will fall here: BRK, RTI, RTS...
 
                                        end
                                end
                                FETCH_HIGH_CALC_INDEX: begin
                                        pc <= next_pc;
                                        temp_addr[12:8] <= data_in[4:0];
                                        address <= {data_in[4:0], address_plus_index[7:0]};
                                        control <= MEM_READ;
                                        data_out <= 8'h00;
                                end
                                FETCH_OP_EVAL_BRANCH: begin
                                        if (branch) begin
                                                pc <= {{5{1'b0}}, address_plus_index[7:0]};
                                                address <= {{5{1'b0}}, address_plus_index[7:0]};
                                                control <= MEM_READ;
                                                data_out <= 8'h00;
                                        end
                                        else begin
                                                pc <= next_pc;
                                                address <= next_pc;
                                                control <= MEM_READ;
                                                data_out <= 8'h00;
                                                ir <= data_in;
                                        end
                                end
                                FETCH_OP_FIX_PC: begin
                                        if (page_crossed) begin
                                                pc[12:8] <= address_plus_index[12:8];
                                                address[12:8] <= address_plus_index[12:8];
                                        end
                                        else begin
                                                pc <= next_pc;
                                                address <= next_pc;
                                                control <= MEM_READ;
                                                ir <= data_in;
                                        end
                                end
                                FETCH_HIGH: begin
                                        if (jump) begin
                                                pc <= {data_in[4:0], temp_addr[7:0]}; // PCL <= first byte, PCH <= second byte
                                                address <= {data_in[4:0], temp_addr[7:0]};
                                                control <= MEM_READ;
                                                data_out <= 8'h00;
                                        end
                                        else begin
                                                if (write) begin
                                                        pc <= next_pc;
                                                        temp_addr[12:8] <= data_in[4:0];
                                                        address <= {data_in[4:0],temp_addr[7:0]};
                                                        control <= MEM_WRITE;
                                                        data_out <= alu_result;
                                                end
                                                else begin // read_modify_write or just read
                                                        pc <= next_pc;
                                                        temp_addr[12:8] <= data_in[4:0];
                                                        address <= {data_in[4:0],temp_addr[7:0]};
                                                        control <= MEM_READ;
                                                        data_out <= 8'h00;
                                                end
                                        end
                                        //else begin
                                        //      $write("FETCHHIGH PROBLEM"); 
                                        //      $finish(0); 
                                        //end
                                end
                                READ_MEM: begin
                                        if (read_modify_write) begin
                                                pc <= pc;
                                                address <= temp_addr;
                                                control <= MEM_WRITE;
                                                temp_data <= data_in;
                                                data_out <= data_in; // writeback the same value
                                        end
                                        else begin
                                                pc <= pc;
                                                address <= pc;
                                                temp_data <= data_in;
                                                control <= MEM_READ;
                                                data_out <= 8'h00;
                                        end
                                end
                                READ_MEM_CALC_INDEX: begin
                                                //pc <= next_pc; // pc was  already updated in the previous cycle
                                                address <= address_plus_index;
                                                temp_addr <= address_plus_index;
 
                                                if (write) begin
                                                        control <= MEM_WRITE;
                                                        data_out <= alu_result;
                                                end
                                                else begin
                                                        control <= MEM_READ;
                                                        data_out <= 8'h00;
                                                end
 
                                end
                                READ_MEM_FIX_ADDR: begin
                                        if (read) begin
                                                control <= MEM_READ;
                                                data_out <= 8'h00;
 
                                                if (page_crossed) begin
                                                        address <= address_plus_index;
                                                        temp_addr <= address_plus_index;
                                                end
                                                else begin
                                                        address <= pc;
                                                        temp_data <= data_in;
                                                end
                                        end
                                        else if (write) begin
                                                control <= MEM_WRITE;
                                                data_out <= alu_result;
                                                address <= address_plus_index;
                                                temp_addr <= address_plus_index;
 
                                        end
                                        else begin // read modify write
                                                control <= MEM_READ;
                                                data_out <= 8'h00;
                                                address <= address_plus_index;
                                                temp_addr <= address_plus_index;
                                        end
                                end
                                DUMMY_WRT_CALC: begin
                                        pc <= pc;
                                        address <= temp_addr;
                                        control <= MEM_WRITE;
                                        data_out <= alu_result;
                                end
                                WRITE_MEM: begin
                                        pc <= pc;
                                        address <= pc;
                                        control <= MEM_READ;
                                        data_out <= 8'h00;
                                end
                                READ_FROM_POINTER: begin
                                        if (jump_indirect) begin
                                                pc[7:0] <= data_in;
                                                control <= MEM_READ;
                                                address <= address_plus_index;
                                        end
                                        else begin
                                                pc <= pc;
                                                control <= MEM_READ;
 
                                                if (indirectx) begin
                                                        address <= address_plus_index;
                                                end
                                                else begin // indirecty falls here
                                                        address <= address_plus_index;
                                                        temp_addr <= {{5{1'b0}}, data_in};
                                                end
                                        end
                                end
                                READ_FROM_POINTER_X: begin
                                        pc <= pc;
                                        address <= address_plus_index;
                                        temp_addr[7:0] <= data_in;
                                        control <= MEM_READ;
                                end
                                READ_FROM_POINTER_X1: begin
                                        if (jump_indirect) begin
                                                pc[12:8] <= data_in[4:0];
                                                control <= MEM_READ;
                                                address <= {data_in[4:0], pc[7:0]};
                                        end
                                        else if (indirectx) begin
                                                address <= {data_in[4:0], temp_addr[7:0]};
                                                if (write) begin
                                                        control <= MEM_WRITE;
                                                        data_out <= alu_result;
                                                end
                                                else begin
                                                        control <= MEM_READ;
                                                end
                                        end
                                        else begin // indirecty falls here
                                                address <= address_plus_index;
                                                temp_addr[12:8] <= data_in;
                                                control <= MEM_READ;
                                        end
                                end
                                default: begin
                                        $write("unknown state"); // TODO: check if synth really ignores this 2 lines. Otherwise wrap it with a `ifdef 
                                        $finish(0);
                                end
 
                        endcase
                end
        end
 
        always @ (*) begin // this is the next_state logic and the output logic always block
                alu_opcode = 8'h00;
                alu_a = 8'h00;
                alu_enable = 1'b0;
 
                next_state = RESET; // this prevents the latch
 
                case (state)
                        RESET: begin
                                next_state = FETCH_OP;
                        end
                        FETCH_OP: begin
                                next_state = FETCH_LOW;
                        end
                        //FETCH_OP_CALC: begin // so far no addressing mode required the use of this state
                        //      next_state = FETCH_LOW;
                        //      alu_opcode = ir;
                        //      alu_enable = 1'b1;
                        //end
                        FETCH_OP_CALC_PARAM: begin
                                next_state = FETCH_LOW;
                                alu_opcode = ir;
                                alu_enable = 1'b1;
                                alu_a = temp_data;
                        end
                        FETCH_LOW: begin
                                if (accumulator  || implied) begin
                                        alu_opcode = ir;
                                        alu_enable = 1'b1;
                                        next_state = FETCH_OP;
                                end
                                else if (immediate) begin
                                        next_state = FETCH_OP_CALC_PARAM;
                                end
                                else if (zero_page) begin
                                        if (read || read_modify_write) begin
                                                next_state = READ_MEM;
                                        end
                                        else if (write) begin
                                                next_state = WRITE_MEM;
                                                alu_opcode = ir;
                                                alu_enable = 1'b1;
                                                alu_a = 8'h00;
                                        end
                                        else begin
                                                $write("unknown behavior");
                                                $finish(0);
                                        end
                                end
                                else if (zero_page_indexed) begin
                                        next_state = READ_MEM_CALC_INDEX;
                                end
                                else if (absolute || jump_indirect) begin // at least the absolute address mode falls here
                                        next_state = FETCH_HIGH;
                                        if (write) begin // this is being done one cycle early but i have checked and the ALU will still work properly
                                                alu_opcode = ir;
                                                alu_enable = 1'b1;
                                                alu_a = 8'h00;
                                        end
                                end
                                else if (absolute_indexed) begin
                                        next_state = FETCH_HIGH_CALC_INDEX;
                                end
                                else if (relative) begin
                                        next_state = FETCH_OP_EVAL_BRANCH;
                                end
                                else if (indirectx || indirecty) begin
                                        next_state = READ_FROM_POINTER;
                                end
                                else begin // all the special instructions will fall here
                                        next_state = RESET;
                                end
                        end
                        READ_FROM_POINTER: begin
                                if (indirectx) begin
                                        next_state = READ_FROM_POINTER_X;
                                end
                                else begin // indirecty and jump indirect falls here
                                        next_state = READ_FROM_POINTER_X1;
                                end
                        end
                        READ_FROM_POINTER_X: begin
                                next_state = READ_FROM_POINTER_X1;
                        end
                        READ_FROM_POINTER_X1: begin
                                if (jump_indirect) begin
                                        next_state = FETCH_OP;
                                end
                                else if (indirecty) begin
                                        next_state = READ_MEM_FIX_ADDR;
                                end
                                else begin
                                        if (read) begin // read_modify_write was showing up here for no reason. no instruction using pointers is from that type.
                                                next_state = READ_MEM;
                                        end
                                        else if (write) begin
                                                alu_opcode = ir;
                                                alu_enable = 1'b1;
                                                next_state = WRITE_MEM;
                                        end
                                end
                        end
                        FETCH_OP_EVAL_BRANCH: begin
                                if (branch) begin
                                        next_state = FETCH_OP_FIX_PC;
                                end
                                else begin
                                        next_state = FETCH_LOW;
                                end
                        end
                        FETCH_OP_FIX_PC: begin
                                if (page_crossed) begin
                                        next_state = FETCH_OP;
                                end
                                else begin
                                        next_state = FETCH_LOW;
                                end
                        end
                        FETCH_HIGH_CALC_INDEX: begin
                                next_state = READ_MEM_FIX_ADDR;
                        end
                        READ_MEM_FIX_ADDR: begin
                                if (read) begin
                                        if (page_crossed) begin
                                                next_state = READ_MEM;
                                        end
                                        else begin
                                                next_state = FETCH_OP_CALC_PARAM;
                                        end
                                end
                                else if (read_modify_write) begin
                                        next_state = READ_MEM;
                                end
                                else if (write) begin
                                        next_state = WRITE_MEM;
                                        alu_enable = 1'b1;
                                        alu_opcode = ir;
                                end
                                else begin
                                        $write("unknown behavior");
                                        $finish(0);
                                end
                        end
                        FETCH_HIGH: begin
                                if (jump_indirect) begin
                                        next_state = READ_FROM_POINTER;
                                end
                                else if (jump) begin
                                        next_state = FETCH_OP;
                                end
                                else if (read || read_modify_write) begin
                                        next_state = READ_MEM;
                                end
                                else if (write) begin
                                        next_state = WRITE_MEM;
                                end
                                else begin
                                        $write("unknown behavior");
                                        $finish(0);
                                end
                        end
                        READ_MEM_CALC_INDEX: begin
                                if (read || read_modify_write) begin
                                        next_state = READ_MEM;
                                end
                                else if (write) begin
                                        alu_opcode = ir;
                                        alu_enable = 1'b1;
                                        next_state = WRITE_MEM;
                                end
                                else begin
                                        $write("unknown behavior");
                                        $finish(0);
                                end
                        end
                        READ_MEM: begin
                                if (read) begin
                                        next_state = FETCH_OP_CALC_PARAM;
                                end
                                else if (read_modify_write) begin
                                        next_state = DUMMY_WRT_CALC;
                                end
                        end
                        DUMMY_WRT_CALC: begin
                                alu_opcode = ir;
                                alu_enable = 1'b1;
                                alu_a = data_in;
                                next_state = WRITE_MEM;
                        end
                        WRITE_MEM: begin
                                next_state = FETCH_OP;
                        end
                        default: begin
                                next_state = RESET;
                        end
                endcase
        end
 
        // this always block is responsible for updating the address mode and the type of operation being done
        always @ (*) begin // 
                absolute = 1'b0;
                absolute_indexed = 1'b0;
                accumulator = 1'b0;
                immediate = 1'b0;
                implied = 1'b0;
                indirectx = 1'b0;
                indirecty = 1'b0;
                relative = 1'b0;
                zero_page = 1'b0;
                zero_page_indexed = 1'b0;
 
                index = 1'b0;
 
                read = 1'b0;
                read_modify_write = 1'b0;
                write = 1'b0;
                jump = 1'b0;
                jump_indirect = 1'b0;
                branch = 1'b0;
 
                case (ir)
                        CLC_IMP, CLD_IMP, CLI_IMP, CLV_IMP, DEX_IMP, DEY_IMP, INX_IMP, INY_IMP, NOP_IMP, PHA_IMP, PHP_IMP, PLA_IMP,
                        PLP_IMP, RTI_IMP, RTS_IMP, SEC_IMP, SED_IMP, SEI_IMP, TAX_IMP, TAY_IMP, TSX_IMP, TXA_IMP, TXS_IMP, TYA_IMP: begin
                                implied = 1'b1;
                        end
                        ASL_ACC, LSR_ACC, ROL_ACC, ROR_ACC: begin
                                accumulator = 1'b1;
                        end
                        ADC_IMM, AND_IMM, CMP_IMM, CPX_IMM, CPY_IMM, EOR_IMM, LDA_IMM, LDX_IMM, LDY_IMM, ORA_IMM, SBC_IMM: begin
                                immediate = 1'b1;
                        end
                        ADC_ZPG, AND_ZPG, ASL_ZPG, BIT_ZPG, CMP_ZPG, CPX_ZPG, CPY_ZPG, DEC_ZPG, EOR_ZPG, INC_ZPG, LDA_ZPG, LDX_ZPG, LDY_ZPG,
                        LSR_ZPG, ORA_ZPG, ROL_ZPG, ROR_ZPG, SBC_ZPG, STA_ZPG, STX_ZPG, STY_ZPG: begin
                                zero_page = 1'b1;
                        end
                        ADC_ZPX, AND_ZPX, ASL_ZPX, CMP_ZPX, DEC_ZPX, EOR_ZPX, INC_ZPX, LDA_ZPX, LDY_ZPX, LSR_ZPX, ORA_ZPX, ROL_ZPX, ROR_ZPX,
                        SBC_ZPX, STA_ZPX, STY_ZPX: begin
                                zero_page_indexed = 1'b1;
                                index = alu_x;
                        end
                        LDX_ZPY, STX_ZPY: begin
                                zero_page_indexed = 1'b1;
                                index = alu_y;
                        end
                        BCC_REL: begin
                                relative = 1'b1;
                                index = temp_data;
 
                                if (!alu_status[C]) begin
                                        branch = 1'b1;
                                end
                                else begin
                                        branch = 1'b0;
                                end
                        end
                        BCS_REL: begin
                                relative = 1'b1;
                                index = temp_data;
 
                                if (alu_status[C]) begin
                                        branch = 1'b1;
                                end
                                else begin
                                        branch = 1'b0;
                                end
                        end
                        BEQ_REL: begin
                                relative = 1'b1;
                                index = temp_data;
 
                                if (alu_status[Z]) begin
                                        branch = 1'b1;
                                end
                                else begin
                                        branch = 1'b0;
                                end
                        end
                        BNE_REL: begin
                                relative = 1'b1;
                                index = temp_data;
 
                                if (alu_status[Z] == 1'b0) begin
                                        branch = 1'b1;
                                end
                                else begin
                                        branch = 1'b0;
                                end
                        end
                        BPL_REL: begin
                                relative = 1'b1;
                                index = temp_data;
 
                                if (!alu_status[N]) begin
                                        branch = 1'b1;
                                end
                                else begin
                                        branch = 1'b0;
                                end
                        end
                        BMI_REL: begin
                                relative = 1'b1;
                                index = temp_data;
 
                                if (alu_status[N]) begin
                                        branch = 1'b1;
                                end
                                else begin
                                        branch = 1'b0;
                                end
                        end
                        BVC_REL: begin
                                relative = 1'b1;
                                index = temp_data;
 
                                if (!alu_status[V]) begin
                                        branch = 1'b1;
                                end
                                else begin
                                        branch = 1'b0;
                                end
                        end
                        BVS_REL: begin
                                relative = 1'b1;
                                index = temp_data;
 
                                if (alu_status[V]) begin
                                        branch = 1'b1;
                                end
                                else begin
                                        branch = 1'b0;
                                end
                        end
                        ADC_ABS, AND_ABS, ASL_ABS, BIT_ABS, CMP_ABS, CPX_ABS, CPY_ABS, DEC_ABS, EOR_ABS, INC_ABS, JSR_ABS, LDA_ABS,
                        LDX_ABS, LDY_ABS, LSR_ABS, ORA_ABS, ROL_ABS, ROR_ABS, SBC_ABS, STA_ABS, STX_ABS, STY_ABS: begin
                                absolute = 1'b1;
                        end
                        ADC_ABX, AND_ABX, ASL_ABX, CMP_ABX, DEC_ABX, EOR_ABX, INC_ABX, LDA_ABX, LDY_ABX, LSR_ABX, ORA_ABX, ROL_ABX, ROR_ABX,
                        SBC_ABX, STA_ABX: begin
                                absolute_indexed = 1'b1;
                                index = alu_x;
                        end
                        ADC_ABY, AND_ABY, CMP_ABY, EOR_ABY, LDA_ABY, LDX_ABY, ORA_ABY, SBC_ABY, STA_ABY: begin
                                absolute_indexed = 1'b1;
                                index = alu_y;
                        end
                        ADC_IDX, AND_IDX, CMP_IDX, EOR_IDX, LDA_IDX, ORA_IDX, SBC_IDX, STA_IDX: begin
                                indirectx = 1'b1;
                                index = alu_x;
                        end
                        ADC_IDY, AND_IDY, CMP_IDY, EOR_IDY, LDA_IDY, ORA_IDY, SBC_IDY, STA_IDY: begin
                                indirecty = 1'b1;
                                index = alu_y;
                        end
                        JMP_ABS: begin
                                absolute = 1'b1;
                                jump = 1'b1;
                        end
                        JMP_IND: begin
                                jump_indirect = 1'b1;
                        end
                        BRK_IMP: begin
                                // something goes in here
                        end
                        default: begin
                                $write("state : %b", state);
                                if (reset_n == 1 && state != FETCH_OP_FIX_PC) begin // the processor is NOT being reset neither it is fixing the pc
                                        $write("\nunknown OPCODE!!!!! 0x%h\n", ir);
                                        $finish();
                                end
                        end
                endcase
 
                case (ir)
                        ASL_ACC, ASL_ZPG, ASL_ZPX, ASL_ABS, ASL_ABX, LSR_ACC, LSR_ZPG, LSR_ZPX, LSR_ABS, LSR_ABX, ROL_ACC, ROL_ZPG, ROL_ZPX, ROL_ABS,
                        ROL_ABX, ROR_ACC, ROR_ZPG, ROR_ZPX, ROR_ABS, ROR_ABX, INC_ZPG, INC_ZPX, INC_ABS, INC_ABX, DEC_ZPG, DEC_ZPX, DEC_ABS,
                        DEC_ABX: begin
                                read_modify_write = 1'b1;
                        end
                        STA_ZPG, STA_ZPX, STA_ABS, STA_ABX, STA_ABY, STA_IDX, STA_IDY, STX_ZPG, STX_ZPY, STX_ABS, STY_ZPG, STY_ZPX, STY_ABS: begin
                                write = 1'b1;
                        end
                        default: begin // this should work fine since the previous case statement will detect the unknown/undocumented/unsupported opcodes
                                read = 1'b1;
                        end
                endcase
        end
endmodule
 
 
 

Line No.	Rev	Author	Line
1	61	creep	`////////////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// T6507LP IP Core ////`
4			`//// ////`
5			`//// This file is part of the T6507LP project ////`
6			`//// http://www.opencores.org/cores/t6507lp/ ////`
7			`//// ////`
8			`//// Description ////`
9			`//// 6507 FSM ////`
10			`//// ////`
11			`//// TODO: ////`
12	96	creep	`//// - Fix relative mode, bit 7 means negative ////`
13	61	creep	`//// - Code the indirect indexed mode ////`
14			`//// - Code the absolute indirect mode ////`
15			`//// ////`
16			`//// Author(s): ////`
17			`//// - Gabriel Oshiro Zardo, gabrieloshiro@gmail.com ////`
18			`//// - Samuel Nascimento Pagliarini (creep), snpagliarini@gmail.com ////`
19			`//// ////`
20			`////////////////////////////////////////////////////////////////////////////`
21			`//// ////`
22			`//// Copyright (C) 2001 Authors and OPENCORES.ORG ////`
23			`//// ////`
24			`//// This source file may be used and distributed without ////`
25			`//// restriction provided that this copyright statement is not ////`
26			`//// removed from the file and that any derivative work contains ////`
27			`//// the original copyright notice and the associated disclaimer. ////`
28			`//// ////`
29			`//// This source file is free software; you can redistribute it ////`
30			`//// and/or modify it under the terms of the GNU Lesser General ////`
31			`//// Public License as published by the Free Software Foundation; ////`
32			`//// either version 2.1 of the License, or (at your option) any ////`
33			`//// later version. ////`
34			`//// ////`
35			`//// This source is distributed in the hope that it will be ////`
36			`//// useful, but WITHOUT ANY WARRANTY; without even the implied ////`
37			`//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ////`
38			`//// PURPOSE. See the GNU Lesser General Public License for more ////`
39			`//// details. ////`
40			`//// ////`
41			`//// You should have received a copy of the GNU Lesser General ////`
42			`//// Public License along with this source; if not, download it ////`
43			`//// from http://www.opencores.org/lgpl.shtml ////`
44			`//// ////`
45			`////////////////////////////////////////////////////////////////////////////`
46
47			`timescale 1ns / 1ps
48
49	86	creep	`module t6507lp_fsm(clk, reset_n, alu_result, alu_status, data_in, address, control, data_out, alu_opcode, alu_a, alu_enable, alu_x, alu_y);`
50	87	creep	`parameter DATA_SIZE = 8;`
51			`parameter ADDR_SIZE = 13;`
52	68	creep
53	83	creep	`localparam DATA_SIZE_ = DATA_SIZE - 4'b0001;`
54			`localparam ADDR_SIZE_ = ADDR_SIZE - 4'b0001;`
55	82	creep
56	71	creep	`input clk;`
57			`input reset_n;`
58	82	creep	`input [DATA_SIZE_:0] alu_result;`
59			`input [DATA_SIZE_:0] alu_status;`
60			`input [DATA_SIZE_:0] data_in;`
61			`output reg [ADDR_SIZE_:0] address;`
62	61	creep	`output reg control; // one bit is enough? read = 0, write = 1`
63	82	creep	`output reg [DATA_SIZE_:0] data_out;`
64			`output reg [DATA_SIZE_:0] alu_opcode;`
65			`output reg [DATA_SIZE_:0] alu_a;`
66	68	creep	`output reg alu_enable;`
67	61	creep
68	86	creep	`input [DATA_SIZE_:0] alu_x;`
69			`input [DATA_SIZE_:0] alu_y;`
70	68	creep
71	61	creep	`// FSM states`
72	95	creep	`localparam FETCH_OP = 5'b00000;`
73			`localparam FETCH_OP_CALC = 5'b00001;`
74			`localparam FETCH_LOW = 5'b00010;`
75			`localparam FETCH_HIGH = 5'b00011;`
76			`localparam READ_MEM = 5'b00100;`
77			`localparam DUMMY_WRT_CALC = 5'b00101;`
78			`localparam WRITE_MEM = 5'b00110;`
79			`localparam FETCH_OP_CALC_PARAM = 5'b00111;`
80			`localparam READ_MEM_CALC_INDEX = 5'b01000;`
81			`localparam FETCH_HIGH_CALC_INDEX = 5'b01001;`
82			`localparam READ_MEM_FIX_ADDR = 5'b01010;`
83			`localparam FETCH_OP_EVAL_BRANCH = 5'b01011;`
84			`localparam FETCH_OP_FIX_PC = 5'b01100;`
85			`localparam READ_FROM_POINTER = 5'b01101;`
86			`localparam READ_FROM_POINTER_X = 5'b01110;`
87			`localparam READ_FROM_POINTER_X1 = 5'b01111;`
88	61	creep
89	95	creep	`localparam RESET = 5'b11111;`
90
91	61	creep	`// OPCODES TODO: verify how this get synthesised`
92			`include "../T6507LP_Package.v"
93
94			`// control signals`
95			`localparam MEM_READ = 1'b0;`
96			`localparam MEM_WRITE = 1'b1;`
97
98	82	creep	`reg [ADDR_SIZE_:0] pc; // program counter`
99	102	creep	`reg [ADDR_SIZE_:0] sp; // stack pointer`
100	82	creep	`reg [DATA_SIZE_:0] ir; // instruction register`
101			`reg [ADDR_SIZE_:0] temp_addr; // temporary address`
102			`reg [DATA_SIZE_:0] temp_data; // temporary data`
103	61	creep
104	96	creep	`reg [4:0] state, next_state; // current and next state registers`
105	61	creep	`// TODO: not sure if this will be 4 bits wide. as of march 9th this was 4bit wide.`
106
107			`// wiring that simplifies the FSM logic`
108			`reg absolute;`
109			`reg absolute_indexed;`
110			`reg accumulator;`
111			`reg immediate;`
112			`reg implied;`
113	95	creep	`reg indirectx;`
114			`reg indirecty;`
115	61	creep	`reg relative;`
116			`reg zero_page;`
117			`reg zero_page_indexed;`
118	86	creep	`reg [DATA_SIZE_:0] index; // will be assigned with either X or Y`
119	61	creep
120			`// regs that store the type of operation. again, this simplifies the FSM a lot.`
121			`reg read;`
122			`reg read_modify_write;`
123			`reg write;`
124			`reg jump;`
125	101	creep	`reg jump_indirect;`
126	61	creep
127	82	creep	`wire [ADDR_SIZE_:0] next_pc;`
128	63	creep	`assign next_pc = pc + 13'b0000000000001;`
129	61	creep
130	87	creep	`reg [ADDR_SIZE_:0] address_plus_index; // this would update more times than actually needed, consuming power.`
131			`reg page_crossed; // so the simple assign was changed into a combinational always block`
132
133	94	creep	`reg branch;`
134
135	87	creep	`always @(*) begin`
136			`address_plus_index = 0;`
137			`page_crossed = 0;`
138	86	creep
139	88	creep	`if (state == READ_MEM_CALC_INDEX \|\| state == READ_MEM_FIX_ADDR \|\| state == FETCH_HIGH_CALC_INDEX) begin`
140			`{page_crossed, address_plus_index[7:0]} = temp_addr[7:0] + index;`
141			`address_plus_index[12:8] = temp_addr[12:8] + page_crossed;`
142	87	creep	`end`
143	94	creep	`else if (branch) begin`
144			`if (state == FETCH_OP_FIX_PC \|\| state == FETCH_OP_EVAL_BRANCH) begin`
145			`{page_crossed, address_plus_index[7:0]} = pc[7:0] + index;`
146			`address_plus_index[12:8] = pc[12:8] + page_crossed;// warning: pc might feed these lines twice and cause branch failure`
147			`end // solution: add a temp reg i guess`
148			`end`
149	95	creep	`else if (state == READ_FROM_POINTER) begin`
150	96	creep	`if (indirectx) begin`
151			`{page_crossed, address_plus_index[7:0]} = temp_data + index;`
152			`address_plus_index[12:8] = 5'b00000;`
153			`end`
154	101	creep	`else if (jump_indirect) begin`
155			`address_plus_index[7:0] = temp_addr + 8'h01;`
156			`address_plus_index[12:8] = 5'b00000;`
157			`end`
158	96	creep	`else begin // indirecty falls here`
159			`address_plus_index[7:0] = temp_data + 8'h01;`
160			`address_plus_index[12:8] = 5'b00000;`
161			`end`
162	95	creep	`end`
163			`else if (state == READ_FROM_POINTER_X) begin`
164			`{page_crossed, address_plus_index[7:0]} = temp_data + index + 8'h01;`
165			`address_plus_index[12:8] = 5'b00000;`
166			`end`
167	96	creep	`else if (state == READ_FROM_POINTER_X1) begin`
168			`{page_crossed, address_plus_index[7:0]} = temp_addr[7:0] + index;`
169			`address_plus_index[12:8] = temp_addr[12:8] + page_crossed;`
170			`end`
171	87	creep	`end`
172
173	103	creep	`wire [8:0] sp_plus_one;`
174			`assign sp_plus_one = sp + 9'b000000001;`
175
176			`wire [8:0] sp_minus_one;`
177			`assign sp_minus_one = sp - 9'b000000001;`
178
179	71	creep	`always @ (posedge clk or negedge reset_n) begin // sequencial always block`
180			`if (reset_n == 1'b0) begin`
181			`// all registers must assume default values`
182	68	creep	`pc <= 0; // TODO: this is written somewhere. something about a reset vector. must be checked.`
183	103	creep	`sp <= 9'b100000000; // the default is 'h100`
184	82	creep	`ir <= 8'h00;`
185	102	creep	`temp_addr <= 13'h00;`
186	82	creep	`temp_data <= 8'h00;`
187	68	creep	`state <= RESET;`
188	71	creep	`// registered outputs also receive default values`
189			`address <= 0;`
190	82	creep	`control <= MEM_READ;`
191			`data_out <= 8'h00;`
192	61	creep	`end`
193			`else begin`
194			`state <= next_state;`
195	83	creep
196	61	creep	`case (state)`
197	68	creep	`RESET: begin`
198	82	creep	`// The processor was reset`
199			`$write("under reset");`
200	68	creep	`end`
201	61	creep	`FETCH_OP: begin // this state is the simplest one. it is a simple fetch that must be done when the cpu was reset or`
202			`// the last cycle was a memory write.`
203			`pc <= next_pc;`
204	71	creep	`address <= next_pc;`
205	83	creep	`control <= MEM_READ;`
206	70	creep	`ir <= data_in;`
207	61	creep	`end`
208	71	creep	`FETCH_OP_CALC, FETCH_OP_CALC_PARAM: begin // this is the pipeline happening!`
209	61	creep	`pc <= next_pc;`
210	71	creep	`address <= next_pc;`
211	83	creep	`control <= MEM_READ;`
212	70	creep	`ir <= data_in;`
213	61	creep	`end`
214	68	creep	`FETCH_LOW: begin // in this state the opcode is already known so truly execution begins`
215			`if (accumulator \|\| implied) begin`
216	70	creep	`pc <= pc; // is this better?`
217	71	creep	`address <= pc;`
218	83	creep	`control <= MEM_READ;`
219	61	creep	`end`
220	94	creep	`else if (immediate \|\| relative) begin`
221	68	creep	`pc <= next_pc;`
222	71	creep	`address <= next_pc;`
223	83	creep	`control <= MEM_READ;`
224	70	creep	`temp_data <= data_in; // the follow-up byte is saved in temp_data`
225	61	creep	`end`
226	101	creep	`else if (absolute \|\| absolute_indexed \|\| jump_indirect) begin`
227	71	creep	`pc <= next_pc;`
228			`address <= next_pc;`
229	83	creep	`control <= MEM_READ;`
230	87	creep	`temp_addr <= {{5{1'b0}},data_in};`
231	101	creep	`temp_data <= 8'h00;`
232	71	creep	`end`
233	77	creep	`else if (zero_page) begin`
234			`pc <= next_pc;`
235			`address <= {{5{1'b0}},data_in};`
236	78	creep	`temp_addr <= {{5{1'b0}},data_in};`
237
238	77	creep	`if (write) begin`
239			`control <= MEM_WRITE;`
240	78	creep	`data_out <= alu_result;`
241	77	creep	`end`
242	83	creep	`else begin`
243			`control <= MEM_READ;`
244			`data_out <= 8'h00;`
245			`end`
246	77	creep	`end`
247	86	creep	`else if (zero_page_indexed) begin`
248			`pc <= next_pc;`
249	94	creep	`address <= {{5{1'b0}}, data_in};`
250			`temp_addr <= {{5{1'b0}}, data_in};`
251	86	creep	`control <= MEM_READ;`
252			`end`
253	96	creep	`else if (indirectx \|\| indirecty) begin`
254	95	creep	`pc <= next_pc;`
255			`address <= data_in;`
256			`temp_data <= data_in;`
257			`control <= MEM_READ;`
258			`end`
259	102	creep	`else begin // the special instructions will fall here: BRK, RTI, RTS...`
260
261			`end`
262	61	creep	`end`
263	87	creep	`FETCH_HIGH_CALC_INDEX: begin`
264			`pc <= next_pc;`
265			`temp_addr[12:8] <= data_in[4:0];`
266			`address <= {data_in[4:0], address_plus_index[7:0]};`
267			`control <= MEM_READ;`
268			`data_out <= 8'h00;`
269			`end`
270	94	creep	`FETCH_OP_EVAL_BRANCH: begin`
271			`if (branch) begin`
272			`pc <= {{5{1'b0}}, address_plus_index[7:0]};`
273			`address <= {{5{1'b0}}, address_plus_index[7:0]};`
274			`control <= MEM_READ;`
275			`data_out <= 8'h00;`
276			`end`
277			`else begin`
278			`pc <= next_pc;`
279			`address <= next_pc;`
280			`control <= MEM_READ;`
281			`data_out <= 8'h00;`
282	95	creep	`ir <= data_in;`
283	94	creep	`end`
284			`end`
285			`FETCH_OP_FIX_PC: begin`
286			`if (page_crossed) begin`
287			`pc[12:8] <= address_plus_index[12:8];`
288			`address[12:8] <= address_plus_index[12:8];`
289			`end`
290			`else begin`
291			`pc <= next_pc;`
292			`address <= next_pc;`
293			`control <= MEM_READ;`
294			`ir <= data_in;`
295			`end`
296			`end`
297	71	creep	`FETCH_HIGH: begin`
298			`if (jump) begin`
299	83	creep	`pc <= {data_in[4:0], temp_addr[7:0]}; // PCL <= first byte, PCH <= second byte`
300			`address <= {data_in[4:0], temp_addr[7:0]};`
301			`control <= MEM_READ;`
302			`data_out <= 8'h00;`
303	71	creep	`end`
304			`else begin`
305			`if (write) begin`
306			`pc <= next_pc;`
307			`temp_addr[12:8] <= data_in[4:0];`
308			`address <= {data_in[4:0],temp_addr[7:0]};`
309			`control <= MEM_WRITE;`
310	77	creep	`data_out <= alu_result;`
311	71	creep	`end`
312			`else begin // read_modify_write or just read`
313			`pc <= next_pc;`
314			`temp_addr[12:8] <= data_in[4:0];`
315			`address <= {data_in[4:0],temp_addr[7:0]};`
316	83	creep	`control <= MEM_READ;`
317			`data_out <= 8'h00;`
318	71	creep	`end`
319			`end`
320			`//else begin`
321			`// $write("FETCHHIGH PROBLEM");`
322			`// $finish(0);`
323			`//end`
324	61	creep	`end`
325	71	creep	`READ_MEM: begin`
326			`if (read_modify_write) begin`
327			`pc <= pc;`
328			`address <= temp_addr;`
329			`control <= MEM_WRITE;`
330			`temp_data <= data_in;`
331			`data_out <= data_in; // writeback the same value`
332			`end`
333			`else begin`
334			`pc <= pc;`
335			`address <= pc;`
336			`temp_data <= data_in;`
337	83	creep	`control <= MEM_READ;`
338			`data_out <= 8'h00;`
339	71	creep	`end`
340	70	creep	`end`
341	86	creep	`READ_MEM_CALC_INDEX: begin`
342			`//pc <= next_pc; // pc was already updated in the previous cycle`
343			`address <= address_plus_index;`
344			`temp_addr <= address_plus_index;`
345
346			`if (write) begin`
347			`control <= MEM_WRITE;`
348			`data_out <= alu_result;`
349			`end`
350			`else begin`
351			`control <= MEM_READ;`
352			`data_out <= 8'h00;`
353			`end`
354
355			`end`
356	87	creep	`READ_MEM_FIX_ADDR: begin`
357			`if (read) begin`
358			`control <= MEM_READ;`
359			`data_out <= 8'h00;`
360
361			`if (page_crossed) begin`
362			`address <= address_plus_index;`
363			`temp_addr <= address_plus_index;`
364			`end`
365			`else begin`
366			`address <= pc;`
367			`temp_data <= data_in;`
368			`end`
369			`end`
370			`else if (write) begin`
371			`control <= MEM_WRITE;`
372			`data_out <= alu_result;`
373			`address <= address_plus_index;`
374			`temp_addr <= address_plus_index;`
375
376			`end`
377			`else begin // read modify write`
378			`control <= MEM_READ;`
379			`data_out <= 8'h00;`
380			`address <= address_plus_index;`
381			`temp_addr <= address_plus_index;`
382			`end`
383			`end`
384	71	creep	`DUMMY_WRT_CALC: begin`
385			`pc <= pc;`
386			`address <= temp_addr;`
387			`control <= MEM_WRITE;`
388			`data_out <= alu_result;`
389	70	creep	`end`
390	71	creep	`WRITE_MEM: begin`
391			`pc <= pc;`
392			`address <= pc;`
393	83	creep	`control <= MEM_READ;`
394			`data_out <= 8'h00;`
395	70	creep	`end`
396	95	creep	`READ_FROM_POINTER: begin`
397	101	creep	`if (jump_indirect) begin`
398			`pc[7:0] <= data_in;`
399			`control <= MEM_READ;`
400	96	creep	`address <= address_plus_index;`
401			`end`
402	101	creep	`else begin`
403			`pc <= pc;`
404			`control <= MEM_READ;`
405
406			`if (indirectx) begin`
407			`address <= address_plus_index;`
408			`end`
409			`else begin // indirecty falls here`
410			`address <= address_plus_index;`
411			`temp_addr <= {{5{1'b0}}, data_in};`
412			`end`
413	96	creep	`end`
414	95	creep	`end`
415			`READ_FROM_POINTER_X: begin`
416			`pc <= pc;`
417			`address <= address_plus_index;`
418			`temp_addr[7:0] <= data_in;`
419			`control <= MEM_READ;`
420			`end`
421			`READ_FROM_POINTER_X1: begin`
422	101	creep	`if (jump_indirect) begin`
423			`pc[12:8] <= data_in[4:0];`
424			`control <= MEM_READ;`
425			`address <= {data_in[4:0], pc[7:0]};`
426			`end`
427			`else if (indirectx) begin`
428			`address <= {data_in[4:0], temp_addr[7:0]};`
429	96	creep	`if (write) begin`
430			`control <= MEM_WRITE;`
431			`data_out <= alu_result;`
432			`end`
433			`else begin`
434			`control <= MEM_READ;`
435			`end`
436	95	creep	`end`
437	96	creep	`else begin // indirecty falls here`
438			`address <= address_plus_index;`
439			`temp_addr[12:8] <= data_in;`
440	95	creep	`control <= MEM_READ;`
441			`end`
442			`end`
443	70	creep	`default: begin`
444	95	creep	$write("unknown state"); // TODO: check if synth really ignores this 2 lines. Otherwise wrap it with a `ifdef
445	70	creep	`$finish(0);`
446			`end`
447
448			`endcase`
449			`end`
450			`end`
451
452	71	creep	`always @ (*) begin // this is the next_state logic and the output logic always block`
453			`alu_opcode = 8'h00;`
454			`alu_a = 8'h00;`
455			`alu_enable = 1'b0;`
456	70	creep
457	71	creep	`next_state = RESET; // this prevents the latch`
458	68	creep
459	71	creep	`case (state)`
460			`RESET: begin`
461			`next_state = FETCH_OP;`
462			`end`
463			`FETCH_OP: begin`
464			`next_state = FETCH_LOW;`
465			`end`
466	82	creep	`//FETCH_OP_CALC: begin // so far no addressing mode required the use of this state`
467			`// next_state = FETCH_LOW;`
468			`// alu_opcode = ir;`
469			`// alu_enable = 1'b1;`
470			`//end`
471	71	creep	`FETCH_OP_CALC_PARAM: begin`
472			`next_state = FETCH_LOW;`
473			`alu_opcode = ir;`
474			`alu_enable = 1'b1;`
475			`alu_a = temp_data;`
476			`end`
477			`FETCH_LOW: begin`
478			`if (accumulator \|\| implied) begin`
479			`alu_opcode = ir;`
480			`alu_enable = 1'b1;`
481			`next_state = FETCH_OP;`
482			`end`
483			`else if (immediate) begin`
484			`next_state = FETCH_OP_CALC_PARAM;`
485			`end`
486	77	creep	`else if (zero_page) begin`
487			`if (read \|\| read_modify_write) begin`
488			`next_state = READ_MEM;`
489			`end`
490			`else if (write) begin`
491			`next_state = WRITE_MEM;`
492	86	creep	`alu_opcode = ir;`
493			`alu_enable = 1'b1;`
494			`alu_a = 8'h00;`
495	77	creep	`end`
496			`else begin`
497			`$write("unknown behavior");`
498			`$finish(0);`
499			`end`
500			`end`

Browse

Tools

Subversion Repositories t6507lp

[/] [t6507lp/] [trunk/] [rtl/] [verilog/] [t6507lp_fsm.v] - Blame information for rev 103