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

Subversion Repositories theia_gpu

[/] [theia_gpu/] [branches/] [beta_1.2/] [rtl/] [CONTROL/] [Unit_Control.v] - Blame information for rev 71

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


/**********************************************************************************
Theia, Ray Cast Programable graphic Processing Unit.
Copyright (C) 2010  Diego Valverde (diego.valverde.g@gmail.com)
 
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 2
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, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
***********************************************************************************/
/**********************************************************************************
Description:
 
This is the main Finite State Machine.
 
**********************************************************************************/
 
`timescale 1ns / 1ps
`include "aDefinitions.v"
 
`define CU_AFTER_RESET_STATE 0
`define CU_WAIT_FOR_INITIAL_CONFIGURATION 1
`define CU_TRIGGER_CONFIGURATION_DATA_READ 2
`define CU_WAIT_FOR_CONFIG_DATA_READ    3
`define CU_ACK_CONFIG_DATA_READ 4
`define CU_PRECALCULATE_CONSTANTS 5
`define CU_WAIT_FOR_CONSTANT 6
`define CU_ACK_PRECALCULATE_CONSTANTS 7
`define CU_WAIT_FOR_TASK 8
`define CU_READ_TASK_DATA 9
`define CU_WAIT_TASK_DATA_READ 10
`define CU_ACK_TASK_DATA_READ 11
`define CU_TRIGGER_RGU 12
`define CU_WAIT_FOR_RGU 13
`define CU_ACK_RGU 14
`define CU_TRIGGER_GEO 15
`define CU_WAIT_FOR_GEO_SYNC 16
//`define CU_CHECK_AABBIU_REQUEST 17
`define CU_TRIGGER_TCC 17
//`define CU_CHECK_BIU_REQUEST 18
`define CU_TRIGGER_TFF 18
//`define CU_CHECK_GEO_DONE 19
`define CU_WAIT_FOR_TFF 19
`define CU_TRIGGER_AABBIU 20
`define CU_WAIT_FOR_AABBIU 21
`define CU_TRIGGER_BIU 22
`define CU_WAIT_FOR_BIU 23
`define CU_ACK_UCODE 24
`define CU_TRIGGER_PSU 25
`define CU_WAIT_FOR_PSU 26
`define CU_ACK_PSU 27
`define CU_TRIGGER_PCU 28
`define CU_WAIT_FOR_PCU 29
`define CU_ACK_PCU 30
`define CU_CHECK_HIT 31
`define CU_CLEAR_REGISTERS 32
`define CU_WAIT_CLEAR_REGISTERS 33
`define CU_ACK_CLEAR_REGISTERS  34
`define CU_TRIGGER_PSU_WITH_TEXTURE 35
`define WAIT_FOR_TCC 36
`define CU_TRIGGER_NPU 37
`define CU_WAIT_NPU 38
`define CU_ACK_NPU 39
`define CU_PERFORM_INTIAL_CONFIGURATION 40
`define CU_SET_PICTH 41
`define CU_TRIGGER_USERCONSTANTS 42
`define CU_WAIT_USERCONSTANTS           43
`define CU_ACK_USERCONSTANTS 44
`define CU_TRIGGER_USERPIXELSHADER 45
`define CU_WAIT_FOR_USERPIXELSHADER 46
`define CU_ACK_USERPIXELSHADER 47
 
//--------------------------------------------------------------
module ControlUnit
(
 
input  wire                                  Clock,
input  wire                                  Reset,
input  wire[15:0]                            iControlRegister,
output reg                                   oGFUEnable,
input    wire                                  iTriggerAABBIURequest,
input   wire                                   iTriggerBIURequest,
input wire                                   iTriggertTCCRequest,
output reg                                   oUCodeEnable,
output reg[`ROM_ADDRESS_WIDTH-1:0]           oCodeInstructioPointer,
input   wire                                   iUCodeDone,
input wire                                   iUCodeReturnValue,
input wire                                   iGFUDone,
input wire                                   iGEOSync,
output reg                                   oTriggerTFF,
input wire                                   iTFFDone,
input wire                                   MST_I,
output reg[2:0]                              oRamBusOwner,
input wire                                   iIODone,
output reg                                   oSetCurrentPitch,
output reg                                   oFlipMemEnabled,
output reg                                   oFlipMem,
output reg                                   oIOWritePixel
 
);
 
//Internal State Machine varibles
reg     [5:0]    CurrentState;
reg     [5:0]    NextState;
integer ucode_file;
reg rResetHitFlop,rHitFlopEnable;
wire wHit;
 
`ifdef DUMP_CODE
        integer log;
 
        initial
        begin
 
        $display("Opening ucode dump file....\n");
        ucode_file = $fopen("CU.log","w");
        end
 
`endif
 
//--------------------------------------------------------------
FFToggleOnce_1Bit FFTO1
(
        .Clock( Clock ),
        .Reset( rResetHitFlop ),
        .Enable( rHitFlopEnable && iUCodeDone ),
        .S( iUCodeReturnValue ),
        .Q( wHit )
);
//--------------------------------------------------------------
 
`ifdef DEBUG
        always @ ( wHit )
        begin
                `LOGME "*** Triangle HIT ***\n");
        end
`endif
 
//Next states logic and Reset sequence
always @(posedge Clock or posedge Reset)
  begin
 
    if (Reset)
                CurrentState <= `CU_AFTER_RESET_STATE;
    else
                CurrentState <= NextState;
 
  end
 
//--------------------------------------------------------------
always @ ( * )
begin
        case (CurrentState)
        //-----------------------------------------
        `CU_AFTER_RESET_STATE:
        begin
 
        `ifdef DEBUG
                `LOGME"%d CU_AFTER_RESET_STATE\n",$time);
        `endif
 
                oRamBusOwner                            <= 0;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_INITIAL;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 1;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 1;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState                                       <= `CU_WAIT_FOR_INITIAL_CONFIGURATION;
 
        end
        //-----------------------------------------
 
        `CU_WAIT_FOR_INITIAL_CONFIGURATION:
        begin
        $display("CU_WAIT_FOR_INITIAL_CONFIGURATION");
