custom_equipment.c

最新MTK手机软件源码

*   GLOBALS AFFECTED
*/
kal_bool custom_cfg_audio_out_device
(
 kal_uint8 audio_sound_id, /* audio_id_enum */
 kal_uint8 *out_device_path /* audio_type_enum */
 )
{
   /*----------------------------------------------------------------*/
   /* Local Variables                                                */
   /*----------------------------------------------------------------*/
   kal_bool res = KAL_TRUE;
   /*----------------------------------------------------------------*/
   /* Code Body                                                      */
   /*----------------------------------------------------------------*/
   
   ASSERT(out_device_path!=NULL);

   /* if there is no change, it will use the default value at PS */
   if ( audio_sound_id <= TONE_KEY_NORMAL )
   {
      if (l_ext_device_id==EXT_DEV_HANDFREE) 
         *out_device_path = AUDIO_DEVICE_LOUDSPEAKER;
      else if ( (l_ext_device_id==EXT_DEV_EARPHONE) || (l_ext_device_id==EXT_DEV_CARKIT) )
         *out_device_path = AUDIO_DEVICE_SPEAKER2;
      else 
         *out_device_path = AUDIO_DEVICE_SPEAKER;
   }
   else if ( (audio_sound_id >TONE_KEY_NORMAL) && (audio_sound_id <= MAX_TONE_ID) )
   {
      /* for little sound will play in speaker */
      if (audio_sound_id <= (TONE_NEGATIVE_ACK))
      {
         if (l_ext_device_id==EXT_DEV_HANDFREE) 
            *out_device_path = AUDIO_DEVICE_LOUDSPEAKER;
         else if ( (l_ext_device_id==EXT_DEV_EARPHONE) || (l_ext_device_id==EXT_DEV_CARKIT) )
            *out_device_path = AUDIO_DEVICE_SPEAKER2;
         else 
            *out_device_path = AUDIO_DEVICE_SPEAKER;
      }
      /* for large sound will play in speaker */
      else
      {
         *out_device_path = AUDIO_DEVICE_LOUDSPEAKER;
      }
   }
   else if ( (audio_sound_id >= MIN_RING_TONE_ID) && (audio_sound_id <= MAX_RING_TONE_ID) )
   {
      *out_device_path = AUDIO_DEVICE_LOUDSPEAKER;
   }
   else if ( (audio_sound_id >= MIN_MIDI_ID) && (audio_sound_id <= MAX_MIDI_ID) )
   {
      *out_device_path = AUDIO_DEVICE_LOUDSPEAKER;
   }
   else
   {
      res = KAL_FALSE;
   }
   
   return res;
}

/* 
*   Function 
*      custom_cfg_speech_out_device
*   DESCRIPTION
*      The function is used to customize speech output path, 
*     while there is a external interrupt occur.
*     And it will be used by audio manager.
*   PARAMETERS
*     ext_device_id      IN
*     out_device_path    IN/OUT
*   RETURNS
*      kal_bool
*   GLOBALS AFFECTED
*/
kal_bool custom_cfg_speech_out_device
(
 kal_uint8  ext_device_id, /* ext_device_enum */
 kal_uint8 *out_device_path /* audio_type_enum */
 )
{
   /*----------------------------------------------------------------*/
   /* Local Variables                                                */
   /*----------------------------------------------------------------*/
   kal_bool res = KAL_TRUE;
   /*----------------------------------------------------------------*/
   /* Code Body                                                      */
   /*----------------------------------------------------------------*/
   
   ASSERT(out_device_path!=NULL);
   
   /* store the external interrupt IO */
   l_ext_device_id = ext_device_id;

   switch(ext_device_id)
   {
   case EXT_DEV_NONE:
      *out_device_path = AUDIO_DEVICE_SPEAKER;
      break;
   case EXT_DEV_EARPHONE:
   case EXT_DEV_CARKIT:
      *out_device_path = AUDIO_DEVICE_SPEAKER2;
      break;
   case EXT_DEV_HANDFREE:
      *out_device_path = AUDIO_DEVICE_LOUDSPEAKER;
      break;
   default:
      res = KAL_FALSE;
      break;
   }

   return res;
}


