static int get_lcd_id(void)
{
    mt_set_gpio_mode(GPIO_LCD_ID_PIN,0);
    mt_set_gpio_dir(GPIO_LCD_ID_PIN,0);
    mt_set_gpio_pull_enable(GPIO_LCD_ID_PIN,1);
    mt_set_gpio_pull_select(GPIO_LCD_ID_PIN,1);
    MDELAY(1);

    return mt_get_gpio_in(GPIO_LCD_ID_PIN);
}
Esempio n. 2
0
int cm_do_md_power_off(void)
{
    EMD_MSG_INF("chr","cm_do_md_power_off\n");
    atomic_set(&traffic_on, 0);
    // Release download key to let md can enter normal boot
    mt_set_gpio_dir(GPIO_EXT_MD_DL_KEY, 1);
#ifdef GPIO_EXT_USB_SW2
    mt_set_gpio_out(GPIO_EXT_MD_DL_KEY, 0);//set evb 
#else
    mt_set_gpio_out(GPIO_EXT_MD_DL_KEY, 1);//set phone
#endif
    
    cm_disable_ext_md_wdt_irq();
    cm_disable_ext_md_wakeup_irq();
    cm_disable_ext_md_exp_irq();      
    mt_set_gpio_dir(GPIO_EXT_AP_WK_MD, 1);
    mt_set_gpio_out(GPIO_EXT_AP_WK_MD, 0);    
#ifndef  GPIO_EXT_USB_SW2     
    mt_set_gpio_dir(GPIO_EXT_MD_META, 1);    
    mt_set_gpio_out(GPIO_EXT_MD_META, 0);
#endif 
    mt_set_gpio_out(GPIO_EXT_MD_PWR_KEY, 0);
    //EMD_MSG_INF("chr","cm_do_md_power_off:GPIO_EXT_MD_PWR_KEY(%d)2\n",mt_get_gpio_out(GPIO_EXT_MD_PWR_KEY));

    mt_set_gpio_dir(GPIO_EXT_MD_WK_AP, 0);
    mt_set_gpio_pull_enable(GPIO_EXT_MD_WK_AP, 1);
    mt_set_gpio_pull_select(GPIO_EXT_MD_WK_AP, 0);
    mt_set_gpio_dir(GPIO_EXT_MD_EXP, 0);
    mt_set_gpio_pull_enable(GPIO_EXT_MD_EXP, 1);
    mt_set_gpio_pull_select(GPIO_EXT_MD_EXP, 0);
    
    mt_set_gpio_dir(GPIO_EXT_MD_DUMP, 0);
    mt_set_gpio_pull_enable(GPIO_EXT_MD_DUMP, 1);
    mt_set_gpio_pull_select(GPIO_EXT_MD_DUMP, 0);
    
    //For low power, we switch UART GPIO when power off md
    mt_set_gpio_mode(GPIO_UART_URXD1_PIN, 0);
    mt_set_gpio_mode(GPIO_UART_UTXD1_PIN, 0);
    mt_set_gpio_mode(GPIO_UART_URTS1_PIN, 0);
    mt_set_gpio_mode(GPIO_UART_UCTS1_PIN, 0);
    mt_set_gpio_dir(GPIO_UART_URXD1_PIN, 0);
    mt_set_gpio_pull_enable(GPIO_UART_URXD1_PIN, 1);
    mt_set_gpio_pull_select(GPIO_UART_URXD1_PIN, 0);
    mt_set_gpio_dir(GPIO_UART_UTXD1_PIN, 0);
    mt_set_gpio_pull_enable(GPIO_UART_UTXD1_PIN, 1);
    mt_set_gpio_pull_select(GPIO_UART_UTXD1_PIN, 0);
    mt_set_gpio_dir(GPIO_UART_URTS1_PIN, 0);
    mt_set_gpio_pull_enable(GPIO_UART_URTS1_PIN, 1);
    mt_set_gpio_pull_select(GPIO_UART_URTS1_PIN, 0);
    mt_set_gpio_dir(GPIO_UART_UCTS1_PIN, 0);
    mt_set_gpio_pull_enable(GPIO_UART_UCTS1_PIN, 1);
    mt_set_gpio_pull_select(GPIO_UART_UCTS1_PIN, 0);
    
    EMD_MSG_INF("chr","uart gpio pull down\n");
    
    cm_dump_gpio();
    return 0;
}
INT32 wmt_plat_bgf_eint_ctrl(ENUM_PIN_STATE state)
{
#if defined(CONFIG_MTK_GPIO_LEGACY)
#ifdef GPIO_COMBO_BGF_EINT_PIN
	switch (state) {
	case PIN_STA_INIT:
		/*set to gpio input low, pull down enable */
		mt_set_gpio_mode(GPIO_COMBO_BGF_EINT_PIN, GPIO_COMBO_BGF_EINT_PIN_M_GPIO);
		mt_set_gpio_dir(GPIO_COMBO_BGF_EINT_PIN, GPIO_DIR_IN);
		mt_set_gpio_pull_select(GPIO_COMBO_BGF_EINT_PIN, GPIO_PULL_DOWN);
		mt_set_gpio_pull_enable(GPIO_COMBO_BGF_EINT_PIN, GPIO_PULL_ENABLE);
		WMT_PLAT_DBG_FUNC("WMT-PLAT:BGFInt init(in pd)\n");
		break;

	case PIN_STA_MUX:
		mt_set_gpio_mode(GPIO_COMBO_BGF_EINT_PIN, GPIO_COMBO_BGF_EINT_PIN_M_GPIO);
		mt_set_gpio_pull_enable(GPIO_COMBO_BGF_EINT_PIN, GPIO_PULL_ENABLE);
		mt_set_gpio_pull_select(GPIO_COMBO_BGF_EINT_PIN, GPIO_PULL_UP);
		mt_set_gpio_mode(GPIO_COMBO_BGF_EINT_PIN, GPIO_COMBO_BGF_EINT_PIN_M_EINT);
		WMT_PLAT_DBG_FUNC("WMT-PLAT:BGFInt mux (eint)\n");
		break;

	case PIN_STA_IN_L:
	case PIN_STA_DEINIT:
		/*set to gpio input low, pull down enable */
		mt_set_gpio_mode(GPIO_COMBO_BGF_EINT_PIN, GPIO_COMBO_BGF_EINT_PIN_M_GPIO);
		mt_set_gpio_dir(GPIO_COMBO_BGF_EINT_PIN, GPIO_DIR_IN);
		mt_set_gpio_pull_select(GPIO_COMBO_BGF_EINT_PIN, GPIO_PULL_DOWN);
		mt_set_gpio_pull_enable(GPIO_COMBO_BGF_EINT_PIN, GPIO_PULL_ENABLE);
		WMT_PLAT_DBG_FUNC("WMT-PLAT:BGFInt deinit(in pd)\n");
		break;

	default:
		WMT_PLAT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on BGF EINT\n", state);
		break;
	}
#else
	WMT_PLAT_INFO_FUNC("WMT-PLAT:BGF EINT not defined\n");
#endif
#else /* #if defined(CONFIG_MTK_GPIO_LEGACY) */
#endif
	return 0;
}
bool Speaker_Init(void)
{
   PRINTK("+Speaker_Init Success");
   mt_set_gpio_mode(GPIO_SPEAKER_EN_PIN,GPIO_MODE_00);  // gpio mode
   mt_set_gpio_pull_enable(GPIO_SPEAKER_EN_PIN,GPIO_PULL_ENABLE);
   mt_set_gpio_dir(GPIO_SPEAKER_EN_PIN,GPIO_DIR_OUT); // output
   mt_set_gpio_out(GPIO_SPEAKER_EN_PIN,GPIO_OUT_ZERO); // high
   PRINTK("-Speaker_Init Success");
   return true;
}
INT32 wmt_plat_ldo_ctrl(ENUM_PIN_STATE state)
{
#ifdef GPIO_COMBO_6620_LDO_EN_PIN
	switch (state) {
	case PIN_STA_INIT:
		/*set to gpio output low, disable pull */
		mt_set_gpio_pull_enable(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_PULL_DISABLE);
		mt_set_gpio_dir(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_DIR_OUT);
		mt_set_gpio_mode(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_MODE_GPIO);
		mt_set_gpio_out(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_OUT_ZERO);
		WMT_DBG_FUNC("WMT-PLAT:LDO init (out 0)\n");
		break;

	case PIN_STA_OUT_H:
		mt_set_gpio_out(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_OUT_ONE);
		WMT_DBG_FUNC("WMT-PLAT:LDO (out 1)\n");
		break;

	case PIN_STA_OUT_L:
		mt_set_gpio_out(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_OUT_ZERO);
		WMT_DBG_FUNC("WMT-PLAT:LDO (out 0)\n");
		break;

	case PIN_STA_IN_L:
	case PIN_STA_DEINIT:
		/*set to gpio input low, pull down enable */
		mt_set_gpio_mode(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_COMBO_6620_LDO_EN_PIN_M_GPIO);
		mt_set_gpio_dir(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_DIR_IN);
		mt_set_gpio_pull_select(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_PULL_DOWN);
		mt_set_gpio_pull_enable(GPIO_COMBO_6620_LDO_EN_PIN, GPIO_PULL_ENABLE);
		WMT_DBG_FUNC("WMT-PLAT:LDO deinit (in pd)\n");
		break;

	default:
		WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on LDO\n", state);
		break;
	}
#else
	WMT_INFO_FUNC("WMT-PLAT:LDO is not used\n");
#endif
	return 0;
}
/*---------------------------------------------------------------------------*/
static int mpu_gpio_config(void)
{
	/* because we donot use EINT ,to support low power */
	/* config to GPIO input mode + PD */
	/* set   GPIO_MSE_EINT_PIN */
	mt_set_gpio_mode(GPIO_GYRO_EINT_PIN, GPIO_GYRO_EINT_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_GYRO_EINT_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_enable(GPIO_GYRO_EINT_PIN, GPIO_PULL_ENABLE);
	mt_set_gpio_pull_select(GPIO_GYRO_EINT_PIN, GPIO_PULL_DOWN);
	return 0;
}
Esempio n. 7
0
void apply_post_md_run_setting(void)
{
	#if defined(GPIO_UART_UTXD3_PIN) && defined(GPIO_UART_URXD3_PIN) && defined(GPIO_UART_UTXD3_PIN_M_GPIO) && defined(GPIO_UART_URXD3_PIN_M_GPIO)
	printk("[EEMCS/PLAT] Disable UART pin\n");
	mt_set_gpio_out(GPIO_UART_UTXD3_PIN, GPIO_OUT_ZERO);
	mt_set_gpio_dir(GPIO_UART_UTXD3_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_select(GPIO_UART_UTXD3_PIN, GPIO_PULL_DOWN);
	mt_set_gpio_pull_enable(GPIO_UART_UTXD3_PIN, 1);
	mt_set_gpio_mode(GPIO_UART_UTXD3_PIN, GPIO_UART_UTXD3_PIN_M_GPIO);

	mt_set_gpio_out(GPIO_UART_URXD3_PIN, GPIO_OUT_ZERO);
	mt_set_gpio_dir(GPIO_UART_URXD3_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_select(GPIO_UART_URXD3_PIN, GPIO_PULL_DOWN);
	mt_set_gpio_pull_enable(GPIO_UART_URXD3_PIN, 1);
	mt_set_gpio_mode(GPIO_UART_URXD3_PIN, GPIO_UART_URXD3_PIN_M_GPIO);
	#else
	printk("[EEMCS/PLAT] Disable UART pin dummy\n");
	#endif
	
}
static int eamp_init()
{
	EAMP_PRINTK("eamp_init");

	eamp_poweron();

	mt_set_gpio_mode(GPIO_HEADSET_AMP_EN, GPIO_HEADSET_AMP_EN_M_GPIO);
	mt_set_gpio_pull_enable(GPIO_HEADSET_AMP_EN, GPIO_PULL_ENABLE);
	mt_set_gpio_dir(GPIO_HEADSET_AMP_EN, GPIO_DIR_OUT);

	mt_set_gpio_mode(GPIO_SPK_AMP_L_EN, GPIO_SPK_AMP_L_EN_M_GPIO);
	mt_set_gpio_pull_enable(GPIO_SPK_AMP_L_EN, GPIO_PULL_ENABLE);
	mt_set_gpio_dir(GPIO_SPK_AMP_L_EN, GPIO_DIR_OUT);

	mt_set_gpio_mode(GPIO_SPK_AMP_R_EN, GPIO_SPK_AMP_R_EN_M_GPIO);
	mt_set_gpio_pull_enable(GPIO_SPK_AMP_R_EN, GPIO_PULL_ENABLE);
	mt_set_gpio_dir(GPIO_SPK_AMP_R_EN, GPIO_DIR_OUT);
	
	return 0;
}
Esempio n. 9
0
static unsigned int lcm_compare_id()
{
	unsigned int id=0;

   	mt_set_gpio_mode(50,0);  // gpio mode   high
	mt_set_gpio_pull_enable(50,0);
	mt_set_gpio_dir(50,0);  //input

	mt_set_gpio_mode(47,0);  // gpio mode   low
	mt_set_gpio_pull_enable(47,0);
	mt_set_gpio_dir(47,0);

	id = (mt_get_gpio_in(50) <<4) | mt_get_gpio_in(47);

#if defined(BUILD_LK) || defined(BUILD_UBOOT)
	printf("%s,second source id1 = 0x%08x\n", __func__, id);
#endif	

    return (LCM_ID == id) ? 1 : 0;
}
Esempio n. 10
0
//static void fcover_key_handler(unsigned long data)
static void fcover_key_handler(struct work_struct *work)
{
//	int tmp;
//	fcover_close_flag=new_fcover;
	
	mt_set_gpio_mode(GPIO_FCOVER_EINT_PIN, GPIO_EINT_HALL_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_FCOVER_EINT_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_enable(GPIO_FCOVER_EINT_PIN, GPIO_PULL_DISABLE);

	mdelay(1);
	new_fcover = mt_get_gpio_in(GPIO_FCOVER_EINT_PIN);
		
	mt_set_gpio_mode(GPIO_FCOVER_EINT_PIN, GPIO_EINT_HALL_PIN_M_EINT);

	printk("fcover_key_handler new_fcover=%d\n",new_fcover);

	if(fcover_close_flag != new_fcover)
	{
		spin_lock(&fcover_lock);
		fcover_close_flag = new_fcover;
		spin_unlock(&fcover_lock);
		
		if(fcover_close_flag == 0) // close
		{
//	        	input_report_key(kpd_input_dev, KEY_FCOVER_1, 1);
				input_report_key(kpd_input_dev, KEY_F11, 1);
	        	input_sync(kpd_input_dev);
	        	mdelay(1);
//	            input_report_key(kpd_input_dev, KEY_FCOVER_1, 0); 
				input_report_key(kpd_input_dev, KEY_F11, 0);
	        	input_sync(kpd_input_dev);
				
//				tpd_fcover_setting(fcover_close_flag); 
		
		}
		else  // open
		{
//	        	input_report_key(kpd_input_dev, KEY_FCOVER_2, 1);
				input_report_key(kpd_input_dev, KEY_F12, 1);
	        	input_sync(kpd_input_dev);
	        	mdelay(1);
//	            input_report_key(kpd_input_dev, KEY_FCOVER_2, 0);
				input_report_key(kpd_input_dev, KEY_F12, 0);
	        	input_sync(kpd_input_dev);
				
//				tpd_fcover_setting(fcover_close_flag); 

		}
		
	}
	switch_set_state((struct switch_dev *)&fcover_data, fcover_close_flag);
	mt_eint_set_polarity(FCOVER_KEY_EINT, !fcover_close_flag);
	mt_eint_unmask(FCOVER_KEY_EINT);
}
Esempio n. 11
0
void tpd_resume(struct early_suspend *h) {
    /* added in android 2.2, for configuring EINT2 to GPIO mode */
    mt_set_gpio_mode(GPIO61, 0x00);
    mt_set_gpio_pull_enable(GPIO61, GPIO_PULL_ENABLE);
    mt_set_gpio_pull_select(GPIO61,GPIO_PULL_UP);
    mt_set_gpio_dir(GPIO61, GPIO_DIR_OUT);
    mt_set_gpio_out(GPIO61, GPIO_OUT_ZERO);
    
    hwPowerOn(TPD_POWER_SOURCE,VOL_3300,"TP");
    mdelay(20);
    
    /* added in android 2.2, for configuring EINT2 to EINT mode */
    mt_set_gpio_mode(GPIO61, 0x01);
    mt_set_gpio_pull_enable(GPIO61, GPIO_PULL_ENABLE);
    mt_set_gpio_pull_select(GPIO61,GPIO_PULL_UP);
        
    MT6516_IRQUnmask(MT6516_TOUCH_IRQ_LINE);    
    MT6516_EINTIRQUnmask(CUST_EINT_TOUCH_PANEL_NUM);   
    tpd_halt = 0;
}
Esempio n. 12
0
 void tinno_tp_power_off(void)
{
    mt_set_gpio_mode(TPIO_WAKEUP, 0x00);		//GPIO mode        
    mt_set_gpio_dir(TPIO_WAKEUP,1);
    mt_set_gpio_pull_enable(TPIO_WAKEUP, 1);	//external pull up???        
    mt_set_gpio_pull_select(TPIO_WAKEUP, GPIO_PULL_DOWN);	       
    mt_set_gpio_out(TPIO_WAKEUP,0);

    msleep(10);        
    
    mt_set_gpio_mode(TPIO_RESET, 0x00);		//GPIO mode        
    mt_set_gpio_dir(TPIO_RESET,1);
    mt_set_gpio_pull_enable(TPIO_RESET, 1);	//external pull up???        
    mt_set_gpio_pull_select(TPIO_RESET, GPIO_PULL_DOWN);	   
    mt_set_gpio_out(TPIO_RESET,0);				//output low
    hwPowerDown(TPD_POWER_SOURCE, "TP");
    
    msleep(50); 
    
}    
Esempio n. 13
0
bool Speaker_Init(void)
{
    PRINTK("+jacob Speaker_Init Success");
    mt_set_gpio_mode(GPIO_SPEAKER_EN_PIN,GPIO_MODE_00);  // gpio mode
    mt_set_gpio_pull_enable(GPIO_SPEAKER_EN_PIN,GPIO_PULL_ENABLE);
    mt_set_gpio_dir(GPIO_SPEAKER_EN_PIN,GPIO_DIR_OUT); // output
    mt_set_gpio_out(GPIO_SPEAKER_EN_PIN,GPIO_OUT_ZERO); // low
    msleep(SPK_WARM_UP_TIME);
    PRINTK("-jacob Speaker_Init Success");
    return true;
}
Esempio n. 14
0
INT32 wmt_plat_wifi_eint_ctrl(ENUM_PIN_STATE state)
{
#if 0 /*def GPIO_WIFI_EINT_PIN*/
    switch(state)
    {
        case PIN_STA_INIT:
            mt_set_gpio_pull_enable(GPIO_WIFI_EINT_PIN, GPIO_PULL_DISABLE);
            mt_set_gpio_dir(GPIO_WIFI_EINT_PIN, GPIO_DIR_OUT);
            mt_set_gpio_mode(GPIO_WIFI_EINT_PIN, GPIO_MODE_GPIO);
            mt_set_gpio_out(GPIO_WIFI_EINT_PIN, GPIO_OUT_ONE);
            break;
        case PIN_STA_MUX:
            mt_set_gpio_mode(GPIO_WIFI_EINT_PIN, GPIO_WIFI_EINT_PIN_M_GPIO);
            mt_set_gpio_pull_enable(GPIO_WIFI_EINT_PIN, GPIO_PULL_ENABLE);
            mt_set_gpio_pull_select(GPIO_WIFI_EINT_PIN, GPIO_PULL_UP);
            mt_set_gpio_mode(GPIO_WIFI_EINT_PIN, GPIO_WIFI_EINT_PIN_M_EINT);

            break;
        case PIN_STA_EINT_EN:
            mt_eint_unmask(CUST_EINT_WIFI_NUM);
            break;
        case PIN_STA_EINT_DIS:
            mt_eint_mask(CUST_EINT_WIFI_NUM);
            break;
        case PIN_STA_IN_L:
        case PIN_STA_DEINIT:
            /*set to gpio input low, pull down enable*/
            mt_set_gpio_mode(GPIO_WIFI_EINT_PIN, GPIO_COMBO_BGF_EINT_PIN_M_GPIO);
            mt_set_gpio_dir(GPIO_WIFI_EINT_PIN, GPIO_DIR_IN);
            mt_set_gpio_pull_select(GPIO_WIFI_EINT_PIN, GPIO_PULL_DOWN);
            mt_set_gpio_pull_enable(GPIO_WIFI_EINT_PIN, GPIO_PULL_ENABLE);
            break;
        default:
            WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on WIFI EINT\n", state);
            break;
    }
#else
    WMT_INFO_FUNC("WMT-PLAT:WIFI EINT is controlled by MSDC driver \n");
#endif
    return 0;
}
Esempio n. 15
0
//baoqiang add to judge panel
static bool lcm_select_panel(void)
{
	int value;
	mt_set_gpio_mode(LCM_ID_PIN,GPIO_MODE_00);
	mt_set_gpio_pull_enable(LCM_ID_PIN,GPIO_PULL_DISABLE);
	mt_set_gpio_dir(LCM_ID_PIN,GPIO_DIR_IN);
	value=mt_get_gpio_in(LCM_ID_PIN);
	if(value==LCM_TDT)
		return LCM_TDT;
	
	return LCM_TRULY;
}
Esempio n. 16
0
static int disp_button_set_backlight(unsigned int level)
{
  mt_set_gpio_pull_enable(LCM_BUTTON_GPIO_PIN,GPIO_PULL_ENABLE);
  mt_set_gpio_pull_select(LCM_BUTTON_GPIO_PIN,GPIO_PULL_UP);
  if(level == 0) {
       mt_set_gpio_out(LCM_BUTTON_GPIO_PIN, GPIO_OUT_ZERO);
   }
  else
   {
       mt_set_gpio_out(LCM_BUTTON_GPIO_PIN, GPIO_OUT_ONE);
   }
}
static int get_lcd_id(void)
{
  mt_set_gpio_mode(GPIO_LCD_ID_PIN,0);
  mt_set_gpio_dir(GPIO_LCD_ID_PIN,0);
  mt_set_gpio_pull_enable(GPIO_LCD_ID_PIN,1);
  mt_set_gpio_pull_select(GPIO_LCD_ID_PIN,1);
  MDELAY(1);

	Lcd_Log("wqcat %s, get_lcd_id=%d\n", __func__, mt_get_gpio_in(GPIO_LCD_ID_PIN));
    
  return mt_get_gpio_in(GPIO_LCD_ID_PIN);
}
Esempio n. 18
0
static void och165twad_mhall_eint_config_polarity(u8 polarity)
{
	MHALL_ERR("%s: penny   \n", __func__);
	mt_set_gpio_mode(GPIO_MHALL_EINT_PIN, GPIO_MHALL_EINT_PIN_M_EINT);
	mt_set_gpio_dir(GPIO_MHALL_EINT_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_enable(GPIO_MHALL_EINT_PIN, GPIO_PULL_DISABLE);

	mt_eint_set_sens(CUST_EINT_MHALL_NUM, CUST_EINT_MHALL_SENSITIVE);
	mt_eint_set_hw_debounce(CUST_EINT_MHALL_NUM, CUST_EINT_MHALL_DEBOUNCE_CN);
	mt_eint_registration(CUST_EINT_MHALL_NUM, CUST_EINT_MHALL_TYPE, och165twad_mhall_eint_interrupt_handler, 0); 
	mt_eint_unmask(CUST_EINT_MHALL_NUM);
}
static int eamp_init()
{
	EAMP_PRINTK("eamp_init");

	eamp_poweron();

	mt_set_gpio_mode(GPIO_AUDIO_SEL, GPIO_AUDIO_SEL_M_GPIO);
	mt_set_gpio_pull_enable(GPIO_AUDIO_SEL, GPIO_PULL_ENABLE);
	mt_set_gpio_dir(GPIO_AUDIO_SEL, GPIO_DIR_OUT);
	
	return 0;
}
Esempio n. 20
0
static int tpd_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) {             
    int err = 0;// ret = -1;
    
    #ifdef TPD_NO_GPIO
    u16 temp;
    temp = *(volatile u16 *) TPD_RESET_PIN_ADDR;
    temp = temp | 0x40;
    *(volatile u16 *) TPD_RESET_PIN_ADDR = temp;
    #endif
    i2c_client = client;
    
    printk("MediaTek touch panel i2c probe\n");
    
    #ifndef TPD_NO_GPIO 

    mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
    mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);  
    msleep(10);  
    mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
   
    mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);
    mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);
    mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_ENABLE);
    mt_set_gpio_pull_select(GPIO_CTP_EINT_PIN, GPIO_PULL_UP);
    #endif 

    msleep(50);

    I2CDMABuf_va = (u8 *)dma_alloc_coherent(NULL, 4096, &I2CDMABuf_pa, GFP_KERNEL);
    if(!I2CDMABuf_va)
    {
        printk("Allocate Touch DMA I2C Buffer failed!\n");
        return -1;
    }
	
    thread = kthread_run(touch_event_handler, 0, TPD_DEVICE);
    if (IS_ERR(thread)) { 
        err = PTR_ERR(thread);
        TPD_DMESG(TPD_DEVICE " failed to create kernel thread: %d\n", err);
    }
    
    tpd_load_status = 1;
    
    mt65xx_eint_set_sens(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_SENSITIVE);
    mt65xx_eint_set_hw_debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
    mt65xx_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, CUST_EINT_TOUCH_PANEL_POLARITY, tpd_eint_interrupt_handler, 1);
    mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
    
    printk("MediaTek touch panel i2c probe success\n");
    
    return 0;
}
static unsigned int lcm_compare_id()
{
  unsigned int id = 0;
  unsigned int lcd_id=0;
  unsigned char buffer[4];
  unsigned int data_array[16];
  SET_RESET_PIN(1);  //TE:should reset LCM firstly
  MDELAY(1);
  SET_RESET_PIN(0);
  MDELAY(20);
  SET_RESET_PIN(1);
  MDELAY(120);
  #ifdef BUILD_LK
    DSI_clk_HS_mode(1);
  #endif
  MDELAY(10);
  #ifdef BUILD_LK
    DSI_clk_HS_mode(0);
  #endif
 //data_array[0]=0x00063902;
 //data_array[1]=0x52AA55F0; // SET password
 //data_array[2]=0x00000108; 
 push_table(lcm_read_lcm_compare_id, sizeof(lcm_read_lcm_compare_id) / sizeof(struct LCM_setting_table), 1);
 read_reg_v2(0xF4, buffer, 3);
 
 id = buffer[0]; //we only need ID 0x00 0x80 0x00
 #ifndef BUILD_LK
   printk("<6>zhangjun [lcm_compare_id %x,%x,%x\n",buffer[0],buffer[1],buffer[2]);
 #else
   printf("<6>zhangjun [lcm_compare_id %x,%x,%x\n",buffer[0],buffer[1],buffer[2]);
 #endif
	if(0x79!= id)
		return 0;

	mt_set_gpio_mode(GPIO_LCM_ID, GPIO_LCM_ID_M_GPIO);
	mt_set_gpio_dir(GPIO_LCM_ID, GPIO_DIR_IN);		
	mt_set_gpio_pull_enable(GPIO_LCM_ID,GPIO_PULL_DISABLE);
	mt_set_gpio_pull_select(GPIO_LCM_ID,GPIO_PULL_DOWN);
	MDELAY(1);
	lcd_id =  mt_get_gpio_in(GPIO_LCM_ID);
#ifndef BUILD_LK
	printk("<6>vendor jingtai [lcm_compare_id] lcd_id =%x\n",lcd_id);
#else
	printf("<6>vendor jingtai [lcm_compare_id] lcd_id =%x\n",lcd_id);
#endif

	if(lcd_id)
		return 0;
	else
		return 1;

}
static void reset_lcd_module(unsigned char reset)
{
	mt_set_gpio_mode(GPIO_LCM_RST, GPIO_LCM_RST_M_GPIO);
	mt_set_gpio_pull_enable(GPIO_LCM_RST, GPIO_PULL_ENABLE);
	mt_set_gpio_dir(GPIO_LCM_RST, GPIO_DIR_OUT);

   if(reset){
   	mt_set_gpio_out(GPIO_LCM_RST, GPIO_OUT_ZERO);
      MDELAY(50);
   }else{
   	mt_set_gpio_out(GPIO_LCM_RST, GPIO_OUT_ONE);
   }
}
Esempio n. 23
0
static u32 ResetI2S(u32 pin, u32 mode)          //set I2S to GPIO and pull down
{
	u32 temp = -1;
	temp = mt_get_gpio_mode(pin);
	printk("MHL GPIO Mode 3 is %d", temp);
	if(temp == mode)
	{
		temp = mt_set_gpio_mode(pin, GPIO_MODE_00);
		printk("MHL GPIO Mode 4 is %d", temp);
		temp = mt_set_gpio_pull_enable(pin, GPIO_PULL_DISABLE);
	}
	return temp;
}
Esempio n. 24
0
static void mtk_enable_pmic_otg_mode(void)
{
	int val;

	printk("set pmic power on, begin\n");
	mt_set_gpio_mode(GPIO_OTG_DRVVBUS_PIN, GPIO_MODE_GPIO);
	mt_set_gpio_pull_select(GPIO_OTG_DRVVBUS_PIN, GPIO_PULL_DOWN);
	mt_set_gpio_pull_enable(GPIO_OTG_DRVVBUS_PIN, GPIO_PULL_ENABLE);

	/* save PMIC related registers */
	printk("set pmic power on, begin2\n");
	pmic_save_regs();

	printk("set pmic power on, begin3\n");
	pmic_config_interface(0x8D22, 0x1, 0x1, 12);
	pmic_config_interface(0x8D14, 0x1, 0x1, 12);
	pmic_config_interface(0x803C, 0x3, 0x3, 0);
	pmic_config_interface(0x803C, 0x2, 0x3, 2);
	pmic_config_interface(0x803C, 0x1, 0x1, 14);
	pmic_config_interface(0x8036, 0x0, 0x0, 0);
	pmic_config_interface(0x8D24, 0xf, 0xf, 12);
	pmic_config_interface(0x8D16, 0x1, 0x1, 15);
	pmic_config_interface(0x803A, 0x1, 0x1, 6);
	pmic_config_interface(0x8046, 0x00A0, 0xffff, 0);
	pmic_config_interface(0x803E, 0x1, 0x1, 2);
	pmic_config_interface(0x803E, 0x1, 0x1, 3);
	pmic_config_interface(0x803E, 0x3, 0x3, 8);
	pmic_config_interface(0x803E, 0x0, 0x1, 10);
	pmic_config_interface(0x8044, 0x3, 0x3, 0);
	pmic_config_interface(0x8044, 0x3, 0x7, 8);
	pmic_config_interface(0x8044, 0x1, 0x1, 11);

	pmic_config_interface(0x809C, 0x8000, 0xFFFF, 0);

	printk("set pmic power on, begin4\n");
	val = 0;
	while (val == 0) {
		pmic_read_interface(0x809A, &val, 0x1, 15);
	}

	printk("set pmic power on, begin5\n");
	pmic_config_interface(0x8084, 0x1, 0x1, 0);
	mdelay(50);

	val = 0;
	while (val == 0) {
		pmic_read_interface(0x8060, &val, 0x1, 14);
	}

	printk("set pmic power on, done\n");
}
Esempio n. 25
0
static int mt5931_power_on(void) 
{ 

	int ret = 0;
    if(_mt5931_powered_on == 0) 
	{ 
        _mt5931_powered_on = 1;         
        printk(KERN_INFO "[mt5931_power_on] config EINT_PIN\n"); 
            
		ret = gpio_request(GPIO_MT5931_PMU_EN, "MT5931_PMU_EN");
		if (ret) 
		{          
			printk("failed to request MT5931_PMU_EN %d!\n", GPIO_MT5931_PMU_EN);          
			return -1;	      
		}         //set the gpio to output mode, low val  
		
            
		ret = gpio_request(GPIO_MT5931_RST, "MT5931_RST");  
		if (ret) 
		{          
			printk("failed to request MT5931_RST %d!\n", GPIO_MT5931_RST);          
			return -1;	      
		} 
              

	#if 0
		mt_wifi_disable_irq(); 
		mt_set_gpio_mode(GPIO_WIFI_EINT_PIN, GPIO_WIFI_EINT_PIN_M_EINT); /* EINT5 */ 
		mt_set_gpio_pull_enable(GPIO_WIFI_PMU_EN_PIN, GPIO_PULL_DISABLE);
		if(0 != sw_gpio_eint_set_enable(gpio_eint, 0))
			printk("set enable status failed\n");
				sw_gpio_setcfg(gpio_eint,6);//EINT6
		sw_gpio_setpull(gpio_dis,0);//pull disabled
	#endif

	
		
		gpio_direction_output(GPIO_MT5931_RST, 0);
		gpio_direction_output(GPIO_MT5931_PMU_EN, 0);
		msleep(MT5931_OFF_TIME);
		gpio_direction_output(GPIO_MT5931_PMU_EN, 1);
		msleep(MT5931_PMU_EN_TIME);
		gpio_direction_output(GPIO_MT5931_RST, 1);
		msleep(MT5931_RST_TIME);


    }else{
    	printk("mt5931 unmatched power on\n");
    } 
	return 0; 
}
Esempio n. 26
0
void cm_gpio_setup(void)
{
    EMD_MSG_INF("chr","cm_gpio_setup 1\n");
    atomic_set(&traffic_on, 0);
    atomic_set(&allow_wk_md, 0);
    // MD wake up AP pin
    mt_set_gpio_pull_enable(GPIO_EXT_MD_WK_AP, 1);
    mt_set_gpio_pull_select(GPIO_EXT_MD_WK_AP, 0);
    mt_set_gpio_dir(GPIO_EXT_MD_WK_AP, 0);
    mt_set_gpio_mode(GPIO_EXT_MD_WK_AP, GPIO_EXT_MD_WK_AP_M_EINT); 
    EMD_MSG_INF("chr","cm_gpio_setup:GPIO_EXT_MD_WK_AP(%x)=%d\n",GPIO_EXT_MD_WK_AP,mt_get_gpio_out(GPIO_EXT_MD_WK_AP));
    // AP wake up MD pin
    mt_set_gpio_mode(GPIO_EXT_AP_WK_MD, GPIO_EXT_AP_WK_MD_M_GPIO); // GPIO Mode
    mt_set_gpio_dir(GPIO_EXT_AP_WK_MD, 1);
    mt_set_gpio_out(GPIO_EXT_AP_WK_MD, 0);
	EMD_MSG_INF("chr","cm_gpio_setup:GPIO_EXT_AP_WK_MD(%x)=%d\n",GPIO_EXT_AP_WK_MD,mt_get_gpio_out(GPIO_EXT_AP_WK_MD));
    // Rest MD pin
    mt_set_gpio_mode(GPIO_EXT_MD_RST, GPIO_EXT_MD_RST_M_GPIO); //GPIO202 is reset pin
    mt_set_gpio_pull_enable(GPIO_EXT_MD_RST, 0);
    mt_set_gpio_pull_select(GPIO_EXT_MD_RST, 1);
    cm_relese_rst_signal();
    EMD_MSG_INF("chr","cm_gpio_setup 4\n");
	EMD_MSG_INF("chr","cm_gpio_setup:GPIO_EXT_MD_RST(%x)=%d\n",GPIO_EXT_MD_RST,mt_get_gpio_out(GPIO_EXT_MD_RST));
    // MD power key pin
    mt_set_gpio_mode(GPIO_EXT_MD_PWR_KEY, GPIO_EXT_MD_PWR_KEY_M_GPIO); //GPIO 200 is power key
    mt_set_gpio_pull_enable(GPIO_EXT_MD_PWR_KEY, 0);
    mt_set_gpio_dir(GPIO_EXT_MD_PWR_KEY, 1);
    mt_set_gpio_out(GPIO_EXT_MD_PWR_KEY, 0);
	EMD_MSG_INF("chr","cm_gpio_setup:GPIO_EXT_MD_PWR_KEY(%x)=%d\n",GPIO_EXT_MD_PWR_KEY,mt_get_gpio_out(GPIO_EXT_MD_PWR_KEY));
    // MD WDT irq pin
    mt_set_gpio_pull_enable(GPIO_EXT_MD_WD, 1);
    mt_set_gpio_pull_select(GPIO_EXT_MD_WD, 1);
    mt_set_gpio_dir(GPIO_EXT_MD_WD, 0);
    mt_set_gpio_mode(GPIO_EXT_MD_WD, GPIO_EXT_MD_WD_M_EINT); // EINT168
    EMD_MSG_INF("chr","cm_gpio_setup GPIO_EXT_MD_WD(%x)(in)=%d\n",GPIO_EXT_MD_WD,mt_get_gpio_in(GPIO_EXT_MD_WD));

    // MD Exception irq pin
    mt_set_gpio_pull_enable(GPIO_EXT_MD_EXP, 1);
    mt_set_gpio_pull_select(GPIO_EXT_MD_EXP, 1);
    mt_set_gpio_dir(GPIO_EXT_MD_EXP, 0);
    mt_set_gpio_mode(GPIO_EXT_MD_EXP, GPIO_EXT_MD_EXP_M_EINT); //     
    EMD_MSG_INF("chr","cm_gpio_setup GPIO_EXT_MD_EXP(%x)(in)=%d\n",GPIO_EXT_MD_EXP,mt_get_gpio_in(GPIO_EXT_MD_EXP));
#ifndef  GPIO_EXT_USB_SW2     
    mt_set_gpio_mode(GPIO_EXT_MD_META, GPIO_EXT_MD_META_M_GPIO); 
    mt_set_gpio_dir(GPIO_EXT_MD_META, 1);// Using input floating    
    mt_set_gpio_out(GPIO_EXT_MD_META, 0);// Default @ reset state
    EMD_MSG_INF("chr","cm_gpio_setup:phone GPIO_EXT_MD_META(%x)=%d\n",GPIO_EXT_MD_META,mt_get_gpio_out(GPIO_EXT_MD_META));
#else
    mt_set_gpio_pull_enable(GPIO_EXT_MD_DUMP, 1);
    mt_set_gpio_pull_select(GPIO_EXT_MD_DUMP, 0); 
    mt_set_gpio_dir(GPIO_EXT_MD_DUMP, 1);  
    mt_set_gpio_mode(GPIO_EXT_MD_DUMP, GPIO_EXT_MD_DUMP_M_GPIO);
    EMD_MSG_INF("chr","cm_gpio_setup:evb GPIO_EXT_MD_DUMP(%x)(in)=(%d)\n",GPIO_EXT_MD_DUMP,mt_get_gpio_in(GPIO_EXT_MD_DUMP));
#endif

    // Configure eint
    eint_var_init();
}
Esempio n. 27
0
static int tpd_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) {
    int err;
    i2c_client = client;
    i2c_rs_client = client;
    i2c_rs_client->addr = i2c_rs_client->addr & I2C_MASK_FLAG | I2C_WR_FLAG | I2C_RS_FLAG;
    
    printk("[mtk-tpd] i2c device probe\n");
    
    /* added in android 2.2, for configuring EINT2 to GPIO mode */
    mt_set_gpio_mode(GPIO61, 0x00);
    mt_set_gpio_pull_enable(GPIO61, GPIO_PULL_ENABLE);
    mt_set_gpio_pull_select(GPIO61,GPIO_PULL_UP);
    mt_set_gpio_dir(GPIO61, GPIO_DIR_OUT);
    mt_set_gpio_out(GPIO61, GPIO_OUT_ZERO);
    
    hwPowerDown(TPD_POWER_SOURCE,"TP");
    hwPowerOn(TPD_POWER_SOURCE,VOL_3300,"TP");
    msleep(20);
    
    thread = kthread_run(touch_event_handler, 0, TPD_DEVICE);
    if (IS_ERR(thread)) { 
        err = PTR_ERR(thread);
        TPD_DMESG(TPD_DEVICE " failed to create kernel thread: %d\n", err);
    }
        
    /* added in android 2.2, for configuring EINT2 to EINT mode */
    mt_set_gpio_mode(GPIO61, 0x01);
    mt_set_gpio_pull_enable(GPIO61, GPIO_PULL_ENABLE);
    mt_set_gpio_pull_select(GPIO61, GPIO_PULL_UP);
    
    MT6516_EINT_Set_Sensitivity(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_SENSITIVE);
    MT6516_EINT_Set_HW_Debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
    MT6516_EINT_Registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, 
                             CUST_EINT_TOUCH_PANEL_POLARITY, tpd_eint_interrupt_handler, 1);
    MT6516_EINTIRQUnmask(CUST_EINT_TOUCH_PANEL_NUM);
   
    return 0;
}
Esempio n. 28
0
static void hall_init_hw(void)
{
	mt_set_gpio_mode(GPIO_MHALL_EINT_PIN, GPIO_MHALL_EINT_PIN_M_EINT);
	mt_set_gpio_dir(GPIO_MHALL_EINT_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_enable(GPIO_MHALL_EINT_PIN, GPIO_PULL_DISABLE); 
	mt_set_gpio_ies(GPIO_MHALL_EINT_PIN, GPIO_IES_ENABLE);

    	mt65xx_eint_set_sens(CUST_EINT_MHALL_NUM, CUST_EINT_MHALL_SENSITIVE);
	mt65xx_eint_set_polarity(CUST_EINT_MHALL_NUM, CUST_EINT_MHALL_POLARITY);
	mt65xx_eint_set_hw_debounce(CUST_EINT_MHALL_NUM, CUST_EINT_MHALL_DEBOUNCE_CN);
	mt65xx_eint_registration(CUST_EINT_MHALL_NUM, CUST_EINT_MHALL_DEBOUNCE_EN, CUST_EINT_MHALL_POLARITY, hall_cover_eint_handler, 0);
	mt65xx_eint_unmask(CUST_EINT_MHALL_NUM);  

}
Esempio n. 29
0
/*
#define GPIO_SPEAKER_EN_PIN GPIO42
#define GPIO_AUD_EXTHP_EN_PIN GPIO20
#define GPIO_AUD_EXTHP_GAIN_PIN GPIO15
*/
bool Speaker_Init(void)
{
    PRINTK("+Speaker_Init Success");
    mt_set_gpio_mode(GPIO_SPEAKER_EN_PIN,GPIO_MODE_00);  // gpio mode
    mt_set_gpio_pull_enable(GPIO_SPEAKER_EN_PIN,GPIO_PULL_ENABLE);
    mt_set_gpio_dir(GPIO_SPEAKER_EN_PIN,GPIO_DIR_OUT); // output
    mt_set_gpio_out(GPIO_SPEAKER_EN_PIN,GPIO_OUT_ZERO); // high
#if 0 //ckt liutao for no need to use this GPIO
    mt_set_gpio_mode(GPIO_AUD_EXTHP_EN_PIN,GPIO_MODE_00);  // gpio mode
    mt_set_gpio_mode(GPIO_AUD_EXTHP_GAIN_PIN,GPIO_MODE_00);  // gpio mode
#endif
    PRINTK("-Speaker_Init Success");
    return true;
}
static int eamp_init()
{
	int result = 0;
	result = mt_set_gpio_mode(GPIO_HP_AMP_EN, GPIO_HP_AMP_EN_M_GPIO);
   	EAMP_PRINTK("GPIO_HP_AMP_EN GPIO Status : mt_set_gpio_mode %d\n", result);
   	result = mt_set_gpio_pull_enable(GPIO_HP_AMP_EN, GPIO_PULL_DISABLE);
   	EAMP_PRINTK("GPIO_HP_AMP_EN GPIO Status : mt_set_gpio_pull_enable %d\n", result);
   	result = mt_set_gpio_dir(GPIO_HP_AMP_EN, GPIO_DIR_OUT);
   	EAMP_PRINTK("GPIO_HP_AMP_EN GPIO Status : mt_set_gpio_dir %d\n", result);
   	result = mt_set_gpio_out(GPIO_HP_AMP_EN, GPIO_OUT_ONE);
   	EAMP_PRINTK("GPIO_HP_AMP_EN GPIO Status : mt_set_gpio_out %d, %d\n", result, mt_get_gpio_out(GPIO_HP_AMP_EN));
   	result = mt_set_gpio_mode(GPIO_SPK_AMP_EN, GPIO_SPK_AMP_EN_M_GPIO);
   	EAMP_PRINTK("GPIO_SPK_AMP_EN GPIO Status : mt_set_gpio_mode %d\n", result);
   	result = mt_set_gpio_pull_enable(GPIO_SPK_AMP_EN, GPIO_PULL_DISABLE);
   	EAMP_PRINTK("GPIO_SPK_AMP_EN GPIO Status : mt_set_gpio_pull_enable %d\n", result);
   	result = mt_set_gpio_dir(GPIO_SPK_AMP_EN, GPIO_DIR_OUT);
   	EAMP_PRINTK("GPIO_SPK_AMP_EN GPIO Status : mt_set_gpio_dir %d\n", result);
   	result = mt_set_gpio_out(GPIO_SPK_AMP_EN, GPIO_OUT_ONE);
   	EAMP_PRINTK("GPIO_SPK_AMP_EN GPIO Status : mt_set_gpio_out %d, %d\n", result, mt_get_gpio_out(GPIO_SPK_AMP_EN));
   	eamp_poweron();
   	eamp_powerdown();
   	return 0;
}