pmic6318.c

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

void pmic_vb_sel(vb_vol sel)
{
   kal_uint8 data;
   kal_uint32 savedMask;

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

   if(sel==VB_VTCXO)
   {
      data|=VASEL_VTCXO;/*sleep mode*/   
   }   
   else if(sel==VB_VD)
   {
      data&=~VASEL_VTCXO;/*normal mode*/
   }            
   B2PSI_write(data, PMIC_MISC);
   RestoreIRQMask(savedMask);           
}     

/*
* FUNCTION                                                            
*	pmic_vd_sel
*
* DESCRIPTION                                                           
*  Adjust vd voltage source
*
* CALLS  
*	
*
* PARAMETERS
*	sel: vd voltage source selection
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_vd_sel(vd_sel sel)
{
   kal_uint8 data;
   kal_uint32 savedMask;
   
   savedMask = SaveAndSetIRQMask();
   data=pmic_reg_save[(PMIC_MISC>>PMIC_SHIFT_BITS)];
   
   if(sel==VD_0_9)
   {
      data|=VD_0_9V;/*sleep mode*/   
   }   
   else if(sel==VD_NORMAL)
   {
      data&=~VD_0_9V;/*normal mode*/
   }            
   B2PSI_write(data, PMIC_MISC);
   RestoreIRQMask(savedMask);          
}     
  /*
* FUNCTION                                                            
*	pmic_vasw_enable
*
* DESCRIPTION                                                           
*  Turn on or Turn off VASW LDO
*
* CALLS  
*	It is called by external module that uses VASW LDO
*
* PARAMETERS
*	enable: on or off
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/   

void pmic_vasw_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|=VASW_ON;   
   }   
   else if(enable==KAL_FALSE)
   {
      data&=~VASW_ON;
   }            
   B2PSI_write(data, PMIC_MISC); 
   RestoreIRQMask(savedMask);          
}
/*
* FUNCTION                                                            
*	pmic_chr_pump_enable
*
* DESCRIPTION                                                           
*  Turn on or turn off charge pump
*
* CALLS  
*	It is called by PMIC6318 driver
*
* PARAMETERS
*	enable: on or off
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
/*chr_pump on/off*/
void pmic_chr_pump_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|=CHR_PUMP_ON;   
   }   
   else if(enable==KAL_FALSE)
   {
      data&=~CHR_PUMP_ON;
   }            
   B2PSI_write(data, PMIC_MISC);
   RestoreIRQMask(savedMask);          
}
/*
* FUNCTION                                                            
*	pmic_chr_enable
*
* DESCRIPTION                                                           
*   start or pause charging process
*
* CALLS  
*	It is called by BMT task 
*
* PARAMETERS
*	enable: on or off
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
/*charge control*/
void pmic_chr_enable(kal_bool enable)
{
   kal_uint8 data;
   kal_uint32 savedMask;

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

   if(enable==KAL_TRUE)
   {
      data|=CHR_ON;   
   }   
   else if(enable==KAL_FALSE)
   {
      data&=~CHR_ON;/*pause mode*/
   }                 
   B2PSI_write(data, PMIC_CHARGER_SPEAKER_CTRL); 
   RestoreIRQMask(savedMask);
}
void pmic_usb_enable(kal_bool enable)
{
   kal_uint8 data;
   kal_uint32 savedMask;

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

   if(enable==KAL_TRUE)
   {
      data|=CHR_ON;   
   }   
   else if(enable==KAL_FALSE)
   {
      data&=~CHR_ON;/*pause mode*/
   }                 
   B2PSI_write(data, PMIC_CHARGER_SPEAKER_CTRL); 
   RestoreIRQMask(savedMask);
}
/*
* FUNCTION                                                            
*	pmic_speaker_gain
*
* DESCRIPTION                                                           
*  adjust audio amplifier gain
*
* CALLS  
*	It is called by audio driver
*
* PARAMETERS
*	gain: audio amplifier gain
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_speaker_gain(kal_uint8 gain)
{
   kal_uint8 data;
   kal_uint32 savedMask;
   if(gain>=MAX_SPK_GAIN)
      gain=MAX_SPK_GAIN;   
   savedMask = SaveAndSetIRQMask();
   data=pmic_reg_save[(PMIC_CHARGER_SPEAKER_CTRL>>PMIC_SHIFT_BITS)];
   gain=gain/3;
   gain=(gain<<SPK_GAIN_SHIFT);
   data&=~SPK_GAIN_MASK;   
   data|= gain;   
   B2PSI_write(data, PMIC_CHARGER_SPEAKER_CTRL); 
   RestoreIRQMask(savedMask);
} 
/*
* FUNCTION                                                            
*	pmic_usb_regulator_enable
*
* DESCRIPTION                                                           
*   	turn on or turn off USB LDO
*
* CALLS  
*	It is called by USB task
*
* PARAMETERS
*	enable: on or off
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/      
/*usb regulator on/off*/
void pmic_usb_regulator_enable(kal_bool enable)
{
   kal_uint8 data;
   kal_uint32 savedMask;

   savedMask = SaveAndSetIRQMask();
   data=pmic_reg_save[(PMIC_CHARGER_SPEAKER_CTRL>>PMIC_SHIFT_BITS)];
      
   if(enable==KAL_TRUE) 
   {
      data|=USB_PWR_ON;   
   }   
   else if(enable==KAL_FALSE)
   {
      data&=~USB_PWR_ON;
   }            
   B2PSI_write(data, PMIC_CHARGER_SPEAKER_CTRL); 
   RestoreIRQMask(savedMask);     
} 
/*
* FUNCTION                                                            
*	pmic_ac_currnet_ctrl
*
* DESCRIPTION                                                           
*   adjust usb charging current
*
* CALLS  
*	It is called by BMT task
*
* PARAMETERS
*	current: AC charging current
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/  
/*ac current control*/
void pmic_ac_currnet_ctrl(ac_current current)
{
   kal_uint8 data;
   kal_uint32 savedMask;

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

   data&=~AC_CURRENT_MASK;
   data|=current;
   B2PSI_write(data, PMIC_CHARGER_SPEAKER_CTRL);    
   RestoreIRQMask(savedMask);     
}
void pmic_charging_currnet_ctrl(pmic_charging_current current)
{
   kal_uint8 data;
   kal_uint32 savedMask;

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

   data&=~CHR_CURRENT_MASK;
   data|=current;
   B2PSI_write(data, PMIC_CHARGER_SPEAKER_CTRL);    
   RestoreIRQMask(savedMask);     
}
/*
* FUNCTION                                                            
*	pmic_usb_current_ctrl
*
* DESCRIPTION                                                           
*  adjust usb charging current  	
*
* CALLS  
*	It is called by BMT task
*
* PARAMETERS
*	current: usb charging current(90 or 450mA)
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/

void pmic_usb_current_ctrl(usb_current current)
{
   kal_uint8 data;
   kal_uint32 savedMask;
   
   savedMask = SaveAndSetIRQMask();
   data=pmic_reg_save[(PMIC_CHARGER_SPEAKER_CTRL>>PMIC_SHIFT_BITS)];   
   data&=~USB_CURRENT_MASK;
   data|=current;
   B2PSI_write(data, PMIC_CHARGER_SPEAKER_CTRL);         
   RestoreIRQMask(savedMask);     
}       


void pmic_charge_pump_init(kal_uint8 value)
{
   kal_uint8 data;
   kal_uint32 savedMask;
   
   savedMask = SaveAndSetIRQMask();
   data=pmic_reg_save[(PMIC_CHARGE_PUMP>>PMIC_SHIFT_BITS)];   
   value&=0x1f;   
   data&=~0xf8;
   data|=(value<<3);
   B2PSI_write(data, PMIC_CHARGE_PUMP);         
   RestoreIRQMask(savedMask);     
}       
/*
* FUNCTION                                                            
*	pmic_ldo_status
*
* DESCRIPTION                                                           
*   	Report currnt LDO status
*
* CALLS  
*	It is called to get current LDO status
*
* PARAMETERS
*	ldo: LDO type
*	
* RETURNS
*	LDO status
*
* GLOBALS AFFECTED
*   external_global
*/
/*LDO status */
kal_uint8 pmic_ldo_status(pmic_ldo ldo)
{
   kal_uint8 data;
   data=B2PSI_read(PMIC_LDO_STAT);   
   
   switch(ldo)
   {
      case VSIM_LDO:
         return (data&LDO_VSIM_MASK);
         break;             
      case VTCXO_LDO:
         return(data&LDO_VTCXO_MASK);
         break;
      case VRTC_LDO:
         return(data&LDO_VRTC_MASK);
         break;         
      case VM_LDO:
         return(data&LDO_VM_MASK);
         break;
      case VA_LDO:
         return(data&LDO_VA_MASK);
         break;
      case VD_LDO:
         return(data&LDO_VD_MASK);
         break;   
      default:
         return(0);
         break;
   }
}      
/*
* FUNCTION                                                            
*	pmic_chr_status
*
* DESCRIPTION                                                           
*   	Read charging control status
*
* CALLS  
*	
*
* PARAMETERS
*	status: status user wants to know
*	
* RETURNS
*	current charging status
*
* GLOBALS AFFECTED
*   external_global
*/
/*charger status, not export to others */
kal_uint8 pmic_chr_status(pmic_chr_stat status)
{
   kal_uint8 data=0, result=0;   
   data=pmic_reg_save[PMIC_CHARGER_STAT];      
   switch(status)
   {
      case CHR_STAT_OV:
         return ((data&OV_MASK)>>7);
         break;             
      case CHR_STAT_CHRDET:
         return((data&CHRDET_MASK)>>6);
         break;
      case CHR_STAT_BAT_ON:
         if(((data&BAT_ON_MASK)>>5))
            result=0;
         else
            result=1;     
         return result;         
         break;
      case CHR_STAT_AC_DET:
         return((data&AC_DET_MASK)>>4);
         break;
      case CHR_STAT_USB_DET:
         return((data&USB_DET_MASK)>>3);
         break;                           
      case CHR_STAT_CV:
         data=B2PSI_read(PMIC_CHARGER_STAT);
         return((data&CV_STATUS_MASK)>>1);
         break;
      case CHR_STAT_CHRG_DIS:
         data=B2PSI_read(PMIC_CHARGER_STAT);
         if(data&CHR_STATUS_MASK)
            result=0;
         else
            result=1;   
         return result;  
      default:
         return(0);
         break;
   }
   
}
/*
* FUNCTION                                                            
*	pmic_write_to_register_save
*
* DESCRIPTION                                                           
*  write data to pmic_register_save
*
* CALLS  
*	It is called by B2PSI to write data to pmic_register_save
*
* PARAMETERS
*	None
*	
* RETURNS
*	data: data that be written
*  register_index: register index  
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_write_to_register_save(kal_uint8 data, kal_uint16 register_index)
{
   pmic_reg_save[(register_index>>PMIC_SHIFT_BITS)]=data;     
}   
/*
* FUNCTION                                                            
*	pmic_is_chr_det
*
* DESCRIPTION                                                           
*   	to check if AC or USB is plug-in
*
* CALLS  
*	It is called by PWIC
*
* PARAMETERS
*	type: charger type(USB or AC)
*
* RETURNS
*	AC or USB exists or not 
*
* GLOBALS AFFECTED
*   external_global
*/
kal_bool pmic_is_chr_det(chr_type type)
{
   kal_bool status=0;
   switch(type)
   {
      case AC_CHR: 
         status=pmic_chr_status(CHR_STAT_AC_DET);      
         break;
      case USB_CHR: 
         status=pmic_chr_status(CHR_STAT_USB_DET);   
         break;
      default:
         ASSERT(0);
         break;   
   }       
   if(status==0)
      return KAL_FALSE;
   else
      return KAL_TRUE;         
   
}