kal_uint8 custom_cfg_hw_aud_output_path(  kal_uint8 speaker_id )
{
   /*----------------------------------------------------------------*/
   /* Local Variables                                                */
   /*----------------------------------------------------------------*/
   kal_uint8 audio_device_out = L1SP_SPEAKER1;
   /*----------------------------------------------------------------*/
   /* Code Body                                                      */
   /*----------------------------------------------------------------*/
   switch(speaker_id)
   {
   case AUDIO_DEVICE_SPEAKER/*AUDIO_OUT_SPEAKER1*/:
      audio_device_out = L1SP_SPEAKER1;
      break;
   case AUDIO_DEVICE_SPEAKER2/*AUDIO_OUT_SPEAKER2*/:
      audio_device_out = L1SP_SPEAKER2;
      break;
   case AUDIO_DEVICE_LOUDSPEAKER/*AUDIO_OUT_LOUDSPEAKER*/:
      audio_device_out = L1SP_LOUD_SPEAKER;
      break;
   case AUDIO_DEVICE_SPEAKER_BOTH: /* AUDIO_OUT_SPEAKER1 and AUDIO_OUT_SPEAKER2 */
      audio_device_out = (L1SP_LOUD_SPEAKER| L1SP_SPEAKER2);
      break;
   case AUDIO_DEVICE_BUZZER/*AUDIO_OUT_BUZZER*/:
   case AUDIO_DEVICE_GMI/*AUDIO_OUT_GMI*/:
      audio_device_out = L1SP_LOUD_SPEAKER;
      break;
   default:
      break;
   }
   
   return audio_device_out;
}



kal_uint8 custom_cfg_hw_aud_input_path(  kal_uint8 mic_id )
{
   kal_uint8 mic_device = 0;

   switch(mic_id)
   {
   case AUDIO_DEVICE_MIC1:
      mic_device = 0;
      break;
   case AUDIO_DEVICE_MIC2:
      mic_device = 1;
      break;
   case AUDIO_DEVICE_FMRR:
      mic_device = 3;  /*L1SP_LNA_FMRR*/
   default:
      break;
   }
   
   return mic_device;
}

/* 
*   Function 
*      custom_cfg_vbat_level_regulator
*   DESCRIPTION
*      The function is used to convert the vbat value to the end-user level .
*     And it will be call by audio manager.
*   PARAMETERS
*     vbat      IN
*   RETURNS
*      kal_uint8
*   GLOBALS AFFECTED
*/
kal_uint8 custom_cfg_vbat_level_regulator( kal_uint32 measure_voltage, kal_uint8 *last_level, kal_uint8 *disp_level, kal_uint8 *hit_count )
{
   kal_uint8 level=0; 
   kal_uint8 regulated_level=0; 

   for( level=0; level<BATTERY_MAX_LEVEL; level++)
      if( measure_voltage <= Battery_Level_Info[level] )
         break;

   kal_prompt_trace(MOD_UEM, "Begin: [level %d] [last %d] [disp %d] [hit %d]", \
      level, *last_level, *disp_level,  *hit_count );
         
   if( level > *disp_level )
      {
            for( level=0; level<BATTERY_MAX_LEVEL; level++)
               if( measure_voltage <= (Battery_Level_Info[level] + VBAT_GROWUP_PENALTY) )
                  break;
      }

   kal_prompt_trace(MOD_UEM, "Penalty: [level %d] [last %d] [disp %d] [hit %d]", \
      level, *last_level, *disp_level,  *hit_count );

   if( level == *last_level )
      {
           if( *hit_count >= VBAT_HIT_COUNT_BOUND )
            {
                 regulated_level = *disp_level = level;
            }
           else 
           {
                (*hit_count)++;
                regulated_level = *disp_level;
            }
      }
   else
      {
           *hit_count=1;
           regulated_level = *disp_level;

      }
   
   kal_prompt_trace(MOD_UEM, "End: [level %d] [last %d] [disp %d] [hit %d]", \
      level, *last_level, *disp_level,  *hit_count );

  *last_level = level;

   if( level <= BATTERY_LOW_WARNING )
      return ( level );
   else
   return ( *disp_level );
   
}

