pmic6318.c

8032底层驱动部分。因为可以移植 所以单独来拿出来

*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_sim_leveltype(kal_bool enable)
{
   kal_uint8 data;
   kal_uint32 savedMask;
   savedMask = SaveAndSetIRQMask();   
   data=pmic_reg_save[(PMIC_EXTRAS>>PMIC_SHIFT_BITS)];      
   if(enable==KAL_TRUE)
      data|=0x4;
   else
      data&=~0x4;
   B2PSI_write(data, PMIC_EXTRAS);         
   RestoreIRQMask(savedMask);      
}
/*
* FUNCTION                                                            
*	pmic_sw_sel
*
* DESCRIPTION                                                           
*   auxiliary analog output voltage selection
*
* CALLS  
*  used to change auxiliary analog output voltage
*
* PARAMETERS
*	value:VASW_3_3V or VASW_2_8V
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_sw_sel(vasw_a_sel_enum value)
{
   kal_uint8 data;
   kal_uint32 savedMask;
   savedMask = SaveAndSetIRQMask();   
   data=pmic_reg_save[(PMIC_EXTRAS>>PMIC_SHIFT_BITS)];      
   if(value==VASW_2_8V)
      data&=~0x80;
   else if(value==VASW_3_3V)      
      data|=0x80;
   else
      ASSERT(0);   
   B2PSI_write(data, PMIC_EXTRAS);         
   RestoreIRQMask(savedMask);         
}   
/*
* FUNCTION                                                            
*	pmic_vibrator_sel
*
* DESCRIPTION                                                           
*  vibrator voltage selection
*
* CALLS  
*  used to change vibrator voltage
*
* PARAMETERS
*	value:VIBRATOR_1_8V or VIBRATOR_2_8V
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_vibrator_sel(vibrator_sel_enum value)
{
   kal_uint8 data;
   kal_uint32 savedMask;
   savedMask = SaveAndSetIRQMask();   
   data=pmic_reg_save[(PMIC_CHARGE_PUMP>>PMIC_SHIFT_BITS)];      
   if(value==VIBRATOR_1_8V)
      data&=~0x2;
   else if(value==VIBRATOR_2_8V)      
      data|=0x2;
   else
      ASSERT(0);   
   B2PSI_write(data, PMIC_CHARGE_PUMP);         
   RestoreIRQMask(savedMask);         
   
}  
/*
* FUNCTION                                                            
*	pmic_chr_pump_current_level
*
* DESCRIPTION                                                           
*  configure charge pump current
*
* CALLS  
*  used to change vibrator voltage
*
* PARAMETERS
*	current level 0~3
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_chr_pump_current_level(kal_uint32 level)
{
   kal_uint8 data;
   kal_uint32 savedMask;
   savedMask = SaveAndSetIRQMask();   
   data=pmic_reg_save[(PMIC_CHARGE_PUMP>>PMIC_SHIFT_BITS)];      
   if (level>3)
   	level=3;
   data&=~(3<<5);
   data|=(level<<5);	
   
   B2PSI_write(data, PMIC_CHARGE_PUMP);         
   RestoreIRQMask(savedMask);         
   
}
/*
* FUNCTION                                                            
*	pmic_usb_chr_enable
*
* DESCRIPTION                                                           
*   	USB charging enable/disable
*
* CALLS  
*   	USB charging enable/disable
*
* PARAMETERS
*	enable: KAL_TRUE or KAL_FALSE
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_usb_chr_enable(kal_bool enable)
{
   kal_uint8 data;
   kal_uint32 savedMask;

   savedMask = SaveAndSetIRQMask();
   data=pmic_reg_save[(PMIC_CHARGE_PUMP>>PMIC_SHIFT_BITS)];

   if(enable==KAL_TRUE)
   {
      data|=0x1;   
   }   
   else if(enable==KAL_FALSE)
   {
      data&=~0x1;/*pause mode*/
   }                 
   B2PSI_write(data, PMIC_CHARGE_PUMP); 
   RestoreIRQMask(savedMask);
}