/*
* FUNCTION                                                            
*	pmic_is_chr_valid
*
* DESCRIPTION                                                           
*   	to check if AC or USB charger is valid 
*
* CALLS  
*	It is called by BMT
*
* PARAMETERS
*  None
*
* RETURNS
*	AC or USB is valid or not 
*
* GLOBALS AFFECTED
*   external_global
*/
kal_bool pmic_is_chr_valid(void)
{
   kal_bool status;
   status=pmic_chr_status(CHR_STAT_CHRDET);      
   
   return(status);      
}
/*
* FUNCTION                                                            
*	PMIC_ChrDet_Registration
*
* DESCRIPTION                                                           
*   	Charger detecion register fucntion
*
* CALLS  
*	It is called by USB and BMT to register their detection handler 
*
* PARAMETERS
*	type: charger type(USB or AC)
*  Callback: detection handler	
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void PMIC_ChrDet_Registration(chr_type type, void (*Callback)(void))
{
   if(type==AC_CHR)
   {
      PMIC_CHRDET.pmic_ac_det=Callback;
   }
   else if (type==USB_CHR)
   {
      PMIC_CHRDET.pmic_usb_det=Callback;
   }
   else
      ASSERT(0);      

}
/*
* FUNCTION                                                            
*	pmic_pump_delay
*
* DESCRIPTION                                                           
*  charge pump delay selection
*
* CALLS  
*  used to charge pump delay selection
*
* PARAMETERS
*	delay: pump delay
*	
* RETURNS
*	None
*
* GLOBALS AFFECTED
*   external_global
*/
void pmic_pump_delay(charge_pumpdelay_enum delay)
{
   kal_uint8 data;
   kal_uint32 savedMask;
   
   savedMask = SaveAndSetIRQMask();   
   data=pmic_reg_save[(PMIC_EXTRAS>>PMIC_SHIFT_BITS)];      
   data&=~0x3;
   data|=delay;
   B2PSI_write(data, PMIC_EXTRAS);         
   RestoreIRQMask(savedMask);   
}   
/*
* FUNCTION                                                            
*	pmic_sim_leveltype
*
* DESCRIPTION                                                           
*   SIM circuit selection
*
* CALLS  
*  used to change SIM circuit
*
* PARAMETERS
*	enable: KAL_TRUE : type 1
           KAL_FALSE : type 0