/*
*      custom_cfg_vbat_level_convert
*   DESCRIPTION
*      The function is used to convert the vbat value to the end-user level .
*     And it will be call by audio manager.
*   PARAMETERS
*     vbat      IN
*   RETURNS
*      kal_uint8
*   GLOBALS AFFECTED
*/
kal_uint8 custom_cfg_vbat_level_convert
(
 kal_int32  vbat
 )
{
   /*----------------------------------------------------------------*/
   /* Local Variables                                                */
   /*----------------------------------------------------------------*/
   kal_uint8 level=0; /* the level could be customized by user */
   /*----------------------------------------------------------------*/
   /* Code Body                                                      */
   /*----------------------------------------------------------------*/

   for( level=0; level<BATTERY_MAX_LEVEL; level++)
      if( vbat <= Battery_Level_Info[level] )
         return level;
      
   return (BATTERY_MAX_LEVEL-1);

}

/*
*      custom_cfg_vbat_percentage_convert
*   DESCRIPTION
*      The function is used to convert the vbat value to the end-user level .
*     And it will be call by audio manager.
*   PARAMETERS
*     vbat      IN
*   RETURNS
*      kal_uint8
*   GLOBALS AFFECTED
*/
kal_uint32 custom_cfg_vbat_percentage_convert
(
 kal_uint32  vbat
 )
{
   kal_uint32 int_result;
   double result;

   if( BATLEV_MAX_IDX == 0 )
   {
      ASSERT(BATLEV_MAX_VOLTAGE > 0);
      result = (double)vbat/(double)BATLEV_MAX_VOLTAGE;
      
   }
   else if( BATLEV_MAX_IDX > 0 && BATLEV_MAX_IDX < BATTERY_MAX_LEVEL ) 
   {
      ASSERT(Battery_Level_Info[BATLEV_MAX_IDX] > 0);
      result = (double)vbat/(double)Battery_Level_Info[BATLEV_MAX_IDX] ;
   }
   else
   {
       result = 0.0;
   }
   
   int_result = (kal_uint32) (result * 10000);
   
   return (int_result);
}

#ifndef __CUST_NEW__
/***********************************************************
  **
  **  GPIO SETTTING
  **
  ***********************************************************/



/* 
*   Function 
*      custom_cfg_outward_gpio_port
*   DESCRIPTION
*      The function is used to handle the port number of the outward gpio device.
*     And it will be call by audio manager.
*   PARAMETERS
*     gpio_device_id      IN
*     port_num            IN/OUT
*   RETURNS
*      kal_bool
*   GLOBALS AFFECTED
*/
kal_uint8 custom_cfg_outward_gpio_port(  kal_uint8  gpio_device_id /* gpio_device_enum */)
{
   if( (gpio_device_id < GPIO_LABELID_MAX) && (gpio_map_tbl[gpio_device_id].vaild != GPIO_INVAILD) )
      return gpio_map_tbl[gpio_device_id].port;
   else
      return 0;
}