/*
* FUNCTION                                                            
*	pmic_set_UV_vol
*
* DESCRIPTION                                                           
*   	set UV voltage
*
* CALLS  
*   	
*
* PARAMETERS
*	enable: KAL_TRUE or KAL_FALSE
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_set_UV_vol(UV_voltage_enum voltage)
{
   kal_uint8 data;
   kal_uint32 savedMask;

   savedMask = SaveAndSetIRQMask();
   data=pmic_reg_save[(PMIC_BANDGAP_SETTING>>PMIC_SHIFT_BITS)];

   data&=0xf3;/*clear original setting*/
   data|=voltage;
   
   B2PSI_write(data, PMIC_BANDGAP_SETTING); 
   RestoreIRQMask(savedMask);
}

/*
* FUNCTION                                                            
*	pmic_power_save_enable
*
* DESCRIPTION                                                           
*   	enable power save or not
*
* CALLS  
*   	
*
* PARAMETERS
*	enable: KAL_TRUE or KAL_FALSE
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_power_save_enable(kal_bool enable)
{
   kal_uint8 data;
   kal_uint32 savedMask;

   savedMask = SaveAndSetIRQMask();
   data=pmic_reg_save[(PMIC_MISC>>PMIC_SHIFT_BITS)];

   if(enable==KAL_TRUE)
   {
      data|=0x20;   
   }   
   else if(enable==KAL_FALSE)
   {
      data&=~0x20;/*pause mode*/
   }                 
   B2PSI_write(data, PMIC_MISC); 
   RestoreIRQMask(savedMask);
}


/*
* FUNCTION                                                            
*	pmic_audio_diffential_enable
*
* DESCRIPTION                                                           
*   	enable differential mode or not
*
* CALLS  
*   	
*
* PARAMETERS
*	enable: KAL_TRUE or KAL_FALSE
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_audio_diffential_enable(kal_bool enable)
{
   kal_uint8 data;
   kal_uint32 savedMask;

   savedMask = SaveAndSetIRQMask();
   data=pmic_reg_save[(PMIC_LDO_STAT>>PMIC_SHIFT_BITS)];

   if(enable==KAL_FALSE)
   {
      data|=0x2;   
   }   
   else if(enable==KAL_TRUE)
   {
      data&=~0x2;
   }                 
   B2PSI_write(data, PMIC_LDO_STAT); 
   RestoreIRQMask(savedMask);
}

/*
* FUNCTION                                                            
*	PMIC_HISR
*
* DESCRIPTION                                                           
*   	PMIC6318 HISR
*
* CALLS  
*	It is called by EINT_LISR to handle interrupt
*
* PARAMETERS
*	None
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void PMIC_HISR(void)
{
	kal_uint8 status, diff;
	static kal_uint8 intcount=0; 
	kal_uint32 savedMask;
   
   
	intcount++;
	savedMask = SaveAndSetIRQMask();
   status = B2PSI_read(PMIC_CHARGER_STAT);
   RestoreIRQMask(savedMask);   
   /*compare the difference with the previous status*/
   diff=pmic_reg_save[PMIC_CHARGER_STAT]^status;
   /*save the current status*/
   pmic_reg_save[PMIC_CHARGER_STAT]=status;
	if (diff & OV_MASK)
	{		  
	   pmic_clear_ov();
	}	
	if (diff & BAT_ON_MASK)
	{	   
	}
	if (diff & AC_DET_MASK)
	{	
		#if 0			      			   	   
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
	   #endif 	      	        	   
	   /*plug in */	   
	   if(PMIC_CHRDET.pmic_ac_det!=NULL) 
	      PMIC_CHRDET.pmic_ac_det();	     	       
	}	
	if (diff& USB_DET_MASK)
	{		  	   
	   //dbg_print("USB det \r\n");	   
	   #if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
	   #endif    
	   if(PMIC_CHRDET.pmic_usb_det!=NULL) 
	      PMIC_CHRDET.pmic_usb_det();	   	   	         
	}
			
	//EINT_UnMask(PMIC_EINT_NO);
}
/*the following are for PMIC test*/
#ifdef MT6318_DEBUG

