PDSP0 & PA clock disable

#include <ti/csl/csl_pscAux.h>
void init_module_states();
int ModuleStateControl(unsigned int mod_num, CSL_PSC_MODSTATE next_state);
int NetCPPwrDomainControl(CSL_PSC_PDSTATE next_state);
unsigned int  getNetCPPwrDomainState();
 // Initialize current Power and Clock domain states. CALL THIS FIRST! This is an internal management data base. Does not affect actual state. See ModuleStateControl()
  init_module_states();

  if(getNetCPPwrDomainState())
  {
  // Disable Power Domain and Clocks (CSL VERSION)
  ModuleStateControl(9, PSC_MODSTATE_DISABLE); // SA Clock Domain
  ModuleStateControl(8, PSC_MODSTATE_DISABLE); // CPSW Clock Domain
  ModuleStateControl(7, PSC_MODSTATE_DISABLE); // PA Clock Domain
  NetCPPwrDomainControl(PSC_PDSTATE_OFF); // NetCP Power Domain
  }


  // Enable Power Domain and Clocks (CSL VERSION)
  NetCPPwrDomainControl(PSC_PDSTATE_ON); // NetCP Power Domain
  ModuleStateControl(7, PSC_MODSTATE_ENABLE); // PA Clock Domain
  ModuleStateControl(8, PSC_MODSTATE_ENABLE); // CPSW Clock Domain
  ModuleStateControl(9, PSC_MODSTATE_ENABLE); // SA Clock Domain
  
  
  // This function controls power and clock domains of NetCP. 
// Input module # and desired state to transition.
unsigned int module_states[4];
int ModuleStateControl(unsigned int mod_num, CSL_PSC_MODSTATE next_state)
{

int status = PASS;
int index  = -1;
        // Make sure PSC is not in process of a state transition
        while (!CSL_PSC_isStateTransitionDone (2));

        // User must make sure to use appropriate state for appropriate domain
        switch(mod_num)
        {
        	       
        	case 7:
            index = 1;
        	// To enable PA clock
        	if(module_states[index] != next_state && (next_state == PSC_MODSTATE_ENABLE || next_state == PSC_MODSTATE_DISABLE))
            {
            	CSL_PSC_setModuleNextState (mod_num, next_state);
            	module_states[index] = next_state;
            }
            else
            {
            	printf("UNDEFINED STATE FOR PA CLOCK DOMAIN\n");
            	status = FAIL;
            }
            break;
            case 8:
            index = 2;
            // To enable CPSW clock
            if(module_states[index] != next_state && (next_state == PSC_MODSTATE_ENABLE || next_state == PSC_MODSTATE_DISABLE))
            {
            	CSL_PSC_setModuleNextState (mod_num, next_state);
            	module_states[index] = next_state;
            }
            else
            {
            	printf("UNDEFINED STATE FOR CPSW CLOCK DOMAIN\n");
            	status = FAIL;
            }
            break;
            case 9:
             index = 3;
            // To enable Crypto clock 
            if(module_states[index] != next_state && (next_state == PSC_MODSTATE_ENABLE || next_state == PSC_MODSTATE_DISABLE))
            {
            	CSL_PSC_setModuleNextState (mod_num, next_state);
            	module_states[index] = next_state;
            }
            else
            {
            	printf("UNDEFINED STATE FOR SA CLOCK DOMAIN\n");
            	status = FAIL;
            }
            break;
            default:
            printf("UNDEFINED NETCP CLOCK DOMAIN\n"); 
            status = FAIL;
        }
        
        if(status == FAIL)
        {
        	printf("ABORT CLOCK SETUP!\n");
        	return status;
        }
        // Initiate transition
        CSL_PSC_startStateTransition (2);

        // Wait until the transition process is completed.
        while (!CSL_PSC_isStateTransitionDone (2));

	   
       	if(CSL_PSC_getModuleState(mod_num) != next_state)
       	{
       		switch(next_state)
       		{
       			case PSC_MODSTATE_ENABLE:
                module_states[index] = PSC_MODSTATE_DISABLE;
       			printf("FAILED TO START ClOCK\n");
       			status = FAIL;
       			break;
       			case PSC_MODSTATE_DISABLE:
                module_states[index] = PSC_MODSTATE_ENABLE;
       			printf("FAILED TO STOP CLOCK\n");
       			status = FAIL;
       			break;
       			default:
       			// WE SHOULD NEVER REACH THIS CODE!
       			printf("FAILED TO FILTER PROPER STATE FOR THE MODULE\n");
       		} 
       	}
	   
	   return status;
}

int NetCPPwrDomainControl(CSL_PSC_PDSTATE next_state)
{
	int status = PASS;
	// Make sure PSC is not in process of a state transition
        while (!CSL_PSC_isStateTransitionDone (2));
        
        switch(next_state)
        	{
        		case PSC_PDSTATE_ON:  
        		// To Enable NetCP Power domain; First check if already enabled.
        		if(module_states[0] == PSC_PDSTATE_OFF)
        		{ 
        			CSL_PSC_enablePowerDomain (2);
        			module_states[0] = next_state;
        		}
        		break;
        		case PSC_PDSTATE_OFF:
        		// To Disable NetCP Power domain; First check if already disabled.
        		if(module_states[0] == PSC_PDSTATE_ON)
        		{
        			CSL_PSC_disablePowerDomain (2);
        			module_states[0] = next_state;
        		}
        		break;
        		default:
        		printf("UNDEFINED STATE FOR NETCP POWER DOMAIN\n");
        		status = FAIL;
        	}
        	
        	if(status == FAIL)
        	{
      printf("ABORT POWER DOMAIN SETUP!\n");
        		return status;
        	}
        	// Initiate transition
        CSL_PSC_startStateTransition (2);

        // Wait until the transition process is completed.
        while (!CSL_PSC_isStateTransitionDone (2));
        
        // Check NetCP transitioned to correct power state
        if(CSL_PSC_getPowerDomainState(2) != next_state)
	   	{
	   		switch(next_state)
	   		{
	   			case PSC_PDSTATE_ON:
                module_states[0] = PSC_PDSTATE_OFF;
	   			printf("FAILED TO ENABLE NETCP PWR DOMAIN\n");
	   			status = FAIL;
	   			break;
	   			case PSC_PDSTATE_OFF:
                module_states[0] = PSC_PDSTATE_ON;
	   			printf("FAILED TO DISABE NETCP PWR DOMAIN\n");
	   			status = FAIL;
	   			break;
	   			default:
	   			printf("FAILED TO FILTER PROPER POWER STATE FOR NETCP\n");
	   			status = FAIL;
	   		}
	   	}
	   	return status;
}


// Initialized current state of modules to "DISABLED"
void init_module_states()
{
	int i = 0;

	module_states[0] = PSC_PDSTATE_OFF;
	for(i = 1; i < 4; i++)
	{
		module_states[i] = PSC_MODSTATE_DISABLE;
	}
}

unsigned int  getNetCPPwrDomainState(){

    return module_states[0];
}