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 81

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

Browse

Tools

Subversion Repositories theia_gpu

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