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

Subversion Repositories theia_gpu

[/] [theia_gpu/] [branches/] [gpu_8_cores/] [rtl/] [GPU/] [CORES/] [CONTROL/] [Unit_Control.v] - Blame information for rev 129

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_MAIN 22
`define CU_WAIT_FOR_MAIN 23
`define CU_ACK_MAIN 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
`define CU_DONE 48
`define CU_WAIT_FOR_RENDER_ENABLE 49
`define CU_ACK_TCC 50
`define CU_WAIT_FOR_HOST_DATA_AVAILABLE 51
//--------------------------------------------------------------
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,
input wire                                   iRenderEnable,
input wire                                   iSceneTraverseComplete,
input wire                                   iHostDataAvailable,
 
`ifdef DEBUG
input wire[`MAX_CORES-1:0]                  iDebug_CoreID,
`endif
 
output reg                                   oResultCommited,
output reg                                   oDone
 
);
 
//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_CU
        always @ ( wHit )
        begin
                $display( "*** 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_CU
                $display("%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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState                                       <= `CU_WAIT_FOR_INITIAL_CONFIGURATION;
 
        end
        //-----------------------------------------
 
        `CU_WAIT_FOR_INITIAL_CONFIGURATION:
        begin
        //$display("CORE: %d CU_WAIT_FOR_INITIAL_CONFIGURATION", iDebug_CoreID);
//              `ifdef DEBUG_CU
//                      $display("%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;
                oDone                   <= 0;
                oResultCommited                 <= 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
        //$display("CORE: %d CU_PERFORM_INTIAL_CONFIGURATION", iDebug_CoreID);
        //oRamBusOwner                          <= 0;
                oCodeInstructioPointer  <= 0;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 1;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;         
 
                if ( MST_I  == 0 && iRenderEnable == 1'b1)
                        NextState <= `CU_CLEAR_REGISTERS;//`CU_WAIT_FOR_CONFIG_DATA_READ;
                else
                        NextState <= `CU_PERFORM_INTIAL_CONFIGURATION;
 
 
        end
        //-----------------------------------------
        `CU_CLEAR_REGISTERS:
        begin
        //$display("CORE: %d CU_CLEAR_REGISTERS", iDebug_CoreID);
        `ifdef DEBUG_CU
                $display("%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                                                <= 0;
                oDone                   <= 0;
                oResultCommited                 <= 0;
 
                ////$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_CU
//              $display("%d CU_WAIT_CLEAR_REGISTERS\n",$time);
//      `endif  
                //$display("CORE: %d CU_WAIT_CLEAR_REGISTERS", iDebug_CoreID);
                //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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_CLEAR_REGISTERS;
                else
                        NextState <= `CU_WAIT_CLEAR_REGISTERS;
 
        end
        //-----------------------------------------
        `CU_ACK_CLEAR_REGISTERS:
        begin
 
        `ifdef DEBUG_CU
                $display("%d CU_ACK_CLEAR_REGISTERS\n", $time);
        `endif
 
        //$display("CORE: %d CU_ACK_CLEAR_REGISTERS", iDebug_CoreID);
 
                //oRamBusOwner                          <= 0;
                oCodeInstructioPointer  <= 0;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0; //*        
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_FOR_CONFIG_DATA_READ;
        end
 
 
 
        //-----------------------------------------
        `CU_WAIT_FOR_CONFIG_DATA_READ:
        begin
 
//              `ifdef DEBUG_CU
//                      $display("%d Control: CU_WAIT_FOR_CONFIG_DATA_READ\n",$time);
//              `endif
 
 
//$display("CORE: %d CU_WAIT_FOR_CONFIG_DATA_READ", iDebug_CoreID);
 
                //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;
                oDone                   <= 0;
                oResultCommited                 <= 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("CORE: %d CU_PRECALCULATE_CONSTANTS", iDebug_CoreID);
        `ifdef DEBUG_CU
                $display("%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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_FOR_CONSTANT;
 
        end
        //-----------------------------------------
        `CU_WAIT_FOR_CONSTANT:
        begin
//      `ifdef DEBUG_CU
//              $display("%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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_PRECALCULATE_CONSTANTS;
                else
                        NextState <= `CU_WAIT_FOR_CONSTANT;
 
        end
        //-----------------------------------------
        `CU_ACK_PRECALCULATE_CONSTANTS:
        begin
        //$display("CORE: %d CU_ACK_PRECALCULATE_CONSTANTS", iDebug_CoreID);
        `ifdef DEBUG_CU
                $display("%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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_TRIGGER_USERCONSTANTS;//CU_WAIT_FOR_TASK;
 
        end
        //-----------------------------------------
 
        `CU_TRIGGER_USERCONSTANTS:
        begin
        `ifdef DEBUG_CU
                $display("%d Control: CU_TRIGGER_USERCONSTANTS\n",$time);
        `endif
 
                //$display("CORE: %d CU_TRIGGER_USERCONSTANTS", iDebug_CoreID);
 
                //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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_USERCONSTANTS;
        end
        //-----------------------------------------
        `CU_WAIT_USERCONSTANTS:
        begin
 
//      `ifdef DEBUG_CU
//              $display("%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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_USERCONSTANTS;
                else
                        NextState <= `CU_WAIT_USERCONSTANTS;
        end
        //-----------------------------------------
        `CU_ACK_USERCONSTANTS:
        begin
 
        `ifdef DEBUG_CU
                $display("%d Control: CU_ACK_RGU\n",$time);
        `endif
 
        //$display("CORE: %d CU_ACK_USERCONSTANTS", iDebug_CoreID);
 
                //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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone  == 0)
                        NextState <= `CU_WAIT_FOR_RENDER_ENABLE;
                else
                        NextState <= `CU_ACK_USERCONSTANTS;
 
        end
        //-----------------------------------------
        `CU_WAIT_FOR_RENDER_ENABLE:
        begin
        `ifdef DEBUG_CU
        $display("CORE: %d CU_WAIT_FOR_RENDER_ENABLE", iDebug_CoreID);
        `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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iRenderEnable)
                        NextState <= `CU_TRIGGER_RGU;
                else
                        NextState <= `CU_WAIT_FOR_RENDER_ENABLE;
        end
        //-----------------------------------------
        `CU_TRIGGER_RGU:
        begin
 
        `ifdef DEBUG_CU
                $display("CORE: %d CU_TRIGGER_RGU", iDebug_CoreID);
        `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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_FOR_RGU;
        end
        //-----------------------------------------
        `CU_WAIT_FOR_RGU:
        begin
 
//      `ifdef DEBUG_CU
//              $display("%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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_RGU;
                else
                        NextState <= `CU_WAIT_FOR_RGU;
        end
        //-----------------------------------------
        `CU_ACK_RGU:
        begin
 
        `ifdef DEBUG_CU
                $display("CORE: %d CU_ACK_RGU", iDebug_CoreID);
        `endif
                //oRamBusOwner                          <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= 0;
                oGFUEnable                                      <= 0;
                oUCodeEnable                            <= 0; //*        
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 1;
                oFlipMem                                                <= 0;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone  == 0 & iRenderEnable == 1)
                        NextState <= `CU_WAIT_FOR_HOST_DATA_AVAILABLE;//`CU_TRIGGER_GEO;///////////// GET RID OF GEO!!!
                else
                        NextState <= `CU_ACK_RGU;
 
        end
        //-----------------------------------------
        `CU_TRIGGER_TCC:
        begin
        ////$display("CU_TRIGGER_TCC");
        `ifdef DEBUG_CU
                $display("%d CORE %d Control: CU_TRIGGER_TCC\n",$time,iDebug_CoreID);
        `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                                                <= 0; //We need u,v from last IO read cycle
                oResultCommited                 <= 0;
                ////$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);
                //oIncCurrentPitch        <= 0;
                oDone                   <= 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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
           if ( iUCodeDone )
                        NextState <= `CU_ACK_TCC;
                else
                        NextState <= `WAIT_FOR_TCC;
 
        end
        //-----------------------------------------
        `CU_ACK_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         <= 0;
                oFlipMem                                                <= 0;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
           if ( iUCodeDone == 0 && iSceneTraverseComplete == 1'b1)  //DDDD
                        NextState <= `CU_TRIGGER_PSU_WITH_TEXTURE;
                else if (iUCodeDone == 0 && iSceneTraverseComplete == 1'b0)
                        NextState <= `CU_WAIT_FOR_HOST_DATA_AVAILABLE;
                else
                        NextState <= `CU_ACK_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_CU
                $display("%d CORE %d Control: CU_CHECK_HIT\n",$time,iDebug_CoreID);
        `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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
 
 
 
                if (wHit)
                begin
                        //$display("HIT");
                        NextState <= `CU_TRIGGER_PSU_WITH_TEXTURE;
                end
                else
                        NextState <= `CU_TRIGGER_USERPIXELSHADER;//666
 
        end
 
        //-----------------------------------------
        `CU_TRIGGER_PSU_WITH_TEXTURE:
        begin
 
        `ifdef DEBUG_CU
                $display("%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                           <= 1;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;//////NEW NEW NEW NEW  
                oFlipMem                                                <= 0;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                ////$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);
           //oIncCurrentPitch        <= 0;
 
                NextState <= `CU_WAIT_FOR_PSU;
        end
        //-----------------------------------------
        //Wait until data from Host becomes available
        `CU_WAIT_FOR_HOST_DATA_AVAILABLE:
        begin
                //oRamBusOwner                          <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= 0;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
                oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 0;
                oDone                   <= 0;
                oResultCommited                 <= 0;
 
                if ( iHostDataAvailable )
                        NextState <= `CU_TRIGGER_MAIN;
                else
                        NextState <= `CU_WAIT_FOR_HOST_DATA_AVAILABLE;
 
 
        end
        //-----------------------------------------
        `CU_TRIGGER_MAIN:
        begin
        `ifdef DEBUG_CU
                $display("%d CORE: %d Control: CU_TRIGGER_MAIN\n",$time,iDebug_CoreID);
        `endif
 
                        //oRamBusOwner                          <= `REG_BUS_OWNED_BY_UCODE;
                        oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_MAIN;
                        oUCodeEnable                            <= 1;
                        oGFUEnable                                      <= 1;
                        oIOWritePixel                           <= 0;
                        rResetHitFlop                           <= 0;
                        rHitFlopEnable                          <= 0;
         oTriggerTFF             <= 0;
                        oSetCurrentPitch        <= 0;
                        oFlipMemEnabled         <= 1;
                        oFlipMem                                                <= 1;
                        oDone                   <= 0;
                        oResultCommited                 <= 0;
                        ////$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);
                        //oIncCurrentPitch        <= 0;
                //      $stop();
 
                        NextState <= `CU_WAIT_FOR_MAIN;
 
        end
        //-----------------------------------------
        `CU_WAIT_FOR_MAIN:
        begin
//      `ifdef DEBUG_CU
//              $display("%d Control: CU_WAIT_FOR_MAIN\n",$time);
//      `endif
 
                        //oRamBusOwner                          <= `REG_BUS_OWNED_BY_UCODE;
                        oCodeInstructioPointer  <= `ENTRYPOINT_INDEX_MAIN;
                        oUCodeEnable                            <= 0;
                        oGFUEnable                                      <= 1;
                        oIOWritePixel                           <= 0;
                        rResetHitFlop                           <= 0;
                        rHitFlopEnable                          <= 1;
         oTriggerTFF             <= 0;
                        oSetCurrentPitch        <= 0;
                        oFlipMemEnabled         <= 1;
                        oFlipMem                                                <= 0;
                        oDone                   <= 0;
                        oResultCommited                 <= 0;
                        //oIncCurrentPitch        <= 0;
 
                        //NextState <= `CU_WAIT_FOR_MAIN;
 
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_MAIN;
                else
                        NextState <= `CU_WAIT_FOR_MAIN;
 
        end
        //-----------------------------------------
        /*
                ACK UCODE by setting oUCodeEnable = 0
        */
        `CU_ACK_MAIN:
        begin
        `ifdef DEBUG_CU
                $display("%d CORE: %d Control: CU_ACK_MAIN\n",$time, iDebug_CoreID);
        `endif
 
                        //oRamBusOwner                          <= `REG_BUS_OWNED_BY_GFU;
                        oCodeInstructioPointer  <= 0; //*
                        oUCodeEnable                            <= 0;    //*
                        oGFUEnable                                      <= 0; //Changed Aug 15
                        oIOWritePixel                           <= 0;
                        rResetHitFlop                           <= 0;
                        rHitFlopEnable                          <= 1;
         oTriggerTFF             <= 0;
                        oSetCurrentPitch        <= 0;
                        oFlipMemEnabled         <= 0;
                        oFlipMem                                                <= 0;
                        oDone                   <= 0;
                        oResultCommited                 <= 0;
                        //oIncCurrentPitch        <= 0;
 
        //              $stop();
 
                        if ( iUCodeDone == 1'b0 & iSceneTraverseComplete == 1'b1)
                                NextState <=  `CU_CHECK_HIT;
                        else if ( iUCodeDone == 1'b0 & iSceneTraverseComplete == 1'b0) //ERROR!!! What if iSceneTraverseComplete will become 1 a cycle after this??
                                NextState <= `CU_TRIGGER_MAIN;
                        else
                                NextState <= `CU_ACK_MAIN;
 
 
 
        end
        //-----------------------------------------
        `CU_WAIT_FOR_PSU:
        begin
 
//      `ifdef DEBUG_CU
//              $display("%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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_PSU;
                else
                        NextState <= `CU_WAIT_FOR_PSU;
 
        end
        //-----------------------------------------
        `CU_ACK_PSU:
        begin
        `ifdef DEBUG_CU
                $display("%d CORE: %d Control: CU_ACK_PSU\n",$time, iDebug_CoreID);
        `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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone  == 0)
                        NextState <= `CU_TRIGGER_USERPIXELSHADER;
                else
                        NextState <= `CU_ACK_PSU;
 
 
        end
        //-----------------------------------------
 
        //-----------------------------------------
        `CU_TRIGGER_NPU: //Next Pixel Unit
        begin
        `ifdef DEBUG_CU
                $display("%d CORE: %d Control: CU_TRIGGER_NPU\n",$time, iDebug_CoreID);
        `endif
                $write("*");
 
                //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;
                oDone                   <= 0;
                oResultCommited                 <= 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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_NPU;
                else
                        NextState <= `CU_WAIT_NPU;
        end
        //-----------------------------------------
        /*
        Next Pixel generation: here we either goto
        to RGU for the next pixel, or we have no
        more pixels so we are done we our picture!
        */
        `CU_ACK_NPU:
        begin
        `ifdef DEBUG_CU
                $display("%d CORE: %d Control: CU_ACK_NPU\n",$time, iDebug_CoreID);
        `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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone  == 0 && iUCodeReturnValue == 1)
                        NextState <= `CU_TRIGGER_RGU;
                else if (iUCodeDone == 0 && iUCodeReturnValue == 0)
                        NextState <= `CU_DONE;
                else
                        NextState <= `CU_ACK_NPU;
 
 
        end
        //-----------------------------------------
        `CU_DONE:
        begin
                //oRamBusOwner                          <= `REG_BUS_OWNED_BY_UCODE;
                oCodeInstructioPointer  <= 0;
                oUCodeEnable                            <= 0;
                oGFUEnable                                      <= 0;
                oIOWritePixel                           <= 0;
                rResetHitFlop                           <= 0;
                rHitFlopEnable                          <= 0;
      oTriggerTFF             <= 0;
                oSetCurrentPitch        <= 0;
                oFlipMemEnabled         <= 0;
                oFlipMem                                                <= 1;
                oDone                   <= 1;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
 
                NextState <= `CU_DONE;
 
        end
        //-----------------------------------------
        /*
        Here we no longer use GFU so set Enable to zero
        */
        `CU_TRIGGER_USERPIXELSHADER:
        begin
        `ifdef DEBUG_CU
                $display("%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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
 
                NextState <= `CU_WAIT_FOR_USERPIXELSHADER;
        end
        //-----------------------------------------
        `CU_WAIT_FOR_USERPIXELSHADER:
        begin
 
//      `ifdef DEBUG_CU
//              $display("%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;
                oDone                   <= 0;
                oResultCommited                 <= 0;
                //oIncCurrentPitch        <= 0;
 
 
                if ( iUCodeDone )
                        NextState <= `CU_ACK_USERPIXELSHADER;
                else
                        NextState <= `CU_WAIT_FOR_USERPIXELSHADER;
 
        end
        //-----------------------------------------
        `CU_ACK_USERPIXELSHADER:
        begin
        `ifdef DEBUG_CU
                $display("%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;
                oDone                   <= 0;
                oResultCommited                 <= 1;
                //oIncCurrentPitch        <= 0;
 
                if ( iUCodeDone  == 0)
                        NextState <= `CU_TRIGGER_NPU;//`CU_TRIGGER_PCU;
                else
                        NextState <= `CU_ACK_USERPIXELSHADER;
 
 
        end
        //---------------------------------------------------
        default:
        begin
 
        `ifdef DEBUG_CU
                $display("%d Control: ERROR 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;
                oDone                   <= 0;
                oResultCommited                 <= 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	105	diegovalve	//`define CU_TRIGGER_TFF 18
51	18	diegovalve	//`define CU_CHECK_GEO_DONE 19
52	105	diegovalve	//`define CU_WAIT_FOR_TFF 19
53	18	diegovalve	`define CU_TRIGGER_AABBIU 20
54			`define CU_WAIT_FOR_AABBIU 21
55	105	diegovalve	`define CU_TRIGGER_MAIN 22
56			`define CU_WAIT_FOR_MAIN 23
57			`define CU_ACK_MAIN 24
58	18	diegovalve	`define CU_TRIGGER_PSU 25
59			`define CU_WAIT_FOR_PSU 26
60			`define CU_ACK_PSU 27
61	105	diegovalve	//`define CU_TRIGGER_PCU 28
62	18	diegovalve	`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	76	diegovalve	`define CU_ACK_USERPIXELSHADER 47
81			`define CU_DONE 48
82	105	diegovalve	`define CU_WAIT_FOR_RENDER_ENABLE 49
83			`define CU_ACK_TCC 50
84			`define CU_WAIT_FOR_HOST_DATA_AVAILABLE 51
85	18	diegovalve	`//--------------------------------------------------------------`
86			`module ControlUnit`
87			`(`
88
89			`input wire Clock,`
90			`input wire Reset,`
91			`input wire[15:0] iControlRegister,`
92			`output reg oGFUEnable,`
93			`input wire iTriggerAABBIURequest,`
94			`input wire iTriggerBIURequest,`
95			`input wire iTriggertTCCRequest,`
96			`output reg oUCodeEnable,`
97	60	diegovalve	output reg[`ROM_ADDRESS_WIDTH-1:0] oCodeInstructioPointer,
98	18	diegovalve	`input wire iUCodeDone,`
99			`input wire iUCodeReturnValue,`
100			`input wire iGFUDone,`
101			`input wire iGEOSync,`
102			`output reg oTriggerTFF,`
103			`input wire iTFFDone,`
104			`input wire MST_I,`
105	116	diegovalve	`//output reg[2:0] //oRamBusOwner,`
106	18	diegovalve	`input wire iIODone,`
107			`output reg oSetCurrentPitch,`
108	71	diegovalve	`output reg oFlipMemEnabled,`
109			`output reg oFlipMem,`
110	76	diegovalve	`output reg oIOWritePixel,`
111	105	diegovalve	`input wire iRenderEnable,`
112			`input wire iSceneTraverseComplete,`
113			`input wire iHostDataAvailable,`
114	76	diegovalve
115			`ifdef DEBUG
116			input wire[`MAX_CORES-1:0] iDebug_CoreID,
117			`endif
118
119	105	diegovalve	`output reg oResultCommited,`
120	76	diegovalve	`output reg oDone`
121	18	diegovalve
122			`);`
123
124			`//Internal State Machine varibles`
125			`reg [5:0] CurrentState;`
126			`reg [5:0] NextState;`
127			`integer ucode_file;`
128			`reg rResetHitFlop,rHitFlopEnable;`
129			`wire wHit;`
130
131			`ifdef DUMP_CODE
132			`integer log;`
133
134			`initial`
135			`begin`
136
137	76	diegovalve	`//$display("Opening ucode dump file....\n");`
138	18	diegovalve	`ucode_file = $fopen("CU.log","w");`
139			`end`
140
141			`endif
142	105	diegovalve
143
144	18	diegovalve
145			`//--------------------------------------------------------------`
146			`FFToggleOnce_1Bit FFTO1`
147			`(`
148			`.Clock( Clock ),`
149			`.Reset( rResetHitFlop ),`
150			`.Enable( rHitFlopEnable && iUCodeDone ),`
151			`.S( iUCodeReturnValue ),`
152			`.Q( wHit )`
153			`);`
154			`//--------------------------------------------------------------`
155
156	81	diegovalve	`ifdef DEBUG_CU
157	18	diegovalve	`always @ ( wHit )`
158			`begin`
159	129	diegovalve	`$display( "* Triangle HIT *\n");`
160	18	diegovalve	`end`
161			`endif
162
163			`//Next states logic and Reset sequence`
164			`always @(posedge Clock or posedge Reset)`
165			`begin`
166
167			`if (Reset)`
168			CurrentState <= `CU_AFTER_RESET_STATE;
169			`else`
170			`CurrentState <= NextState;`
171
172			`end`
173
174			`//--------------------------------------------------------------`
175			`always @ ( * )`
176			`begin`
177			`case (CurrentState)`
178			`//-----------------------------------------`
179			`CU_AFTER_RESET_STATE:
180			`begin`
181
182	81	diegovalve	`ifdef DEBUG_CU
183	129	diegovalve	`$display("%d CU_AFTER_RESET_STATE\n",$time);`
184	18	diegovalve	`endif
185
186	116	diegovalve	`//oRamBusOwner <= 0;`
187	60	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_INITIAL;
188	18	diegovalve	`oGFUEnable <= 0;`
189			`oUCodeEnable <= 0;`
190			`oIOWritePixel <= 0;`
191			`rResetHitFlop <= 1;`
192			`rHitFlopEnable <= 0;`
193			`oTriggerTFF <= 0;`
194			`oSetCurrentPitch <= 1;`
195	71	diegovalve	`oFlipMemEnabled <= 0;`
196	76	diegovalve	`oFlipMem <= 0;`
197	105	diegovalve	`oDone <= 0;`
198			`oResultCommited <= 0;`
199	18	diegovalve	`//oIncCurrentPitch <= 0;`
200
201			NextState <= `CU_WAIT_FOR_INITIAL_CONFIGURATION;
202
203			`end`
204			`//-----------------------------------------`
205
206			`CU_WAIT_FOR_INITIAL_CONFIGURATION:
207			`begin`
208	76	diegovalve	`//$display("CORE: %d CU_WAIT_FOR_INITIAL_CONFIGURATION", iDebug_CoreID);`
209	81	diegovalve	// `ifdef DEBUG_CU
210	129	diegovalve	`// $display("%d Control: CU_WAIT_FOR_INITIAL_CONFIGURATION\n",$time);`
211	18	diegovalve	// `endif
212
213	116	diegovalve	`//oRamBusOwner <= 0;`
214	60	diegovalve	`oCodeInstructioPointer <= 0;`
215	18	diegovalve	`oGFUEnable <= 0;`
216			`oUCodeEnable <= 0;`
217			`oIOWritePixel <= 0;`
218			`rResetHitFlop <= 1;`
219			`rHitFlopEnable <= 0;`
220			`oTriggerTFF <= 0;`
221			`oSetCurrentPitch <= 0;`
222	71	diegovalve	`oFlipMemEnabled <= 0;`
223	76	diegovalve	`oFlipMem <= 0;`
224	105	diegovalve	`oDone <= 0;`
225			`oResultCommited <= 0;`
226	18	diegovalve	`//oIncCurrentPitch <= 0;`
227
228			`if ( MST_I )`
229			NextState <= `CU_PERFORM_INTIAL_CONFIGURATION;//`CU_WAIT_FOR_CONFIG_DATA_READ;
230			`else`
231			NextState <= `CU_WAIT_FOR_INITIAL_CONFIGURATION;
232
233
234			`end`
235			`//-----------------------------------------`
236			`CU_PERFORM_INTIAL_CONFIGURATION:
237	76	diegovalve	`begin`
238			`//$display("CORE: %d CU_PERFORM_INTIAL_CONFIGURATION", iDebug_CoreID);`
239	116	diegovalve	`//oRamBusOwner <= 0;`
240	60	diegovalve	`oCodeInstructioPointer <= 0;`
241	18	diegovalve	`oGFUEnable <= 0;`
242			`oUCodeEnable <= 0;`
243			`oIOWritePixel <= 0;`
244			`rResetHitFlop <= 1;`
245			`rHitFlopEnable <= 0;`
246			`oTriggerTFF <= 0;`
247			`oSetCurrentPitch <= 0;`
248	71	diegovalve	`oFlipMemEnabled <= 0;`
249	76	diegovalve	`oFlipMem <= 0;`
250	105	diegovalve	`oDone <= 0;`
251			`oResultCommited <= 0;`
252	18	diegovalve	`//oIncCurrentPitch <= 0;`
253
254	76	diegovalve	`if ( MST_I == 0 && iRenderEnable == 1'b1)`
255			NextState <= `CU_CLEAR_REGISTERS;//`CU_WAIT_FOR_CONFIG_DATA_READ;
256			`else`
257			NextState <= `CU_PERFORM_INTIAL_CONFIGURATION;
258
259	18	diegovalve
260			`end`
261			`//-----------------------------------------`
262			`CU_CLEAR_REGISTERS:
263	76	diegovalve	`begin`
264			`//$display("CORE: %d CU_CLEAR_REGISTERS", iDebug_CoreID);`
265	81	diegovalve	`ifdef DEBUG_CU
266	129	diegovalve	`$display("%d CU_CLEAR_REGISTERS\n",$time);`
267	18	diegovalve	`endif
268
269	116	diegovalve	//oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
270	60	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_INITIAL;
271	18	diegovalve	`oGFUEnable <= 0;`
272			`oUCodeEnable <= 1; //*`
273			`oIOWritePixel <= 0;`
274			`rResetHitFlop <= 0;`
275			`rHitFlopEnable <= 0;`
276			`oTriggerTFF <= 0;`
277			`oSetCurrentPitch <= 0;`
278	71	diegovalve	`oFlipMemEnabled <= 1;`
279	105	diegovalve	`oFlipMem <= 0;`
280			`oDone <= 0;`
281			`oResultCommited <= 0;`
282
283	76	diegovalve	`////$display("\n\n %d XOXOXOXOX FLIP XOXOXOXOXOX\n\n",$time);`
284	18	diegovalve	`//oIncCurrentPitch <= 0;`
285
286			NextState <= `CU_WAIT_CLEAR_REGISTERS;
287			`end`
288			`//-----------------------------------------`
289			`CU_WAIT_CLEAR_REGISTERS:
290			`begin`
291	81	diegovalve	// `ifdef DEBUG_CU
292	129	diegovalve	`// $display("%d CU_WAIT_CLEAR_REGISTERS\n",$time);`
293	18	diegovalve	// `endif
294	76	diegovalve	`//$display("CORE: %d CU_WAIT_CLEAR_REGISTERS", iDebug_CoreID);`
295	116	diegovalve	//oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
296	60	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_INITIAL;
297	18	diegovalve	`oGFUEnable <= 0;`
298			`oUCodeEnable <= 0;`
299			`oIOWritePixel <= 0;`
300			`rResetHitFlop <= 0;`
301			`rHitFlopEnable <= 0;`
302			`oTriggerTFF <= 0;`
303			`oSetCurrentPitch <= 0;`
304	71	diegovalve	`oFlipMemEnabled <= 1;`
305	76	diegovalve	`oFlipMem <= 0;`
306	105	diegovalve	`oDone <= 0;`
307			`oResultCommited <= 0;`
308	18	diegovalve	`//oIncCurrentPitch <= 0;`
309
310			`if ( iUCodeDone )`
311			NextState <= `CU_ACK_CLEAR_REGISTERS;
312			`else`
313			NextState <= `CU_WAIT_CLEAR_REGISTERS;
314
315			`end`
316			`//-----------------------------------------`
317			`CU_ACK_CLEAR_REGISTERS:
318	76	diegovalve	`begin`
319
320	81	diegovalve	`ifdef DEBUG_CU
321	129	diegovalve	`$display("%d CU_ACK_CLEAR_REGISTERS\n", $time);`
322	18	diegovalve	`endif
323	76	diegovalve
324			`//$display("CORE: %d CU_ACK_CLEAR_REGISTERS", iDebug_CoreID);`
325	18	diegovalve
326	116	diegovalve	`//oRamBusOwner <= 0;`
327	60	diegovalve	`oCodeInstructioPointer <= 0;`
328	18	diegovalve	`oGFUEnable <= 0;`
329			`oUCodeEnable <= 0; //*`
330			`oIOWritePixel <= 0;`
331			`rResetHitFlop <= 0;`
332			`rHitFlopEnable <= 0;`
333			`oTriggerTFF <= 0;`
334			`oSetCurrentPitch <= 0;`
335	71	diegovalve	`oFlipMemEnabled <= 0;`
336	76	diegovalve	`oFlipMem <= 0;`
337	105	diegovalve	`oDone <= 0;`
338			`oResultCommited <= 0;`
339	18	diegovalve	`//oIncCurrentPitch <= 0;`
340
341			NextState <= `CU_WAIT_FOR_CONFIG_DATA_READ;
342			`end`
343
344
345
346			`//-----------------------------------------`
347			`CU_WAIT_FOR_CONFIG_DATA_READ:
348			`begin`
349	76	diegovalve
350	81	diegovalve	// `ifdef DEBUG_CU
351	129	diegovalve	`// $display("%d Control: CU_WAIT_FOR_CONFIG_DATA_READ\n",$time);`
352	18	diegovalve	// `endif
353	76	diegovalve
354
355			`//$display("CORE: %d CU_WAIT_FOR_CONFIG_DATA_READ", iDebug_CoreID);`
356	18	diegovalve
357	116	diegovalve	//oRamBusOwner <= 0;//`REG_BUS_OWNED_BY_BCU;
358	60	diegovalve	`oCodeInstructioPointer <= 0;`
359	18	diegovalve	`oGFUEnable <= 0;`
360			`oUCodeEnable <= 0;`
361			`oIOWritePixel <= 0;`
362			`rResetHitFlop <= 0;`
363			`rHitFlopEnable <= 0;`
364			`oTriggerTFF <= 0;`
365			`oSetCurrentPitch <= 0;`
366	71	diegovalve	`oFlipMemEnabled <= 0;`
367	76	diegovalve	`oFlipMem <= 0;`
368	105	diegovalve	`oDone <= 0;`
369			`oResultCommited <= 0;`
370	18	diegovalve	`//oIncCurrentPitch <= 0;`
371
372			`if ( MST_I == 0 )`
373			NextState <= `CU_PRECALCULATE_CONSTANTS;
374			`else`
375			NextState <= `CU_WAIT_FOR_CONFIG_DATA_READ;
376
377			`end`
378			`//-----------------------------------------`
379			`CU_PRECALCULATE_CONSTANTS:
380			`begin`
381	76	diegovalve	`//$display("CORE: %d CU_PRECALCULATE_CONSTANTS", iDebug_CoreID);`
382	81	diegovalve	`ifdef DEBUG_CU
383	129	diegovalve	`$display("%d Control: CU_PRECALCULATE_CONSTANTS\n", $time);`
384	18	diegovalve	`endif
385
386	116	diegovalve	//oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
387	60	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_CPPU;
388	18	diegovalve	`oGFUEnable <= 0;`
389			`oUCodeEnable <= 1; //*`
390			`oIOWritePixel <= 0;`
391			`rResetHitFlop <= 0;`
392			`rHitFlopEnable <= 0;`
393			`oTriggerTFF <= 0;`
394			`oSetCurrentPitch <= 0;`
395	71	diegovalve	`oFlipMemEnabled <= 0;`
396	76	diegovalve	`oFlipMem <= 0;`
397	105	diegovalve	`oDone <= 0;`
398			`oResultCommited <= 0;`
399	18	diegovalve	`//oIncCurrentPitch <= 0;`
400
401			NextState <= `CU_WAIT_FOR_CONSTANT;
402
403			`end`
404			`//-----------------------------------------`
405			`CU_WAIT_FOR_CONSTANT:
406			`begin`
407	81	diegovalve	// `ifdef DEBUG_CU
408	129	diegovalve	`// $display("%d Control: CU_WAIT_FOR_CONSTANT\n", $time);`
409	18	diegovalve	// `endif
410
411
412	116	diegovalve	//oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
413	60	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_CPPU;
414	18	diegovalve	`oGFUEnable <= 0;`
415			`oUCodeEnable <= 0; //*`
416			`oIOWritePixel <= 0;`
417			`rResetHitFlop <= 0;`
418			`rHitFlopEnable <= 0;`
419			`oTriggerTFF <= 0;`
420			`oSetCurrentPitch <= 0;`
421	71	diegovalve	`oFlipMemEnabled <= 0;`
422	76	diegovalve	`oFlipMem <= 0;`
423	105	diegovalve	`oDone <= 0;`
424			`oResultCommited <= 0;`
425	18	diegovalve	`//oIncCurrentPitch <= 0;`
426
427			`if ( iUCodeDone )`
428			NextState <= `CU_ACK_PRECALCULATE_CONSTANTS;
429			`else`
430			NextState <= `CU_WAIT_FOR_CONSTANT;
431
432			`end`
433			`//-----------------------------------------`
434			`CU_ACK_PRECALCULATE_CONSTANTS:
435			`begin`
436	76	diegovalve	`//$display("CORE: %d CU_ACK_PRECALCULATE_CONSTANTS", iDebug_CoreID);`
437	81	diegovalve	`ifdef DEBUG_CU
438	129	diegovalve	`$display("%d Control: CU_ACK_PRECALCULATE_CONSTANTS\n", $time);`
439	18	diegovalve	`endif
440
441
442	116	diegovalve	//oRamBusOwner <= 0;//`REG_BUS_OWNED_BY_BCU;
443	60	diegovalve	`oCodeInstructioPointer <= 0;`
444	18	diegovalve	`oGFUEnable <= 0;`
445			`oUCodeEnable <= 0; //*`
446			`oIOWritePixel <= 0;`
447			`rResetHitFlop <= 0;`
448			`rHitFlopEnable <= 0;`
449			`oTriggerTFF <= 0;`
450			`oSetCurrentPitch <= 0;`
451	71	diegovalve	`oFlipMemEnabled <= 0;`
452	76	diegovalve	`oFlipMem <= 0;`
453	105	diegovalve	`oDone <= 0;`
454			`oResultCommited <= 0;`
455	18	diegovalve	`//oIncCurrentPitch <= 0;`
456
457	63	diegovalve	NextState <= `CU_TRIGGER_USERCONSTANTS;//CU_WAIT_FOR_TASK;
458	18	diegovalve
459			`end`
460			`//-----------------------------------------`
461	71	diegovalve
462	63	diegovalve	`CU_TRIGGER_USERCONSTANTS:
463			`begin`
464	81	diegovalve	`ifdef DEBUG_CU
465	129	diegovalve	`$display("%d Control: CU_TRIGGER_USERCONSTANTS\n",$time);`
466	63	diegovalve	`endif
467	76	diegovalve
468			`//$display("CORE: %d CU_TRIGGER_USERCONSTANTS", iDebug_CoreID);`
469	63	diegovalve
470	116	diegovalve	//oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
471	63	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_USERCONSTANTS;
472			`oGFUEnable <= 0;`
473			`oUCodeEnable <= 1; //*`
474			`oIOWritePixel <= 0;`
475			`rResetHitFlop <= 0;`
476			`rHitFlopEnable <= 0;`
477			`oTriggerTFF <= 0;`
478			`oSetCurrentPitch <= 0;`
479	71	diegovalve	`oFlipMemEnabled <= 0;`
480	76	diegovalve	`oFlipMem <= 0;`
481	105	diegovalve	`oDone <= 0;`
482			`oResultCommited <= 0;`
483	63	diegovalve	`//oIncCurrentPitch <= 0;`
484
485			NextState <= `CU_WAIT_USERCONSTANTS;
486			`end`
487			`//-----------------------------------------`
488			`CU_WAIT_USERCONSTANTS:
489			`begin`
490
491	81	diegovalve	// `ifdef DEBUG_CU
492	129	diegovalve	`// $display("%d Control: CU_WAIT_FOR_RGU\n",$time);`
493	63	diegovalve	// `endif
494
495	116	diegovalve	//oRamBusOwner <= `REG_BUS_OWNED_BY_UCODE;
496	63	diegovalve	oCodeInstructioPointer <= `ENTRYPOINT_INDEX_USERCONSTANTS;
497			`oGFUEnable <= 0;`
498			`oUCodeEnable <= 0;`
499			`oIOWritePixel <= 0;`
500			`rResetHitFlop <= 0;`

Browse

Tools

Subversion Repositories theia_gpu

[/] [theia_gpu/] [branches/] [gpu_8_cores/] [rtl/] [GPU/] [CORES/] [CONTROL/] [Unit_Control.v] - Blame information for rev 129