void LED_clock_config(kal_uint32 count)
{
   kal_uint32 result;
   result=count%2;
   
   
}   
void LED_test(kal_uint8 currnet, kal_uint8 duty)
{
   pmic_led_struct pmic_set;  
   kal_uint8    status;    
   pmic_set.type=R_LED;
   pmic_set.current=currnet;
   pmic_set.duty_cycle=duty;      
   pmic_led_enable(R_LED, KAL_TRUE);
   pmic_led_config(&pmic_set);   
   status=B2PSI_read(PMIC_RLED_DRIVER);
   status=status&0x1f;
   status=(status+1)*100/32;
   dbg_print("R LED duty= %d\r\n",(status));
   
   pmic_set.type=G_LED;
   pmic_led_enable(G_LED, KAL_TRUE);
   pmic_led_config(&pmic_set);   
   status=B2PSI_read(PMIC_GLED_DRIVER); 
   status=status&0x1f;
   status=(status+1)*100/32;  
   dbg_print("G LED duty= %d\r\n",(status));
      
   pmic_set.type=B_LED;
   pmic_led_enable(B_LED, KAL_TRUE);
   pmic_led_config(&pmic_set);
   status=B2PSI_read(PMIC_GLED_DRIVER);   
   status=status&0x1f;
   status=(status+1)*100/32;  
   dbg_print("B LED duty= %d\r\n",(status));
   
   pmic_set.type=KP_LED;
   pmic_led_enable(KP_LED, KAL_TRUE);
   pmic_led_config(&pmic_set);
   status=B2PSI_read(PMIC_KPLED_DRIVER);
   status=status&0x1f;
   status=(status+1)*100/32;  
   dbg_print("KP LED duty= %d\r\n",(status));
   
   pmic_set.type=BL_LED;
   pmic_led_enable(BL_LED, KAL_TRUE);
   pmic_led_config(&pmic_set);
   status=B2PSI_read(PMIC_BLLED_DRIVER);    
   status=status&0x1f;
   status=(status+1)*100/32;  
   dbg_print("BL LED duty= %d\r\n",(status));   
}   
void LED_turnoff(void)
{
   pmic_led_enable(R_LED, KAL_FALSE);
   pmic_led_enable(G_LED, KAL_FALSE);
   pmic_led_enable(B_LED, KAL_FALSE);
   pmic_led_enable(KP_LED, KAL_FALSE);
   pmic_led_enable(BL_LED, KAL_FALSE);
}   
void DIM_test(kal_uint32 clk)
{
   kal_uint32 div;
   pmic_rgb_dim_clk_setting(clk);
   pmic_bl_dim_clk_setting(clk);
   div=B2PSI_read(PMIC_DIM_CLOCK);   
   div=div&0xf;
   //div=32000/(div+1);
   dbg_print("DIV= %d\r\n",div);
}   
void current_offset_test(kal_int8 current_off)
{
   kal_int8 offset;
   pmic_charge_current_offset(current_off);
   offset=B2PSI_read(PMIC_CHARGER_CTRL2);  
   offset=4*(offset-4); 
   dbg_print("offset = %d\r\n",offset);
   
}   
void spk_test(kal_uint8 gain)
{  
   kal_uint8 data;   
   //dbg_print("spk ctrl before= %d\r\n",gain);    
   pmic_speaker_gain(gain);   
   data=B2PSI_read(PMIC_CHARGER_SPEAKER_CTRL);  
   data=data&SPK_GAIN_MASK;
   data=2*(data>>4);
   dbg_print("spk ctrl after= %d\r\n",data);       
}   
void charging_current_test(pmic_charging_current current)
{
   kal_uint8 data;
   data=B2PSI_read(PMIC_CHARGER_SPEAKER_CTRL);  
   //dbg_print("ac ctrl before= %d\r\n",data); 
   //dbg_print("ac current= %d\r\n",current);    
   //pmic_ac_currnet_ctrl(current);   
   pmic_charging_currnet_ctrl(current);
   data=B2PSI_read(PMIC_CHARGER_SPEAKER_CTRL);  
   data=data&(0x7);
   //dbg_print("ac ctrl after= %d\r\n",data);    
   switch (data)
   {
      case 0:
         dbg_print("charing current 50mA\r\n");    
         break;
      case 1:
         dbg_print("charing current 90mA\r\n");    
         break;
      case 2:
         dbg_print("charing current 150mA\r\n");    
         break;
      case 3:
         dbg_print("charing current 225mA\r\n");    
         break;
       case 4:
         dbg_print("charing current 300mA\r\n");    
         break;
       case 5:
         dbg_print("charing current 450mA\r\n");    
         break;
      case 6:
         dbg_print("charing current 650mA\r\n");    
         break;
      case 7:
         dbg_print("charing current 800mA\r\n");    
         break;          
      default:
         break; 
    }                                            
}


