/************************************************************************\
 *                                                                        *
 *               Copyright (C) 1994, Silicon Graphics, Inc.               *
 *                                                                        *
 *  These coded instructions, statements, and computer programs  contain  *
 *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
 *  are protected by Federal copyright  law.  They  may not be disclosed  *
 *  to  third  parties  or copied or duplicated in any form, in whole or  *
 *  in part, without the prior written consent of Silicon Graphics, Inc.  *
 *                                                                        *
 \************************************************************************/

// $Id: arb.v,v 1.1.1.1 2002/05/17 06:07:44 blythe Exp $

module arb(clock, reset_l,
   dma_ready,
   sp_dma_request, sp_read_request,
   mem_read_request,
   mi_dma_request, mi_write_request, mi_read_request,
   cmd_dma_request, cmd_read_request,
   ri_read_request,
   pi_dma_request, pi_read_request,
   si_dma_request, si_read_request,
   ai_dma_request, ai_read_request,
   vi_dma_request, vi_read_request,
   span_dma_request, span_read_request,
	refresh_strobe,
   sp_cbus_read_enable, sp_cbus_write_enable, sp_dma_grant, sp_read_grant,
   mem_cbus_write_enable,
   mi_cbus_read_enable, mi_cbus_write_enable, mi_cbus_grant,
   cmd_cbus_read_enable, cmd_cbus_write_enable, cmd_dma_grant, cmd_read_grant,
   ri_cbus_read_enable, ri_cbus_write_enable, ri_read_grant,
   pi_cbus_read_enable, pi_cbus_write_enable, pi_dma_grant, pi_read_grant,
   si_cbus_read_enable, si_cbus_write_enable, si_dma_grant, si_read_grant,
   ai_cbus_read_enable, ai_cbus_write_enable, ai_dma_grant, ai_read_grant,
   vi_cbus_read_enable, vi_cbus_write_enable, vi_dma_grant, vi_read_grant,
   span_cbus_read_enable, span_cbus_write_enable, span_dma_grant,
   span_read_grant,
   cbus_select, cbus_command);