//              `ifdef DEBUG
//                      `LOGME"%d Control: CU_WAIT_FOR_INITIAL_CONFIGURATION\n",$time);
//              `endif
 
                oRamBusOwner                            <= 0;
                oCodeInstructioPointer  <= 0;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 1;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;         
 
                if ( MST_I  )
                        NextState <= `CU_PERFORM_INTIAL_CONFIGURATION;//`CU_WAIT_FOR_CONFIG_DATA_READ;
                else
                        NextState <= `CU_WAIT_FOR_INITIAL_CONFIGURATION;
 
 
        end
        //-----------------------------------------
        `CU_PERFORM_INTIAL_CONFIGURATION:
        begin
        oRamBusOwner                            <= 0;
                oCodeInstructioPointer  <= 0;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 1;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;         
 
                if ( MST_I  )
                        NextState <= `CU_PERFORM_INTIAL_CONFIGURATION;//`CU_WAIT_FOR_CONFIG_DATA_READ;
                else
                        NextState <= `CU_CLEAR_REGISTERS;
 
        end
        //-----------------------------------------
        `CU_CLEAR_REGISTERS:
        begin
        `ifdef DEBUG
                `LOGME"%d CU_CLEAR_REGISTERS\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_INITIAL;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 1;   //*
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 1;
                //$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);
                //oIncCurrentPitch        <= 0;
 
                NextState                                       <= `CU_WAIT_CLEAR_REGISTERS;
        end
//-----------------------------------------     
        `CU_WAIT_CLEAR_REGISTERS:
        begin
//      `ifdef DEBUG
//              `LOGME"%d CU_WAIT_CLEAR_REGISTERS\n",$time);
//      `endif  
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_INITIAL;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_CLEAR_REGISTERS;
                else
                        NextState <= `CU_WAIT_CLEAR_REGISTERS;
 
        end
        //-----------------------------------------
        `CU_ACK_CLEAR_REGISTERS:
        begin
        `ifdef DEBUG
                `LOGME"%d CU_ACK_CLEAR_REGISTERS\n", $time);
        `endif
 
                oRamBusOwner                            <= 0;
                oCodeInstructioPointer  <= 0;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0; //*        
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_FOR_CONFIG_DATA_READ;
        end
 
 
 
        //-----------------------------------------
        `CU_WAIT_FOR_CONFIG_DATA_READ:
        begin
        $display("CU_WAIT_FOR_CONFIG_DATA_READ");
//              `ifdef DEBUG
//                      `LOGME"%d Control: CU_WAIT_FOR_CONFIG_DATA_READ\n",$time);
//              `endif
 
                oRamBusOwner                            <= 0;//`REG_BUS_OWNED_BY_BCU;
                oCodeInstructioPointer  <= 0;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( MST_I == 0  )
                        NextState <= `CU_PRECALCULATE_CONSTANTS;
                else
                        NextState <= `CU_WAIT_FOR_CONFIG_DATA_READ;
 
        end
        //-----------------------------------------
        `CU_PRECALCULATE_CONSTANTS:
        begin
        $display("CU_PRECALCULATE_CONSTANTS");
        `ifdef DEBUG
                `LOGME"%d Control: CU_PRECALCULATE_CONSTANTS\n", $time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_CPPU;
                oGFUEnable                              <= 0;
                oUCodeEnable                            <= 1; //*       
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_FOR_CONSTANT;
 
        end
        //-----------------------------------------
        `CU_WAIT_FOR_CONSTANT:
        begin
//      `ifdef DEBUG
//              `LOGME"%d Control: CU_WAIT_FOR_CONSTANT\n", $time);
//      `endif
 
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_CPPU;
                oGFUEnable                                 <= 0;
                oUCodeEnable                            <= 0; //*        
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_PRECALCULATE_CONSTANTS;
                else
                        NextState <= `CU_WAIT_FOR_CONSTANT;
 
        end
        //-----------------------------------------
        `CU_ACK_PRECALCULATE_CONSTANTS:
        begin
        $display("CU_ACK_PRECALCULATE_CONSTANTS");
        `ifdef DEBUG
                `LOGME"%d Control: CU_ACK_PRECALCULATE_CONSTANTS\n", $time);
        `endif
 
 
                oRamBusOwner                            <= 0;//`REG_BUS_OWNED_BY_BCU;
                oCodeInstructioPointer  <= 0;
                oGFUEnable                                 <= 0;
                oUCodeEnable                            <= 0; //*        
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_TRIGGER_USERCONSTANTS;//CU_WAIT_FOR_TASK;
 
        end
        //-----------------------------------------
 
        `CU_TRIGGER_USERCONSTANTS:
        begin
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_RGU\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_USERCONSTANTS;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 1;   //*
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_USERCONSTANTS;
        end
        //-----------------------------------------
        `CU_WAIT_USERCONSTANTS:
        begin
 
