9086/system/biu.v

/* biu.v - implementation of the 9086 bus interface unit. The logic that
   controls all external bus functions

   This file is part of the 9086 project.

   Copyright (c) 2023 Efthymios Kritikos

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program 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 "config.v"

`define BIU_HALT			4'b0000
`define BIU_NEXT_ACTION 		4'b0001
`define BIU_READ			4'b0010
`define BIU_RESET			4'b0011

`define BIU_PUT_BYTE			4'b0100
`define BIU_PUT_UNALIGNED_16BIT_DATA	4'b0101
`define BIU_PUT_ALIGNED_16BIT_DATA	4'b0110
`define BIU_PUT_UNALIGNED_PREP_NEXT2	4'b1000
`define BIU_WRITE_EXIT			4'b1001
`define BIU_WRITE_RELEASE		4'b1010

`define BIU_GET_ALIGNED_DATA		4'b1011
`define BIU_GET_UNALIGNED_DATA		4'b1100
`define BIU_GET_SECOND_BYTE		4'b1101
`define BIU_GET_SECOND_BYTE1		4'b1110

module BIU (
/* Outside world */ input clock, input reset, output reg [19:0] external_address_bus,
/*               */ inout [15:0] external_data_bus,output reg read, output reg write,output reg BHE,output reg IOMEM,
/*   Internal    */ output reg [31:0] INSTRUCTION, output reg VALID_INSTRUCTION, output reg [15:0] INSTRUCTION_LOCATION, input jump_req,
/*               */ input[15:0] ADDRESS_INPUT, inout [15:0] DATA, input write_request, input read_request, input Wbit, output reg VALID_DATA, input MEM_OR_IO,
/*               */ input valid_instruction_ack
`ifdef OTUPUT_JSON_STATISTICS
/*  Statistics   */ ,output  wire [`L1_CACHE_SIZE-1:0] FIFO_SIZE_STAT, output wire VALID_INSTRUCTION_STAT
`endif
	);

`ifdef OTUPUT_JSON_STATISTICS
assign FIFO_SIZE_STAT = FIFO_SIZE;
assign VALID_INSTRUCTION_STAT = ((Isit1==1) && (FIFO_SIZE!=0) && `EARLY_VALID_INSTRUCTION_) || ((fifoIsize==2) && (FIFO_SIZE > 1) && `EARLY_VALID_INSTRUCTION_) || ((fifoIsize==3) && (FIFO_SIZE > 2) && `EARLY_VALID_INSTRUCTION_) || (FIFO_SIZE>3);
`endif

reg [15:0] data_bus_output_register;
assign external_data_bus=read?data_bus_output_register:16'hz;

reg [15:0] DATA_OUT;
reg DATA_DIR;
assign DATA=DATA_DIR ? 16'hz:DATA_OUT;

`define FIFO_SIZE_BYTES $rtoi($pow(2,`L1_CACHE_SIZE))

reg [7:0] INPUT_FIFO [`FIFO_SIZE_BYTES-1:0];
reg [`L1_CACHE_SIZE-1:0] FIFO_start; /*inclusive*/
reg [`L1_CACHE_SIZE-1:0] FIFO_end;   /*exclusive*/
wire [`L1_CACHE_SIZE-1:0] FIFO_SIZE = FIFO_end-FIFO_start;

reg [3:0] biu_state;

always @(negedge reset) begin
	biu_state <= `BIU_HALT;
	write <= 1;
end
always @(posedge reset) begin
	biu_state <= `BIU_RESET;
end

reg jump_req_latch;

reg func;
reg [19:0]INSTRUCTION_ADDRESS;
reg [19:0]DATA_ADDRESS;

assign external_address_bus= func? INSTRUCTION_ADDRESS : DATA_ADDRESS ;