void usb_test(kal_bool on, usb_current current)
{
   kal_uint8 data;
   pmic_usb_regulator_enable(on);
   pmic_chr_enable(on);
   pmic_usb_current_ctrl(current);      
   data=B2PSI_read(PMIC_CHARGER_SPEAKER_CTRL);
}   
      
void misc_test(kal_bool on)
{
   pmic_vasw_enable(on);   
   pmic_vd_sel(on);
   //pmic_vb_sel(on);
   pmic_usb_regulator_enable(on);
   pmic_vmc_enable(on);
   pmic_vsim_sel(on);
   pmic_speaker_enable(on);   
   pmic_vibrator_enable(on);
}  

void LDO_test(void)
{  
   kal_uint8 i;
   kal_uint8 status;
   for(i=0;i<6;i++)
   {
      status=pmic_ldo_status(i);
      status=status>>(i+2);
      switch(i)
      {
         case VSIM_LDO:
            dbg_print("VSIM_LDO=");             
            break;             
         case VTCXO_LDO:
            dbg_print("VTCXO_LDO=");             
            break;
         case VRTC_LDO:
            dbg_print("VRTC_LDO=");             
            break;         
         case VM_LDO:
            dbg_print("VM_LDO=");             
            break;
         case VA_LDO:
            dbg_print("VA_LDO=");             
            break;
         case VD_LDO:
            dbg_print("VD_LDO=");             
            break;   
         default:            
            break;
      }
      dbg_print("%d\r\n",status);                         
   }   
   
      
}  
kal_uint32 pmic_test_count=0; 
kal_uint8 duty=100;
kal_uint8  led_mode=0;
kal_uint8 spk_gain=0; 
void pmic_test(void)
{   
     
   if(pmic_test_count==0)
   {  
      B2PSI_init();  
      pmic_init(); 
      pmic_led_enable(BL_LED, KAL_TRUE);
      
      pmic_vibrator_sel(VIBRATOR_1_8V);
      pmic_vibrator_sel(VIBRATOR_2_8V);
      pmic_vibrator_sel(VIBRATOR_1_8V);
      pmic_usb_chr_enable(KAL_TRUE);
      pmic_usb_chr_enable(KAL_FALSE);
      pmic_usb_chr_enable(KAL_TRUE);
   }
   /*spk gain control*/ 
   spk_gain=2*(pmic_test_count%8);   
	spk_test(spk_gain);
	misc_test((pmic_test_count%2));			
	duty=duty-5;
	if(duty==0)
	{
	   duty=100;
	   led_mode++;
	   led_mode=led_mode%4;
	   /*current offset*/
	   current_offset_test((led_mode*4));			   			   
	   LED_turnoff();			   
	}   
	/*LED test*/
  switch(led_mode)
  {
     case 0:
        dbg_print("LED current: 24mA\r\n");
        LED_test(LED_CURRENT_24, duty);   
        DIM_test(1000);            
        break;
     case 1:
        dbg_print("LED current: 20mA\r\n");
        LED_test(LED_CURRENT_20, duty);
        DIM_test(200);            
        break;
     case 2:
        dbg_print("LED current: 16mA\r\n");
        LED_test(LED_CURRENT_16, duty);
        DIM_test(50);            
        break;
     case 3:
        dbg_print("LED current: 12mA\r\n");
        LED_test(LED_CURRENT_12, duty);
        DIM_test(1);            
        break;                              
     default:
		break;   
  }      		
	pmic_test_count++;			
	pmic_test_mode_test();
}    

void pmic_module_test(void)
{      
            
   DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_B2SPI,PDN_B2PSI);
   B2PSI_init();
   pmic_init();
   pmic_usb_regulator_enable(KAL_TRUE);
   pmic_usb_enable(KAL_TRUE);
   pmic_chr_pump_enable(KAL_TRUE);
   pmic_vasw_enable(KAL_TRUE);
   pmic_vmc_enable(KAL_TRUE);
   pmic_speaker_enable(KAL_TRUE);
   pmic_vibrator_enable(KAL_TRUE);
   spk_test(100);
   misc_test(KAL_TRUE);   
   pmic_vibrator_sel(VIBRATOR_1_8V);    
   pmic_usb_chr_enable(KAL_TRUE);
       
   LED_test(LED_CURRENT_24, 100); 
   B2PSI_write(0xff, 0X7000);
   B2PSI_write(0xff, 0X3000);   
   
}
#endif/*MT6318_DEBUG*/

#endif/*MT6318*/