//      `ifdef DEBUG
//              `LOGME"%d Control: CU_WAIT_FOR_RGU\n",$time);
//      `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_USERCONSTANTS;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_USERCONSTANTS;
                else
                        NextState <= `CU_WAIT_USERCONSTANTS;
        end
        //-----------------------------------------
        `CU_ACK_USERCONSTANTS:
        begin
 
        `ifdef DEBUG
                `LOGME"%d Control: CU_ACK_RGU\n",$time);
        `endif
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= 0;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0; //*        
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone  == 0)
                        NextState <= `CU_TRIGGER_RGU;
                else
                        NextState <= `CU_ACK_USERCONSTANTS;
 
        end
        //-----------------------------------------
        `CU_TRIGGER_RGU:
        begin
 
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_RGU\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_RGU;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 1;   //*
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_FOR_RGU;
        end
        //-----------------------------------------
        `CU_WAIT_FOR_RGU:
        begin
 
//      `ifdef DEBUG
//              `LOGME"%d Control: CU_WAIT_FOR_RGU\n",$time);
//      `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= 0;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_RGU;
                else
                        NextState <= `CU_WAIT_FOR_RGU;
        end
        //-----------------------------------------
        `CU_ACK_RGU:
        begin
 
        `ifdef DEBUG
                `LOGME"%d Control: CU_ACK_RGU\n",$time);
        `endif
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= 0;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0; //*        
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone  == 0)
                        NextState <= `CU_TRIGGER_GEO;
                else
                        NextState <= `CU_ACK_RGU;
 
        end
        //-----------------------------------------
        `CU_TRIGGER_GEO:
        begin
 
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_GEO\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_GFU;
                oCodeInstructioPointer  <= 0;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 1;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 1;   //*
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_FOR_GEO_SYNC;
 
        end
        //-----------------------------------------
        `CU_WAIT_FOR_GEO_SYNC:
        begin
 
        `ifdef DEBUG
                `LOGME"%d Control: CU_WAIT_FOR_GEO_SYNC\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_GFU;
                oCodeInstructioPointer  <= 0;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 0; //Change AUg 15
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
        if (iGEOSync & iTriggerAABBIURequest )
                NextState <= `CU_TRIGGER_AABBIU;
        else if (iGEOSync & iTriggerBIURequest)
                NextState <= `CU_TRIGGER_BIU;
        else if (iGEOSync & iTriggertTCCRequest )
      NextState <= `CU_TRIGGER_TCC;
   else if (iGEOSync & iGFUDone )
      NextState <= `CU_CHECK_HIT;
   else
      NextState <= `CU_WAIT_FOR_GEO_SYNC;
 
        end
        //-----------------------------------------
        `CU_TRIGGER_TCC:
        begin
        //$display("CU_TRIGGER_TCC");
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_TCC\n",$time);
        `endif
 
           oRamBusOwner                                 <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_TCC;
                oUCodeEnable                            <= 1;   //*
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 1; //We need u,v from last IO read cycle
                //$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);
                //oIncCurrentPitch        <= 0;
 
          NextState  <= `WAIT_FOR_TCC;
        end
        //-----------------------------------------
        `WAIT_FOR_TCC:
        begin
 
        //$display("WAIT_FOR_TCC");
           oRamBusOwner                                 <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_TCC;
                oUCodeEnable                            <= 0;    //*
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
           if ( iUCodeDone )
                        NextState <= `CU_ACK_UCODE;
                else
                        NextState <= `WAIT_FOR_TCC;
 
        end
        //-----------------------------------------
        /*
        Was there any hit at all?
        At this point, all the triangles in the list
        have been traversed looking for a hit with our ray.
        There are 3 possibilities:
        1) The was not a single hit, then just paint a black
        pixel on the screen and send it via PCU.
        2)There was a hit and Texturing is not enabled, then trigger the PSU with
        no texturing
        2) There was a hit and Texturing is enabled, then fetch the texture
        values corresponding to the triangle that we hitted.
        */
        `CU_CHECK_HIT:
        begin
 
        `ifdef DEBUG
                `LOGME"%d Control: CU_CHECK_HIT\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_GFU;
                oCodeInstructioPointer  <= 0;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 0;    ///CHANGED Aug 15
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
           oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 1;
                //$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);
                //oIncCurrentPitch        <= 0;
 
                if (wHit && !iControlRegister[`CR_EN_TEXTURE] )
                        NextState <= `CU_TRIGGER_PSU;
                else if (wHit && iControlRegister[`CR_EN_TEXTURE])
                        NextState <= `CU_TRIGGER_TFF;           //Fetch the texture values from external RAM
                else
                        NextState <= `CU_TRIGGER_PCU;           //Make sure contents of the OUT_REG are ZERo!
        end
        //-----------------------------------------
        /*
        Get the texture values from external RAM.
        GFU already took care of calculating the correct
        texture addresses for the 4 coordinates so now lets
        just ask for them.
        */
        `CU_TRIGGER_TFF:
        begin
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_TFF\n",$time);
        `endif
 
        //$display("CU_TRIGGER_TFF");
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_GFU;
                oCodeInstructioPointer  <= 0;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 1;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 1;       //*
           oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;  //NO need, we did this n check hit
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_FOR_TFF;
        end
        //-----------------------------------------
        `CU_WAIT_FOR_TFF:
        begin
 
           oRamBusOwner                                 <= `REG_BUS_OWNED_BY_GFU;
                oCodeInstructioPointer  <= 0;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 0;     //Changed Aug 14
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
 
                //oIncCurrentPitch        <= 0;
 
        if (iTFFDone)
                NextState <= `CU_TRIGGER_PSU_WITH_TEXTURE;
        else
                NextState <= `CU_WAIT_FOR_TFF;
 
        end
        //-----------------------------------------
        `CU_TRIGGER_PSU_WITH_TEXTURE:
        begin
 
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_PSU_WITH_TEXTURE\n",$time);
        `endif
 
           oRamBusOwner                                 <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_PSU2;
                oUCodeEnable                            <= 1;
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 1;
                //$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);
           //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_FOR_PSU;
        end
        //-----------------------------------------
        `CU_TRIGGER_AABBIU:
        begin
 
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_AABBIU\n",$time);
        `endif
//      $stop();
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
 
                oCodeInstructioPointer  <=`ENTRYPOINT_INDEX_AABBIU;
                oUCodeEnable                            <= 1;
                oGFUEnable                                      <= 1;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 1;
                //$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_FOR_AABBIU;
        end
        //-----------------------------------------
        `CU_WAIT_FOR_AABBIU:
        begin
 
 