always @(posedge clock) begin
	if ( jump_req_latch ) begin
		/* verilator lint_off BLKSEQ */
		FIFO_start = 0;
		/* verilator lint_on BLKSEQ */
		FIFO_end <= 0;
		INSTRUCTION_ADDRESS <= { 4'b0 , ADDRESS_INPUT };
		INSTRUCTION_LOCATION <= ADDRESS_INPUT;
		func <= 1;
		jump_req_latch <= 0;
		if (biu_state==`BIU_READ)
			biu_state <= `BIU_NEXT_ACTION;
	end else begin
		case(biu_state)
			`BIU_HALT: begin
			end
			`BIU_NEXT_ACTION: begin /* decide if we can read, if we are full or if we need to do something else */
				if (write_request) begin
					func<=0;
					DATA_ADDRESS <= { 4'b0 , ADDRESS_INPUT };
					DATA_DIR <= 1 ;
					IOMEM <= MEM_OR_IO;
					biu_state <= (Wbit==0) ? `BIU_PUT_BYTE : (ADDRESS_INPUT[0:0]?`BIU_PUT_UNALIGNED_16BIT_DATA:`BIU_PUT_ALIGNED_16BIT_DATA) ;
				end else if ( read_request ) begin
					func<=0;
					DATA_ADDRESS <= { 4'b0 , ADDRESS_INPUT };
					DATA_DIR <= 0;
					IOMEM <= MEM_OR_IO;
					read <= 0;
					BHE <= 0;
					biu_state <= (ADDRESS_INPUT[0:0])?`BIU_GET_UNALIGNED_DATA:`BIU_GET_ALIGNED_DATA;
				end else begin
					if ( FIFO_SIZE!=4'hF ) begin
						func<=1;
						biu_state <= `BIU_READ;
						write <= 1;
						read <= 0;
						IOMEM <= 0;
						BHE <= 0;
					end else begin
						biu_state <= `BIU_NEXT_ACTION;
					end
				end

				`ifdef EARLY_VALID_INSTRUCTION
				if((Isit1==1) && (FIFO_SIZE!=0) && `EARLY_VALID_INSTRUCTION_)begin
					VALID_INSTRUCTION <= 1;
					INSTRUCTION[31:24] <= INPUT_FIFO[FIFO_start];
				end else if((fifoIsize==2) && (FIFO_SIZE > 1) && `EARLY_VALID_INSTRUCTION_)begin
					VALID_INSTRUCTION <= 1;
					INSTRUCTION[31:24] <= INPUT_FIFO[FIFO_start];
					INSTRUCTION[23:16] <= INPUT_FIFO[FIFO_start+4'd1];
				end else if((fifoIsize==3) && (FIFO_SIZE > 2) && `EARLY_VALID_INSTRUCTION_)begin
					VALID_INSTRUCTION <= 1;
					INSTRUCTION[31:24] <= INPUT_FIFO[FIFO_start];
					INSTRUCTION[23:16] <= INPUT_FIFO[FIFO_start+4'd1];
					INSTRUCTION[15: 8] <= INPUT_FIFO[FIFO_start+4'd2];
				end else if(FIFO_SIZE>3)begin
					VALID_INSTRUCTION <= 1;
					INSTRUCTION[31:24] <= INPUT_FIFO[FIFO_start];
					INSTRUCTION[23:16] <= INPUT_FIFO[FIFO_start+4'd1];
					INSTRUCTION[15: 8] <= INPUT_FIFO[FIFO_start+4'd2];
					INSTRUCTION[ 7: 0] <= INPUT_FIFO[FIFO_start+4'd3];
				end
				`else
				if(FIFO_SIZE>3)begin
					VALID_INSTRUCTION <= 1;
					INSTRUCTION[31:24] <= INPUT_FIFO[FIFO_start];
					INSTRUCTION[23:16] <= INPUT_FIFO[FIFO_start+4'd1];
					INSTRUCTION[15: 8] <= INPUT_FIFO[FIFO_start+4'd2];
					INSTRUCTION[ 7: 0] <= INPUT_FIFO[FIFO_start+4'd3];
				end
				`endif


			end

			/*************** INSTRUCTION FIFO READ ***************/
			`BIU_READ: begin
				if(INSTRUCTION_ADDRESS[0:0]==0 && FIFO_SIZE<4'hD)begin
					INPUT_FIFO[FIFO_end] <= external_data_bus[7:0];
					INPUT_FIFO[FIFO_end+4'd1] <= external_data_bus[15:8];
					FIFO_end <= FIFO_end+4'd2;
					INSTRUCTION_ADDRESS <= INSTRUCTION_ADDRESS+20'd2;
				end else if(INSTRUCTION_ADDRESS[0:0]==0)begin
					INPUT_FIFO[FIFO_end] <= external_data_bus[7:0];
					FIFO_end <= FIFO_end+4'd1;
					INSTRUCTION_ADDRESS <= INSTRUCTION_ADDRESS+20'd1;
				end else begin
					INPUT_FIFO[FIFO_end] <= external_data_bus[15:8];
					FIFO_end <= FIFO_end+4'd1;
					INSTRUCTION_ADDRESS <= INSTRUCTION_ADDRESS+20'd1;
				end
				biu_state <= `BIU_NEXT_ACTION;
				read<=1;
			end

			/*************** DATA WRITE ***************/
			//TODO TODO TODO flush fifo, self modifying code
			`BIU_PUT_UNALIGNED_16BIT_DATA:begin
				`ifdef DEBUG_DATA_READ_WRITES
					$display("Writing 16bit %04x at %04x",DATA,DATA_ADDRESS);
				`endif
				BHE <= 0;
				data_bus_output_register <= {DATA[7:0],DATA[15:8]};
				write <= 0;
				biu_state <= `BIU_PUT_UNALIGNED_PREP_NEXT2;
			end
			`BIU_PUT_UNALIGNED_PREP_NEXT2:begin
				write <= 1;
				DATA_ADDRESS <= DATA_ADDRESS+20'd1;
				BHE <= 1;
				biu_state <= `BIU_WRITE_EXIT;
			end
			`BIU_PUT_ALIGNED_16BIT_DATA:begin
				`ifdef DEBUG_DATA_READ_WRITES
					$display("Writing 16bit %04x at %04x",DATA,DATA_ADDRESS);
				`endif
				data_bus_output_register <= {DATA[15:8],DATA[7:0]};
				write <= 0;
				biu_state <= `BIU_WRITE_RELEASE;
			end
			`BIU_PUT_BYTE:begin
				`ifdef DEBUG_DATA_READ_WRITES
					$display("Writing 8bit %02x at %04x",DATA[7:0],DATA_ADDRESS);
				`endif
				if(ADDRESS_INPUT[0:0]==0) begin
					BHE <= 1;
					data_bus_output_register <= {8'b0,DATA[7:0]};
				end else begin
					BHE <= 0;
					data_bus_output_register <= {DATA[7:0],8'b0};
				end
				write <= 0;
				biu_state <= `BIU_WRITE_RELEASE;
			end
			`BIU_WRITE_EXIT:begin
				write <= 0;
				biu_state <= `BIU_WRITE_RELEASE;
			end
			`BIU_WRITE_RELEASE:begin
				write <= 1;
				biu_state <= `BIU_NEXT_ACTION;
			end


			/*************** DATA READ ***************/
			`define finished_read  \
				DATA_DIR <= 0; \
				VALID_DATA <= 1;\
				if ( read_request == 0 ) begin \
					biu_state <= `BIU_NEXT_ACTION;\
					VALID_DATA <= 0;\
				end
			`BIU_GET_ALIGNED_DATA:begin
				`ifdef DEBUG_DATA_READ_WRITES
					if(Wbit==1)
						$display("Reading 16bit %04x from %04x",external_data_bus,DATA_ADDRESS);
					else
						$display("Reading 8bit %02x from %04x",external_data_bus[7:0],DATA_ADDRESS);
				`endif
				DATA_OUT <= (Wbit==1)? external_data_bus : {8'b0,external_data_bus[7:0]} ;
				read <=1;
				`finished_read
			end
			`BIU_GET_UNALIGNED_DATA:begin
				`ifdef DEBUG_DATA_READ_WRITES
					if(Wbit==0)
						$display("Reading 8bit %02x from %04x",external_data_bus[15:8],DATA_ADDRESS);
				`endif
				DATA_OUT[7:0] <= external_data_bus[15:8];
				read <=1;
				if(Wbit==1) begin
					biu_state <= `BIU_GET_SECOND_BYTE;
				end else begin
					`finished_read
				end
			end
			`BIU_GET_SECOND_BYTE:begin
				DATA_ADDRESS <= DATA_ADDRESS+20'd1;
				biu_state <= `BIU_GET_SECOND_BYTE1;
				read <=0;
			end
			`BIU_GET_SECOND_BYTE1:begin
				`ifdef DEBUG_DATA_READ_WRITES
						$display("Reading 16bit %02x from %04x",{external_data_bus[7:0],DATA_OUT[7:0]},DATA_ADDRESS-1);//read started a byte earlier
				`endif
				DATA_OUT[15:8] <= external_data_bus[7:0];
				`finished_read
				read <=1;
			end

			/*************** HOUSE KEEPING ***************/
			`BIU_RESET: begin
				/* verilator lint_off BLKSEQ */
				FIFO_start = 4'b0;
				/* verilator lint_on BLKSEQ */
				FIFO_end <= 4'b0;
				biu_state <= `BIU_NEXT_ACTION;
				INSTRUCTION_ADDRESS <= 20'h0FFF0;
				INSTRUCTION_LOCATION <= 16'hFFF0;
				VALID_INSTRUCTION <= 0;
				VALID_DATA <= 0;
				DATA_DIR <= 0;
			end
			default: begin
				biu_state <= `BIU_NEXT_ACTION;/*Should be unreachable*/
			end
		endcase
	end
end

wire [2:0] Isize;
InstrSize InstrSize({INSTRUCTION[31:24],INSTRUCTION[21:19]},Isize);

`ifdef INCLUDE_EARLY_CALC_CIRUIT
wire [2:0] fifoIsize;
wire Isit1;
InstrSize fifoInstrSize({INPUT_FIFO[FIFO_start][7:0],INPUT_FIFO[FIFO_start+4'd1][5:3]},fifoIsize);
Is1 Is1(INPUT_FIFO[FIFO_start][7:0],Isit1);
`endif

`ifdef DOUBLE_INSTRUCTION_LOAD
wire [2:0] fifoIsize2;
InstrSize fifoInstrSize2({INPUT_FIFO[FIFO_start+fifoIsize][7:0],INPUT_FIFO[FIFO_start+fifoIsize+4'd1][5:3]},fifoIsize2);
`endif

always @( valid_instruction_ack ) begin
	/* verilator lint_off BLKSEQ */
	FIFO_start = FIFO_start + {1'b0,Isize};
	INSTRUCTION_LOCATION <= INSTRUCTION_LOCATION + {12'b0,Isize};;
	`ifdef DOUBLE_INSTRUCTION_LOAD
	if(FIFO_SIZE>4'd3+Isize)begin
		if((fifoIsize2==2) && (FIFO_SIZE > 1+fifoIsize) && `EARLY_VALID_INSTRUCTION_)begin
			VALID_INSTRUCTION <= 1;
			INSTRUCTION[31:24] <= INPUT_FIFO[FIFO_start];
			INSTRUCTION[23:16] <= INPUT_FIFO[FIFO_start+4'd1];
		end else if((fifoIsize2==3) && (FIFO_SIZE > 2+fifoIsize) && `EARLY_VALID_INSTRUCTION_)begin
			VALID_INSTRUCTION <= 1;
			INSTRUCTION[31:24] <= INPUT_FIFO[FIFO_start];
			INSTRUCTION[23:16] <= INPUT_FIFO[FIFO_start+4'd1];
			INSTRUCTION[15: 8] <= INPUT_FIFO[FIFO_start+4'd2];
		end else if(FIFO_SIZE>3+fifoIsize)begin
			VALID_INSTRUCTION <= 1;
			INSTRUCTION[31:24] <= INPUT_FIFO[FIFO_start];
			INSTRUCTION[23:16] <= INPUT_FIFO[FIFO_start+4'd1];
			INSTRUCTION[15: 8] <= INPUT_FIFO[FIFO_start+4'd2];
			INSTRUCTION[ 7: 0] <= INPUT_FIFO[FIFO_start+4'd3];
		end else
			VALID_INSTRUCTION <= 0;
	end else begin
		VALID_INSTRUCTION <= 0;
		/* verilator lint_on BLKSEQ */
	end
	`else
		VALID_INSTRUCTION <= 0;
	`endif
end

always @( posedge jump_req ) begin
	jump_req_latch <= 1;
	VALID_INSTRUCTION <= 0;
end

endmodule