`include "rcp.vh"

input clock;
input reset_l;

input dma_ready;
input sp_dma_request;
input sp_read_request;
input mem_read_request;
input mi_dma_request;
input mi_write_request;
input mi_read_request;
input cmd_dma_request;
input cmd_read_request;
input ri_read_request;
input pi_dma_request;
input pi_read_request;
input si_dma_request;
input si_read_request;
input ai_dma_request;
input ai_read_request;
input vi_dma_request;
input vi_read_request;
input span_dma_request;
input span_read_request;
input refresh_strobe;

output sp_cbus_read_enable;
output sp_cbus_write_enable;
output sp_dma_grant;
output sp_read_grant;
output mem_cbus_write_enable;
output mi_cbus_read_enable;
output mi_cbus_write_enable;
output mi_cbus_grant;
output cmd_cbus_read_enable;
output cmd_cbus_write_enable;
output cmd_dma_grant;
output cmd_read_grant;
output ri_cbus_read_enable;
output ri_cbus_write_enable;
output ri_read_grant;
output pi_cbus_read_enable;
output pi_cbus_write_enable;
output pi_dma_grant;
output pi_read_grant;
output si_cbus_read_enable;
output si_cbus_write_enable;
output si_dma_grant;
output si_read_grant;
output ai_cbus_read_enable;
output ai_cbus_write_enable;
output ai_dma_grant;
output ai_read_grant;
output vi_cbus_read_enable;
output vi_cbus_write_enable;
output vi_dma_grant;
output vi_read_grant;
output span_cbus_read_enable;
output span_cbus_write_enable;
output span_dma_grant;
output span_read_grant;
output [CBUS_SELECT_SIZE-1:0] cbus_select;
output [CBUS_COMMAND_SIZE-1:0] cbus_command;

// output registers
reg sp_dma_grant;
reg sp_read_grant;
reg mi_cbus_grant;
reg cmd_dma_grant;
reg cmd_read_grant;
reg ri_read_grant;
reg pi_dma_grant;
reg pi_read_grant;
reg si_dma_grant;
reg si_read_grant;
reg ai_dma_grant;
reg ai_read_grant;
reg vi_dma_grant;
reg vi_read_grant;
reg span_dma_grant;
reg span_read_grant;
reg [CBUS_SELECT_SIZE-1:0] cbus_select;
reg [CBUS_COMMAND_SIZE-1:0] cbus_command;

// output pseudo register
reg sp_cbus_write_enable;
reg mem_cbus_write_enable;
reg mi_cbus_write_enable;
reg cmd_cbus_write_enable;
reg ri_cbus_write_enable;
reg pi_cbus_write_enable;
reg si_cbus_write_enable;
reg ai_cbus_write_enable;
reg vi_cbus_write_enable;
reg span_cbus_write_enable;
reg sp_cbus_read_enable;
reg mi_cbus_read_enable;
reg cmd_cbus_read_enable;
reg ri_cbus_read_enable;
reg pi_cbus_read_enable;
reg si_cbus_read_enable;
reg ai_cbus_read_enable;
reg vi_cbus_read_enable;
reg span_cbus_read_enable;

// internal registers
reg sp_dma_grant_a1;
reg sp_read_grant_a1;
reg mi_cbus_grant_a1;
reg cmd_dma_grant_a1;
reg cmd_read_grant_a1;
reg ri_read_grant_a1;
reg pi_dma_grant_a1;
reg pi_read_grant_a1;
reg si_dma_grant_a1;
reg si_read_grant_a1;
reg ai_dma_grant_a1;
reg ai_read_grant_a1;
reg vi_dma_grant_a1;
reg vi_read_grant_a1;
reg span_dma_grant_a1;
reg span_read_grant_a1;
reg [DMA_DEVICE_SIZE-1:0] cbus_enable;
reg read_disable;
reg refresh_request;

// state machine register
reg [2:0] state;
parameter
   STATE_IDLE 					= 0,
   STATE_DMA 					= 1,
   STATE_WRITE 				= 2,
   STATE_READ	 				= 3,
   STATE_RESPONSE				= 4,
   STATE_REFRESH				= 5,
   STATE_DELAY 				= 6;

// cbus enable decoder
// all states must decode to exactly one active enable
always @(cbus_enable or read_disable) begin
//compass statemachine adj state
	sp_cbus_write_enable = LOW;
	mem_cbus_write_enable = LOW;
	mi_cbus_write_enable = LOW;
	cmd_cbus_write_enable = LOW;
	ri_cbus_write_enable = LOW;
	pi_cbus_write_enable = LOW;
	si_cbus_write_enable = LOW;
	ai_cbus_write_enable = LOW;
	vi_cbus_write_enable = LOW;
	span_cbus_write_enable = LOW;

	if (read_disable) begin
		sp_cbus_read_enable = LOW;
		mi_cbus_read_enable = LOW;
		cmd_cbus_read_enable = LOW;
		ri_cbus_read_enable = LOW;
		pi_cbus_read_enable = LOW;
		si_cbus_read_enable = LOW;
		ai_cbus_read_enable = LOW;
		vi_cbus_read_enable = LOW;
		span_cbus_read_enable = LOW;
		end
	else begin
		sp_cbus_read_enable = HIGH;
		mi_cbus_read_enable = HIGH;
		cmd_cbus_read_enable = HIGH;
		ri_cbus_read_enable = HIGH;
		pi_cbus_read_enable = HIGH;
		si_cbus_read_enable = HIGH;
		ai_cbus_read_enable = HIGH;
		vi_cbus_read_enable = HIGH;
		span_cbus_read_enable = HIGH;
		end

	// enable the selected write device
	case (cbus_enable)
		BUS_DEVICE_SP: begin
			sp_cbus_write_enable = HIGH;
			sp_cbus_read_enable = LOW;
			end
		BUS_DEVICE_MEM : begin
			mem_cbus_write_enable = HIGH;
			end
		BUS_DEVICE_MI : begin
			mi_cbus_write_enable = HIGH;
			mi_cbus_read_enable = LOW;
			end
		BUS_DEVICE_DP_CMD : begin
			cmd_cbus_write_enable = HIGH;
			cmd_cbus_read_enable = LOW;
			end
		BUS_DEVICE_RI : begin
			ri_cbus_write_enable = HIGH;
			ri_cbus_read_enable = LOW;
			end
		BUS_DEVICE_PI : begin
			pi_cbus_write_enable = HIGH;
			pi_cbus_read_enable = LOW;
			end
		BUS_DEVICE_SI : begin
			si_cbus_write_enable = HIGH;
			si_cbus_read_enable = LOW;
			end
		BUS_DEVICE_AI : begin
			ai_cbus_write_enable = HIGH;
			ai_cbus_read_enable = LOW;
			end
		BUS_DEVICE_VI : begin
			vi_cbus_write_enable = HIGH;
			vi_cbus_read_enable = LOW;
			end
		BUS_DEVICE_DP_SPAN : begin
			span_cbus_write_enable = HIGH;
			span_cbus_read_enable = LOW;
			end
		default : begin
			sp_cbus_write_enable = HIGH;
			sp_cbus_read_enable = LOW;
			end
		endcase
	end


always @(posedge clock) begin
	sp_dma_grant <= sp_dma_grant_a1;
	sp_read_grant <= sp_read_grant_a1;
	mi_cbus_grant <= mi_cbus_grant_a1;
	cmd_dma_grant <= cmd_dma_grant_a1;
	cmd_read_grant <= cmd_read_grant_a1;
	span_dma_grant <= span_dma_grant_a1;
	span_read_grant <= span_read_grant_a1;
	ri_read_grant <= ri_read_grant_a1;
	pi_dma_grant <= pi_dma_grant_a1;
	pi_read_grant <= pi_read_grant_a1;
	si_dma_grant <= si_dma_grant_a1;
	si_read_grant <= si_read_grant_a1;
	ai_dma_grant <= ai_dma_grant_a1;
	ai_read_grant <= ai_read_grant_a1;
	vi_dma_grant <= vi_dma_grant_a1;
	vi_read_grant <= vi_read_grant_a1;
	end


always @(posedge clock or negedge reset_l) begin
	if (!reset_l) begin
		sp_dma_grant_a1 <= LOW;
		sp_read_grant_a1 <= LOW;
		mi_cbus_grant_a1 <= LOW;
		cmd_dma_grant_a1 <= LOW;
		cmd_read_grant_a1 <= LOW;
		ri_read_grant_a1 <= LOW;
		pi_dma_grant_a1 <= LOW;
		pi_read_grant_a1 <= LOW;
		si_dma_grant_a1 <= LOW;
		si_read_grant_a1 <= LOW;
		ai_dma_grant_a1 <= LOW;
		ai_read_grant_a1 <= LOW;
		vi_dma_grant_a1 <= LOW;
		vi_read_grant_a1 <= LOW;
		span_dma_grant_a1 <= LOW;
		span_read_grant_a1 <= LOW;

		refresh_request <= LOW;
		cbus_enable <= 0;
		read_disable <= LOW;
		cbus_command <= CBUS_IDLE_COMMAND;
		state <= STATE_IDLE;

		cbus_select <= 'bx;
		end
	else begin : main_block
		reg next_sp_dma_grant_a1;
		reg next_sp_read_grant_a1;
		reg next_mi_cbus_grant_a1;
		reg next_cmd_dma_grant_a1;
		reg next_cmd_read_grant_a1;
		reg next_ri_read_grant_a1;
		reg next_pi_dma_grant_a1;
		reg next_pi_read_grant_a1;
		reg next_si_dma_grant_a1;
		reg next_si_read_grant_a1;
		reg next_ai_dma_grant_a1;
		reg next_ai_read_grant_a1;
		reg next_vi_dma_grant_a1;
		reg next_vi_read_grant_a1;
		reg next_span_dma_grant_a1;
		reg next_span_read_grant_a1;
		reg next_read_disable;
		reg next_refresh_request;
		reg [CBUS_SELECT_SIZE-1:0] next_cbus_select;
		reg [CBUS_COMMAND_SIZE-1:0] next_cbus_command;
		
		next_sp_dma_grant_a1 = LOW;
		next_sp_read_grant_a1 = LOW;
		next_mi_cbus_grant_a1 = LOW;
		next_cmd_dma_grant_a1 = LOW;
		next_cmd_read_grant_a1 = LOW;
		next_ri_read_grant_a1 = LOW;
		next_pi_dma_grant_a1 = LOW;
		next_pi_read_grant_a1 = LOW;
		next_si_dma_grant_a1 = LOW;
		next_si_read_grant_a1 = LOW;
		next_ai_dma_grant_a1 = LOW;
		next_ai_read_grant_a1 = LOW;
		next_vi_dma_grant_a1 = LOW;
		next_vi_read_grant_a1 = LOW;
		next_span_dma_grant_a1 = LOW;
		next_span_read_grant_a1 = LOW;
		next_read_disable = LOW;
		next_refresh_request = refresh_request;
		next_cbus_select = 'bx;
		next_cbus_command = CBUS_IDLE_COMMAND;

		// arbitrate the cbus
		case (state)
			STATE_IDLE : begin
				if (sp_read_request && !sp_read_grant) begin
					// sp response data
					next_sp_read_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_DATA_SELECT;
					cbus_enable <= BUS_DEVICE_SP;
					state <= STATE_RESPONSE;
					end
				else if (mem_read_request && !sp_read_grant) begin
					// sp response data
					next_sp_read_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_DATA_SELECT;
					cbus_enable <= BUS_DEVICE_MEM;
					state <= STATE_RESPONSE;
					end
				else if (pi_read_request && !pi_read_grant) begin
					// pi response data
					next_pi_read_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_DATA_SELECT;
					cbus_enable <= BUS_DEVICE_PI;
					state <= STATE_RESPONSE;
					end
				else if (si_read_request && !si_read_grant) begin
					// si response data
					next_si_read_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_DATA_SELECT;
					cbus_enable <= BUS_DEVICE_SI;
					state <= STATE_RESPONSE;
					end
				else if (ai_read_request && !ai_read_grant) begin
					// ai response data
					next_ai_read_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_DATA_SELECT;
					cbus_enable <= BUS_DEVICE_AI;
					state <= STATE_RESPONSE;
					end
				else if (vi_read_request && !vi_read_grant) begin
					// vi response data
					next_vi_read_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_DATA_SELECT;
					cbus_enable <= BUS_DEVICE_VI;
					state <= STATE_RESPONSE;
					end
				else if (ri_read_request && !ri_read_grant) begin
					// ri response data
					next_ri_read_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_DATA_SELECT;
					cbus_enable <= BUS_DEVICE_RI;
					state <= STATE_RESPONSE;
					end
				else if (span_read_request && !span_read_grant) begin
					// dp span response data
					next_span_read_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_DATA_SELECT;
					cbus_enable <= BUS_DEVICE_DP_SPAN;
					state <= STATE_RESPONSE;
					end
				else if (cmd_read_request && !cmd_read_grant) begin
					// dp command response data
					next_cmd_read_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_DATA_SELECT;
					cbus_enable <= BUS_DEVICE_DP_CMD;
					state <= STATE_RESPONSE;
					end
				else if (vi_dma_request && dma_ready) begin
					// vi dma request
					next_vi_dma_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_ADDRESS_SELECT;
					cbus_enable <= BUS_DEVICE_VI;
					state <= STATE_DMA;
					end
				else if (si_dma_request && dma_ready) begin
					// si dma request
					next_si_dma_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_ADDRESS_SELECT;
					cbus_enable <= BUS_DEVICE_SI;
					state <= STATE_DMA;
					end
				else if (ai_dma_request && dma_ready) begin
					// ai dma request
					next_ai_dma_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_ADDRESS_SELECT;
					cbus_enable <= BUS_DEVICE_AI;
					state <= STATE_DMA;
					end
				else if (refresh_request && dma_ready) begin
					next_refresh_request = LOW;
					state <= STATE_REFRESH;
					end
				else if (pi_dma_request && dma_ready) begin
					// pi dma request
					next_pi_dma_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_ADDRESS_SELECT;
					cbus_enable <= BUS_DEVICE_PI;
					state <= STATE_DMA;
					end
				else if (mi_dma_request && dma_ready) begin
					// mi dma request
					next_mi_cbus_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_ADDRESS_SELECT;
					cbus_enable <= BUS_DEVICE_MI;
					state <= STATE_DMA;
					end
				else if (sp_dma_request && dma_ready) begin
					// sp dma request
					next_sp_dma_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_ADDRESS_SELECT;
					cbus_enable <= BUS_DEVICE_SP;
					state <= STATE_DMA;
					end
				else if (cmd_dma_request && dma_ready) begin
					// dp command dma request
					next_cmd_dma_grant_a1 = HIGH;
					cbus_enable <= BUS_DEVICE_DP_CMD;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_ADDRESS_SELECT;
					state <= STATE_DMA;
					end
				else if (span_dma_request && dma_ready) begin
					// dp span dma request
					next_span_dma_grant_a1 = HIGH;
					cbus_enable <= BUS_DEVICE_DP_SPAN;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_ADDRESS_SELECT;
					state <= STATE_DMA;
					end
				else if (mi_write_request && !mi_cbus_grant) begin
					// mi write request
					next_mi_cbus_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_ADDRESS_SELECT;
					cbus_enable <= BUS_DEVICE_MI;
					state <= STATE_WRITE;
					end
				else if (mi_read_request && !mi_cbus_grant) begin
					// mi read request
					next_mi_cbus_grant_a1 = HIGH;
					next_read_disable = HIGH;
					next_cbus_select = CBUS_ADDRESS_SELECT;
					cbus_enable <= BUS_DEVICE_MI;
					state <= STATE_READ;
					end
				else begin
					state <= STATE_IDLE;
					end
				end

			STATE_DMA : begin
				next_cbus_select = CBUS_LENGTH_SELECT;
				next_cbus_command = CBUS_DMA_COMMAND;
				state <= STATE_DELAY;
				end

			STATE_WRITE : begin
				next_cbus_select = CBUS_DATA_SELECT;
				next_cbus_command = CBUS_WRITE_COMMAND;
				state <= STATE_DELAY;
				end

			STATE_READ : begin
				next_cbus_command = CBUS_READ_COMMAND;
				state <= STATE_DELAY;
				end

			STATE_RESPONSE : begin
				next_cbus_command = CBUS_RESPONSE_COMMAND;
				state <= STATE_DELAY;
				end

			STATE_REFRESH : begin
				next_cbus_command = CBUS_REFRESH_COMMAND;
				state <= STATE_DELAY;
				end

			STATE_DELAY : begin
				state <= STATE_IDLE;
				end

			default : begin
				state <= STATE_IDLE;
				end
			endcase

		sp_dma_grant_a1 <= next_sp_dma_grant_a1;
		sp_read_grant_a1 <= next_sp_read_grant_a1;
		mi_cbus_grant_a1 <= next_mi_cbus_grant_a1;
		cmd_dma_grant_a1 <= next_cmd_dma_grant_a1;
		cmd_read_grant_a1 <= next_cmd_read_grant_a1;
		span_dma_grant_a1 <= next_span_dma_grant_a1;
		span_read_grant_a1 <= next_span_read_grant_a1;
		ri_read_grant_a1 <= next_ri_read_grant_a1;
		pi_dma_grant_a1 <= next_pi_dma_grant_a1;
		pi_read_grant_a1 <= next_pi_read_grant_a1;
		si_dma_grant_a1 <= next_si_dma_grant_a1;
		si_read_grant_a1 <= next_si_read_grant_a1;
		ai_dma_grant_a1 <= next_ai_dma_grant_a1;
		ai_read_grant_a1 <= next_ai_read_grant_a1;
		vi_dma_grant_a1 <= next_vi_dma_grant_a1;
		vi_read_grant_a1 <= next_vi_read_grant_a1;

		read_disable <= next_read_disable;
		refresh_request <= next_refresh_request || refresh_strobe;
		cbus_command <= next_cbus_command;
		cbus_select <= next_cbus_select;
		end
	end
endmodule