//      `ifdef DEBUG
//              `LOGME"%d Control: CU_WAIT_FOR_AABBIU\n",$time);
//      `endif
 
 
//      $display("iUCodeDone",iUCodeDone);
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_AABBIU;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 1;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                begin
        //         $display("iUCodeDone\n",iUCodeDone);
        //              $stop();
                        NextState <= `CU_ACK_UCODE;
                end
                else
                        NextState <= `CU_WAIT_FOR_AABBIU;
        end
        //-----------------------------------------
        `CU_TRIGGER_BIU:
        begin
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_BIU\n",$time);
        `endif
 
                        oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                        oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_BIU;
                        oUCodeEnable                            <= 1;
                        oGFUEnable                                      <= 1;
                        oIOWritePixel                           <= 0;
                        rResetHitFlop                           <= 0;//1;        
                        rHitFlopEnable                          <= 1;
         oTriggerTFF             <= 0;
                        oSetCurrentPitch        <= 0;
                        oFlipMemEnabled         <= 1;
                        oFlipMem                                                <= 1;
                        //$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);
                        //oIncCurrentPitch        <= 0;
                //      $stop();
 
                        NextState <= `CU_WAIT_FOR_BIU;
 
        end
        //-----------------------------------------
        `CU_WAIT_FOR_BIU:
        begin
//      `ifdef DEBUG
//              `LOGME"%d Control: CU_WAIT_FOR_BIU\n",$time);
//      `endif
 
                        oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                        oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_BIU;
                        oUCodeEnable                            <= 0;
                        oGFUEnable                                      <= 1;
                        oIOWritePixel                           <= 0;
                        rResetHitFlop                           <= 0;
                        rHitFlopEnable                          <= 1;
         oTriggerTFF             <= 0;
                        oSetCurrentPitch        <= 0;
                        oFlipMemEnabled         <= 1;
                        oFlipMem                                                <= 0;
                        //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_UCODE;
                else
                        NextState <= `CU_WAIT_FOR_BIU;
        end
        //-----------------------------------------
        /*
                ACK UCODE by setting oUCodeEnable = 0
        */
        `CU_ACK_UCODE:
        begin
        `ifdef DEBUG
                `LOGME"%d Control: CU_ACK_UCODE\n",$time);
        `endif
 
                        oRamBusOwner                            <= `REG_BUS_OWNED_BY_GFU;
                        oCodeInstructioPointer  <= 0; //*
                        oUCodeEnable                            <= 0;    //*
                        oGFUEnable                                      <= 0; //Changed Aug 15
                        oIOWritePixel                           <= 0;
                        rResetHitFlop                           <= 0;
                        rHitFlopEnable                          <= 0;
         oTriggerTFF             <= 0;
                        oSetCurrentPitch        <= 0;
                        oFlipMemEnabled         <= 0;
                        oFlipMem                                                <= 0;
                        //oIncCurrentPitch        <= 0;
 
        //              $stop();
 
                        if ( iUCodeDone == 0 )
                                NextState <= `CU_WAIT_FOR_GEO_SYNC;
                        else
                                NextState <= `CU_ACK_UCODE;
        end
        //-----------------------------------------
        /*
        Here we no longer use GFU so set Enable to zero
        */
        `CU_TRIGGER_PSU:
        begin
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_PSU\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_PSU;
                oUCodeEnable                            <= 1;
                oGFUEnable                                      <= 0;//*
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 1;
                //$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);
                //oIncCurrentPitch        <= 0;
 
 
                NextState <= `CU_WAIT_FOR_PSU;
        end
        //-----------------------------------------
        `CU_WAIT_FOR_PSU:
        begin
 
//      `ifdef DEBUG
//              `LOGME"%d Control: CU_TRIGGER_PSU\n",$time);
//      `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_PSU;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_PSU;
                else
                        NextState <= `CU_WAIT_FOR_PSU;
 
        end
        //-----------------------------------------
        `CU_ACK_PSU:
        begin
        `ifdef DEBUG
                `LOGME"%d Control: CU_ACK_PSU\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= 0;    //*
                oUCodeEnable                            <= 0;    //*
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone  == 0)
                        NextState <= `CU_TRIGGER_USERPIXELSHADER;
                else
                        NextState <= `CU_ACK_PSU;
 
 
        end
        //-----------------------------------------
        /*
                Trigger the Pixel Commit.
        */
        `CU_TRIGGER_PCU:
        begin
 
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_PCU\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_GFU;
                oCodeInstructioPointer  <= 0;    //*
                oUCodeEnable                            <= 0;    //*
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 1; //*
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 1;
                //$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);
                //oIncCurrentPitch        <= 0;
 
 
                NextState <= `CU_SET_PICTH;
 
        end
        //-----------------------------------------
        `CU_SET_PICTH:
        begin
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_GFU;
                oCodeInstructioPointer  <= 0;    //*
                oUCodeEnable                            <= 0;    //*
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 1; //*
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 1; //*
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
 
                NextState <= `CU_WAIT_FOR_PCU;
        end
        //-----------------------------------------
        `CU_WAIT_FOR_PCU:
        begin
 
//      `ifdef DEBUG
//              `LOGME"%d Control: CU_WAIT_FOR_PCU\n",$time);
//      `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_GFU;
                oCodeInstructioPointer  <= 0;    //*
                oUCodeEnable                            <= 0;    //*
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 1;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iIODone )
                        NextState <= `CU_ACK_PCU;
                else
                        NextState <= `CU_WAIT_FOR_PCU;
 
        end
        //-----------------------------------------
        `CU_ACK_PCU:
        begin
 
        `ifdef DEBUG
                `LOGME"%d Control: CU_ACK_PCU\n",$time);
        `endif
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_GFU;
                oCodeInstructioPointer  <= 0;    //*
                oUCodeEnable                            <= 0;    //*
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_TRIGGER_NPU;
 
        end
        //-----------------------------------------
        `CU_TRIGGER_NPU: //Next Pixel Unit
        begin
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_NPU\n",$time);
        `endif
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_NPG;       //*
                oUCodeEnable                            <= 1;   //*
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_NPU;
        end
        //-----------------------------------------
        `CU_WAIT_NPU:
        begin
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_NPG;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_NPU;
                else
                        NextState <= `CU_WAIT_NPU;
        end
        //-----------------------------------------
        `CU_ACK_NPU:
        begin
        `ifdef DEBUG
                `LOGME"%d Control: CU_ACK_PSU\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= 0;    //*
                oUCodeEnable                            <= 0;    //*
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone  == 0)
                        NextState <= `CU_TRIGGER_RGU;
                else
                        NextState <= `CU_ACK_NPU;
 
 
        end
        //-----------------------------------------
        //-----------------------------------------
        /*
        Here we no longer use GFU so set Enable to zero
        */
        `CU_TRIGGER_USERPIXELSHADER:
        begin
        `ifdef DEBUG
                `LOGME"%d Control: CU_TRIGGER_PSU\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_PIXELSHADER;
                oUCodeEnable                            <= 1;
                oGFUEnable                                      <= 0;//*
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
 
                NextState <= `CU_WAIT_FOR_USERPIXELSHADER;
        end
        //-----------------------------------------
        `CU_WAIT_FOR_USERPIXELSHADER:
        begin
 
