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);
}
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;
}
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;
}
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;
}
//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);
}
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;
}
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);
}
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;
}
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;
}
//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;
}
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);
}
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;
}
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);
}
}
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;
}
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");
}
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;
}
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();
}
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;
}
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);
}
/*
#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;
}