kal_bool custom_cfg_gpio_set_level(kal_uint8 gpio_dev_type, kal_uint8 gpio_dev_level )
{
   kal_bool res=KAL_TRUE;
   kal_uint8 port;
          
   switch(gpio_dev_type)     
   {
   case GPIO_DEV_LED_MAINLCD:
        if( gpio_dev_level == LED_LIGHT_LEVEL0)
           GPIO_WriteIO(GPIO_OFF, custom_cfg_outward_gpio_port(GPIO_LABEL_LCM_BL_EN) );
        else
           GPIO_WriteIO(GPIO_ON, custom_cfg_outward_gpio_port(GPIO_LABEL_LCM_BL_EN) );
           
        PWM_level(gpio_dev_level);
        break;

   case GPIO_DEV_LED_SUBLCD:
        break;

   case GPIO_DEV_LED_STATUS_1:
        if( gpio_dev_level == LED_LIGHT_LEVEL0)
           GPIO_WriteIO(GPIO_OFF, custom_cfg_outward_gpio_port(GPIO_LABELID_RLED_EN) );
        else
           GPIO_WriteIO(GPIO_ON, custom_cfg_outward_gpio_port(GPIO_LABELID_RLED_EN) );
        break;

   case GPIO_DEV_LED_STATUS_2:
        if( gpio_dev_level == LED_LIGHT_LEVEL0)
           GPIO_WriteIO(GPIO_OFF, custom_cfg_outward_gpio_port(GPIO_LABELID_GLED_EN) );
        else
           GPIO_WriteIO(GPIO_ON, custom_cfg_outward_gpio_port(GPIO_LABELID_GLED_EN) );
        break;

   case GPIO_DEV_LED_STATUS_3:
        if( gpio_dev_level == LED_LIGHT_LEVEL0)
           GPIO_WriteIO(GPIO_OFF, custom_cfg_outward_gpio_port(GPIO_LABELID_BLED_EN) );
        else
           GPIO_WriteIO(GPIO_ON, custom_cfg_outward_gpio_port(GPIO_LABELID_BLED_EN) );
        break;

   case GPIO_DEV_LED_KEY:
	{
			static kal_uint16 mode = 1;
			
			if (mode == 1)
			{
				mode = 0;
				GPIO_ModeSetup((kal_uint16)  custom_cfg_outward_gpio_port(GPIO_LABELID_KELEDPWM), mode);
			}
			
        if(gpio_dev_level==LED_LIGHT_LEVEL0)
            GPIO_WriteIO(GPIO_OFF, custom_cfg_outward_gpio_port(GPIO_LABELID_KELEDPWM));
        else
            GPIO_WriteIO(GPIO_ON, custom_cfg_outward_gpio_port(GPIO_LABELID_KELEDPWM));

       		
        Alter_level(gpio_dev_level);
        break;
	}
   case GPIO_DEV_VIBRATOR:
        if( gpio_dev_level == VIBRATOR_OFF)
           GPIO_WriteIO(GPIO_OFF, custom_cfg_outward_gpio_port(GPIO_LABEL_VIB_EN) );
        else
           GPIO_WriteIO(GPIO_ON, custom_cfg_outward_gpio_port(GPIO_LABEL_VIB_EN));
        break;

   case GPIO_DEV_FLASHLIGHT:
        if( gpio_dev_level == LED_LIGHT_LEVEL0)
           GPIO_WriteIO(GPIO_OFF, custom_cfg_outward_gpio_port(GPIO_LABEL_CMLIGHT_EN) );
        else
           GPIO_WriteIO(GPIO_ON, custom_cfg_outward_gpio_port(GPIO_LABEL_CMLIGHT_EN) );
        break;

   default:
      /* error undefine */
      return KAL_FALSE;
   }

   return KAL_TRUE;
}

void custom_start_flashlight(kal_uint8 red_level, kal_uint8 green_level, kal_uint8 blue_level, kal_uint8 duty)
{
	GPIO_WriteIO(GPIO_ON, custom_cfg_outward_gpio_port(GPIO_LABEL_CMFLASH_EN) );
}

void custom_stop_flashlight(void)
{ 
	GPIO_WriteIO(GPIO_OFF, custom_cfg_outward_gpio_port(GPIO_LABEL_CMFLASH_EN) );
}
#endif /* __CUST_NEW__ */

#endif /* !__L1_STANDALONE__ */