//      `ifdef DEBUG
//              `LOGME"%d Control: CU_TRIGGER_PSU\n",$time);
//      `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_PIXELSHADER;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_USERPIXELSHADER;
                else
                        NextState <= `CU_WAIT_FOR_USERPIXELSHADER;
 
        end
        //-----------------------------------------
        `CU_ACK_USERPIXELSHADER:
        begin
        `ifdef DEBUG
                `LOGME"%d Control: CU_ACK_PSU\n",$time);
        `endif
 
                oRamBusOwner                            <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= 0;    //*
                oUCodeEnable                            <= 0;    //*
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone  == 0)
                        NextState <= `CU_TRIGGER_PCU;
                else
                        NextState <= `CU_ACK_USERPIXELSHADER;
 
 
        end
        //---------------------------------------------------
        default:
        begin
 
        `ifdef DEBUG
                `LOGME"%d Control: ERRO Undefined State\n",$time);
        `endif
 
                oRamBusOwner                            <= 0;
                oCodeInstructioPointer  <= 0;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_AFTER_RESET_STATE;
        end
        //-----------------------------------------
 
        endcase
 
end //always    
endmodule

Line No.	Rev	Author	Line
1	18	diegovalve	`/**********************************************************************************`
2			`Theia, Ray Cast Programable graphic Processing Unit.`
3			`Copyright (C) 2010 Diego Valverde (diego.valverde.g@gmail.com)`
4
5			`This program is free software; you can redistribute it and/or`
6			`modify it under the terms of the GNU General Public License`
7			`as published by the Free Software Foundation; either version 2`
8			`of the License, or (at your option) any later version.`
9
10			`This program is distributed in the hope that it will be useful,`
11			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
12			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
13			`GNU General Public License for more details.`
14
15			`You should have received a copy of the GNU General Public License`
16			`along with this program; if not, write to the Free Software`
17			`Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.`
18
19			`***********************************************************************************/`
20			`/**********************************************************************************`
21			`Description:`
22
23			`This is the main Finite State Machine.`
24
25			`**********************************************************************************/`
26
27			`timescale 1ns / 1ps
28			`include "aDefinitions.v"
29
30			`define CU_AFTER_RESET_STATE 0
31			`define CU_WAIT_FOR_INITIAL_CONFIGURATION 1
32			`define CU_TRIGGER_CONFIGURATION_DATA_READ 2
33			`define CU_WAIT_FOR_CONFIG_DATA_READ 3
34			`define CU_ACK_CONFIG_DATA_READ 4
35			`define CU_PRECALCULATE_CONSTANTS 5
36			`define CU_WAIT_FOR_CONSTANT 6
37			`define CU_ACK_PRECALCULATE_CONSTANTS 7
38			`define CU_WAIT_FOR_TASK 8
39			`define CU_READ_TASK_DATA 9
40			`define CU_WAIT_TASK_DATA_READ 10
41			`define CU_ACK_TASK_DATA_READ 11
42			`define CU_TRIGGER_RGU 12
43			`define CU_WAIT_FOR_RGU 13
44			`define CU_ACK_RGU 14
45			`define CU_TRIGGER_GEO 15
46			`define CU_WAIT_FOR_GEO_SYNC 16
47			//`define CU_CHECK_AABBIU_REQUEST 17
48			`define CU_TRIGGER_TCC 17
49			//`define CU_CHECK_BIU_REQUEST 18
50			`define CU_TRIGGER_TFF 18
51			//`define CU_CHECK_GEO_DONE 19
52			`define CU_WAIT_FOR_TFF 19
53			`define CU_TRIGGER_AABBIU 20
54			`define CU_WAIT_FOR_AABBIU 21
55			`define CU_TRIGGER_BIU 22
56			`define CU_WAIT_FOR_BIU 23
57			`define CU_ACK_UCODE 24
58			`define CU_TRIGGER_PSU 25
59			`define CU_WAIT_FOR_PSU 26
60			`define CU_ACK_PSU 27
61			`define CU_TRIGGER_PCU 28
62			`define CU_WAIT_FOR_PCU 29
63			`define CU_ACK_PCU 30
64			`define CU_CHECK_HIT 31
65			`define CU_CLEAR_REGISTERS 32
66			`define CU_WAIT_CLEAR_REGISTERS 33
67			`define CU_ACK_CLEAR_REGISTERS 34
68			`define CU_TRIGGER_PSU_WITH_TEXTURE 35
69			`define WAIT_FOR_TCC 36
70			`define CU_TRIGGER_NPU 37
71			`define CU_WAIT_NPU 38
72			`define CU_ACK_NPU 39
73			`define CU_PERFORM_INTIAL_CONFIGURATION 40
74			`define CU_SET_PICTH 41
75	63	diegovalve	`define CU_TRIGGER_USERCONSTANTS 42
76			`define CU_WAIT_USERCONSTANTS 43
77			`define CU_ACK_USERCONSTANTS 44
78			`define CU_TRIGGER_USERPIXELSHADER 45
79			`define CU_WAIT_FOR_USERPIXELSHADER 46
80			`define CU_ACK_USERPIXELSHADER 47
81	18	diegovalve
82			`//--------------------------------------------------------------`
83			`module ControlUnit`
84			`(`
85
86			`input wire Clock,`
87			`input wire Reset,`
88			`input wire[15:0] iControlRegister,`
89			`output reg oGFUEnable,`
90			`input wire iTriggerAABBIURequest,`
91			`input wire iTriggerBIURequest,`
92			`input wire iTriggertTCCRequest,`
93			`output reg oUCodeEnable,`
94	60	diegovalve	output reg[`ROM_ADDRESS_WIDTH-1:0] oCodeInstructioPointer,
95	18	diegovalve	`input wire iUCodeDone,`
96			`input wire iUCodeReturnValue,`
97			`input wire iGFUDone,`
98			`input wire iGEOSync,`
99			`output reg oTriggerTFF,`
100			`input wire iTFFDone,`
101			`input wire MST_I,`
102			`output reg[2:0] oRamBusOwner,`
103			`input wire iIODone,`
104			`output reg oSetCurrentPitch,`
105	71	diegovalve	`output reg oFlipMemEnabled,`
106			`output reg oFlipMem,`
107	18	diegovalve	`output reg oIOWritePixel`
108
109			`);`
110
111			`//Internal State Machine varibles`
112			`reg [5:0] CurrentState;`
113			`reg [5:0] NextState;`
114			`integer ucode_file;`
115			`reg rResetHitFlop,rHitFlopEnable;`
116			`wire wHit;`
117
118			`ifdef DUMP_CODE
119			`integer log;`
120
121			`initial`
122			`begin`
123
124			`$display("Opening ucode dump file....\n");`
125			`ucode_file = $fopen("CU.log","w");`
126			`end`
127
128			`endif
129
130			`//--------------------------------------------------------------`
131			`FFToggleOnce_1Bit FFTO1`
132			`(`
133			`.Clock( Clock ),`
134			`.Reset( rResetHitFlop ),`
135			`.Enable( rHitFlopEnable && iUCodeDone ),`
136			`.S( iUCodeReturnValue ),`
137			`.Q( wHit )`
138			`);`
139			`//--------------------------------------------------------------`
140
141			`ifdef DEBUG
142			`always @ ( wHit )`
143			`begin`
144			`LOGME "* Triangle HIT *\n");
145			`end`
146			`endif
147
148			`//Next states logic and Reset sequence`
149			`always @(posedge Clock or posedge Reset)`
150			`begin`
151
152			`if (Reset)`
153			CurrentState <= `CU_AFTER_RESET_STATE;
154			`else`
155			`CurrentState <= NextState;`
156
157			`end`
158
159			`//--------------------------------------------------------------`
160			`always @ ( * )`
161			`begin`
162			`case (CurrentState)`
163			`//-----------------------------------------`
164			`CU_AFTER_RESET_STATE:
165			`begin`
166
167			`ifdef DEBUG
168			`LOGME"%d CU_AFTER_RESET_STATE\n",$time);
169			`endif
170
171			`oRamBusOwner <= 0;`
172	60	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_INITIAL;
173	18	diegovalve	`oGFUEnable <= 0;`
174			`oUCodeEnable <= 0;`
175			`oIOWritePixel <= 0;`
176			`rResetHitFlop <= 1;`
177			`rHitFlopEnable <= 0;`
178			`oTriggerTFF <= 0;`
179			`oSetCurrentPitch <= 1;`
180	71	diegovalve	`oFlipMemEnabled <= 0;`
181			`oFlipMem <= 0;`
182	18	diegovalve	`//oIncCurrentPitch <= 0;`
183
184			NextState <= `CU_WAIT_FOR_INITIAL_CONFIGURATION;
185
186			`end`
187			`//-----------------------------------------`
188
189			`CU_WAIT_FOR_INITIAL_CONFIGURATION:
190			`begin`
191			`$display("CU_WAIT_FOR_INITIAL_CONFIGURATION");`
192			// `ifdef DEBUG
193			// `LOGME"%d Control: CU_WAIT_FOR_INITIAL_CONFIGURATION\n",$time);
194			// `endif
195
196			`oRamBusOwner <= 0;`
197	60	diegovalve	`oCodeInstructioPointer <= 0;`
198	18	diegovalve	`oGFUEnable <= 0;`
199			`oUCodeEnable <= 0;`
200			`oIOWritePixel <= 0;`
201			`rResetHitFlop <= 1;`
202			`rHitFlopEnable <= 0;`
203			`oTriggerTFF <= 0;`
204			`oSetCurrentPitch <= 0;`
205	71	diegovalve	`oFlipMemEnabled <= 0;`
206			`oFlipMem <= 0;`
207	18	diegovalve	`//oIncCurrentPitch <= 0;`
208
209			`if ( MST_I )`
210			NextState <= `CU_PERFORM_INTIAL_CONFIGURATION;//`CU_WAIT_FOR_CONFIG_DATA_READ;
211			`else`
212			NextState <= `CU_WAIT_FOR_INITIAL_CONFIGURATION;
213
214
215			`end`
216			`//-----------------------------------------`
217			`CU_PERFORM_INTIAL_CONFIGURATION:
218			`begin`
219			`oRamBusOwner <= 0;`
220	60	diegovalve	`oCodeInstructioPointer <= 0;`
221	18	diegovalve	`oGFUEnable <= 0;`
222			`oUCodeEnable <= 0;`
223			`oIOWritePixel <= 0;`
224			`rResetHitFlop <= 1;`
225			`rHitFlopEnable <= 0;`
226			`oTriggerTFF <= 0;`
227			`oSetCurrentPitch <= 0;`
228	71	diegovalve	`oFlipMemEnabled <= 0;`
229			`oFlipMem <= 0;`
230	18	diegovalve	`//oIncCurrentPitch <= 0;`
231
232			`if ( MST_I )`
233			NextState <= `CU_PERFORM_INTIAL_CONFIGURATION;//`CU_WAIT_FOR_CONFIG_DATA_READ;
234			`else`
235			NextState <= `CU_CLEAR_REGISTERS;
236
237			`end`
238			`//-----------------------------------------`
239			`CU_CLEAR_REGISTERS:
240			`begin`
241			`ifdef DEBUG
242			`LOGME"%d CU_CLEAR_REGISTERS\n",$time);
243			`endif
244
245			oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
246	60	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_INITIAL;
247	18	diegovalve	`oGFUEnable <= 0;`
248			`oUCodeEnable <= 1; //*`
249			`oIOWritePixel <= 0;`
250			`rResetHitFlop <= 0;`
251			`rHitFlopEnable <= 0;`
252			`oTriggerTFF <= 0;`
253			`oSetCurrentPitch <= 0;`
254	71	diegovalve	`oFlipMemEnabled <= 1;`
255			`oFlipMem <= 1;`
256			`//$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);`
257	18	diegovalve	`//oIncCurrentPitch <= 0;`
258
259			NextState <= `CU_WAIT_CLEAR_REGISTERS;
260			`end`
261			`//-----------------------------------------`
262			`CU_WAIT_CLEAR_REGISTERS:
263			`begin`
264			// `ifdef DEBUG
265			// `LOGME"%d CU_WAIT_CLEAR_REGISTERS\n",$time);
266			// `endif
267
268			oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
269	60	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_INITIAL;
270	18	diegovalve	`oGFUEnable <= 0;`
271			`oUCodeEnable <= 0;`
272			`oIOWritePixel <= 0;`
273			`rResetHitFlop <= 0;`
274			`rHitFlopEnable <= 0;`
275			`oTriggerTFF <= 0;`
276			`oSetCurrentPitch <= 0;`
277	71	diegovalve	`oFlipMemEnabled <= 1;`
278			`oFlipMem <= 0;`
279	18	diegovalve	`//oIncCurrentPitch <= 0;`
280
281			`if ( iUCodeDone )`
282			NextState <= `CU_ACK_CLEAR_REGISTERS;
283			`else`
284			NextState <= `CU_WAIT_CLEAR_REGISTERS;
285
286			`end`
287			`//-----------------------------------------`
288			`CU_ACK_CLEAR_REGISTERS:
289			`begin`
290			`ifdef DEBUG
291			`LOGME"%d CU_ACK_CLEAR_REGISTERS\n", $time);
292			`endif
293
294			`oRamBusOwner <= 0;`
295	60	diegovalve	`oCodeInstructioPointer <= 0;`
296	18	diegovalve	`oGFUEnable <= 0;`
297			`oUCodeEnable <= 0; //*`
298			`oIOWritePixel <= 0;`
299			`rResetHitFlop <= 0;`
300			`rHitFlopEnable <= 0;`
301			`oTriggerTFF <= 0;`
302			`oSetCurrentPitch <= 0;`
303	71	diegovalve	`oFlipMemEnabled <= 0;`
304			`oFlipMem <= 0;`
305	18	diegovalve	`//oIncCurrentPitch <= 0;`
306
307			NextState <= `CU_WAIT_FOR_CONFIG_DATA_READ;
308			`end`
309
310
311
312			`//-----------------------------------------`
313			`CU_WAIT_FOR_CONFIG_DATA_READ:
314			`begin`
315			`$display("CU_WAIT_FOR_CONFIG_DATA_READ");`
316			// `ifdef DEBUG
317			// `LOGME"%d Control: CU_WAIT_FOR_CONFIG_DATA_READ\n",$time);
318			// `endif
319
320			oRamBusOwner <= 0;//`REG_BUS_OWNED_BY_BCU;
321	60	diegovalve	`oCodeInstructioPointer <= 0;`
322	18	diegovalve	`oGFUEnable <= 0;`
323			`oUCodeEnable <= 0;`
324			`oIOWritePixel <= 0;`
325			`rResetHitFlop <= 0;`
326			`rHitFlopEnable <= 0;`
327			`oTriggerTFF <= 0;`
328			`oSetCurrentPitch <= 0;`
329	71	diegovalve	`oFlipMemEnabled <= 0;`
330			`oFlipMem <= 0;`
331	18	diegovalve	`//oIncCurrentPitch <= 0;`
332
333			`if ( MST_I == 0 )`
334			NextState <= `CU_PRECALCULATE_CONSTANTS;
335			`else`
336			NextState <= `CU_WAIT_FOR_CONFIG_DATA_READ;
337
338			`end`
339			`//-----------------------------------------`
340			`CU_PRECALCULATE_CONSTANTS:
341			`begin`
342			`$display("CU_PRECALCULATE_CONSTANTS");`
343			`ifdef DEBUG
344			`LOGME"%d Control: CU_PRECALCULATE_CONSTANTS\n", $time);
345			`endif
346
347			oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
348	60	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_CPPU;
349	18	diegovalve	`oGFUEnable <= 0;`
350			`oUCodeEnable <= 1; //*`
351			`oIOWritePixel <= 0;`
352			`rResetHitFlop <= 0;`
353			`rHitFlopEnable <= 0;`
354			`oTriggerTFF <= 0;`
355			`oSetCurrentPitch <= 0;`
356	71	diegovalve	`oFlipMemEnabled <= 0;`
357			`oFlipMem <= 0;`
358	18	diegovalve	`//oIncCurrentPitch <= 0;`
359
360			NextState <= `CU_WAIT_FOR_CONSTANT;
361
362			`end`
363			`//-----------------------------------------`
364			`CU_WAIT_FOR_CONSTANT:
365			`begin`
366			// `ifdef DEBUG
367			// `LOGME"%d Control: CU_WAIT_FOR_CONSTANT\n", $time);
368			// `endif
369
370
371			oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
372	60	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_CPPU;
373	18	diegovalve	`oGFUEnable <= 0;`
374			`oUCodeEnable <= 0; //*`
375			`oIOWritePixel <= 0;`
376			`rResetHitFlop <= 0;`
377			`rHitFlopEnable <= 0;`
378			`oTriggerTFF <= 0;`
379			`oSetCurrentPitch <= 0;`
380	71	diegovalve	`oFlipMemEnabled <= 0;`
381			`oFlipMem <= 0;`
382	18	diegovalve	`//oIncCurrentPitch <= 0;`
383
384			`if ( iUCodeDone )`
385			NextState <= `CU_ACK_PRECALCULATE_CONSTANTS;
386			`else`
387			NextState <= `CU_WAIT_FOR_CONSTANT;
388
389			`end`
390			`//-----------------------------------------`
391			`CU_ACK_PRECALCULATE_CONSTANTS:
392			`begin`
393			`$display("CU_ACK_PRECALCULATE_CONSTANTS");`
394			`ifdef DEBUG
395			`LOGME"%d Control: CU_ACK_PRECALCULATE_CONSTANTS\n", $time);
396			`endif
397
398
399			oRamBusOwner <= 0;//`REG_BUS_OWNED_BY_BCU;
400	60	diegovalve	`oCodeInstructioPointer <= 0;`
401	18	diegovalve	`oGFUEnable <= 0;`
402			`oUCodeEnable <= 0; //*`
403			`oIOWritePixel <= 0;`
404			`rResetHitFlop <= 0;`
405			`rHitFlopEnable <= 0;`
406			`oTriggerTFF <= 0;`
407			`oSetCurrentPitch <= 0;`
408	71	diegovalve	`oFlipMemEnabled <= 0;`
409			`oFlipMem <= 0;`
410	18	diegovalve	`//oIncCurrentPitch <= 0;`
411
412	63	diegovalve	NextState <= `CU_TRIGGER_USERCONSTANTS;//CU_WAIT_FOR_TASK;
413	18	diegovalve
414			`end`
415			`//-----------------------------------------`
416	71	diegovalve
417	63	diegovalve	`CU_TRIGGER_USERCONSTANTS:
418			`begin`
419			`ifdef DEBUG
420			`LOGME"%d Control: CU_TRIGGER_RGU\n",$time);
421			`endif
422
423			oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
424			oCodeInstructioPointer <= `ENTRYPOINT_INDEX_USERCONSTANTS;
425			`oGFUEnable <= 0;`
426			`oUCodeEnable <= 1; //*`
427			`oIOWritePixel <= 0;`
428			`rResetHitFlop <= 0;`
429			`rHitFlopEnable <= 0;`
430			`oTriggerTFF <= 0;`
431			`oSetCurrentPitch <= 0;`
432	71	diegovalve	`oFlipMemEnabled <= 0;`
433			`oFlipMem <= 0;`
434	63	diegovalve	`//oIncCurrentPitch <= 0;`
435
436			NextState <= `CU_WAIT_USERCONSTANTS;
437			`end`
438			`//-----------------------------------------`
439			`CU_WAIT_USERCONSTANTS:
440			`begin`
441
442			// `ifdef DEBUG
443			// `LOGME"%d Control: CU_WAIT_FOR_RGU\n",$time);
444			// `endif
445
446			oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
447			oCodeInstructioPointer <= `ENTRYPOINT_INDEX_USERCONSTANTS;
448			`oGFUEnable <= 0;`
449			`oUCodeEnable <= 0;`
450			`oIOWritePixel <= 0;`
451			`rResetHitFlop <= 0;`
452			`rHitFlopEnable <= 0;`
453			`oTriggerTFF <= 0;`
454			`oSetCurrentPitch <= 0;`
455	71	diegovalve	`oFlipMemEnabled <= 0;`
456			`oFlipMem <= 0;`
457	63	diegovalve	`//oIncCurrentPitch <= 0;`
458
459			`if ( iUCodeDone )`
460			NextState <= `CU_ACK_USERCONSTANTS;
461			`else`
462			NextState <= `CU_WAIT_USERCONSTANTS;
463			`end`
464			`//-----------------------------------------`
465			`CU_ACK_USERCONSTANTS:
466			`begin`
467
468			`ifdef DEBUG
469			`LOGME"%d Control: CU_ACK_RGU\n",$time);
470			`endif
471			oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
472			`oCodeInstructioPointer <= 0;`
473			`oGFUEnable <= 0;`
474			`oUCodeEnable <= 0; //*`
475			`oIOWritePixel <= 0;`
476			`rResetHitFlop <= 0;`
477			`rHitFlopEnable <= 0;`
478			`oTriggerTFF <= 0;`
479			`oSetCurrentPitch <= 0;`
480	71	diegovalve	`oFlipMemEnabled <= 0;`
481			`oFlipMem <= 0;`
482	63	diegovalve	`//oIncCurrentPitch <= 0;`
483
484			`if ( iUCodeDone == 0)`
485			NextState <= `CU_TRIGGER_RGU;
486			`else`
487			NextState <= `CU_ACK_USERCONSTANTS;
488
489			`end`
490			`//-----------------------------------------`
491	18	diegovalve	`CU_TRIGGER_RGU:
492			`begin`
493
494			`ifdef DEBUG
495			`LOGME"%d Control: CU_TRIGGER_RGU\n",$time);
496			`endif
497
498			oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
499	60	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_RGU;
500	18	diegovalve	`oGFUEnable <= 0;`

Browse

Tools

Subversion Repositories theia_gpu

[/] [theia_gpu/] [branches/] [beta_1.2/] [rtl/] [CONTROL/] [Unit_Control.v] - Blame information for rev 71