static void txc_set_enable(struct txc_data *txc, int enable)
{
struct i2c_client *client = txc->client;
int ret;
mutex_lock(&txc->enable_lock);
if (enable) {
mt_eint_mask(CUST_EINT_INTI_INT_NUM);
pa12201001_set_ps_mode(client);
#if defined(PA12_FAST_CAL)
pa122_run_fast_calibration(client);
#endif
} else {
input_report_abs(txc->input_dev, ABS_DISTANCE, PS_UNKONW);
input_sync(txc->input_dev);
}
ret = pa12201001_enable_ps(client, enable);
if (enable) {
mdelay(50);
mt_eint_unmask(CUST_EINT_INTI_INT_NUM);
}
if (ret < 0) {
mutex_unlock(&txc->enable_lock);
APS_ERR("pa12201001_enable_ps function err\n");
return ret;
}
mutex_unlock(&txc->enable_lock);
}
static void swtp_eint_handler(void)
{
unsigned int rfcable_enable;
mt_eint_mask(SWTP_EINT_NUM);
if(swtp_eint_state == EINT_PIN_PLUG_IN )
{
if (SWTP_EINT_TYPE == CUST_EINTF_TRIGGER_HIGH){
mt_eint_set_polarity(SWTP_EINT_NUM, (1));
}else{
mt_eint_set_polarity(SWTP_EINT_NUM, (0));
}
swtp_eint_state = EINT_PIN_PLUG_OUT;
rfcable_enable = SWTP_MODE_OFF;
}
else
{
if (SWTP_EINT_TYPE == CUST_EINTF_TRIGGER_HIGH){
mt_eint_set_polarity(SWTP_EINT_NUM, !(1));
}else{
mt_eint_set_polarity(SWTP_EINT_NUM, !(0));
}
swtp_eint_state = EINT_PIN_PLUG_IN;
rfcable_enable = SWTP_MODE_ON;
}
printk("[swtp]: rfcable_enable: %d\n", rfcable_enable);
swtp_set_mode_unlocked(SWTP_CTRL_SUPER_SET, rfcable_enable);
mt_eint_unmask(SWTP_EINT_NUM);
}
/************************** HAL To Platform****************************************/
void Mask_MHL_Intr(void)
{
#ifdef CUST_EINT_MHL_NUM
mt_eint_mask(CUST_EINT_MHL_NUM);
#endif
return ;
}
static void hw_register_irq(void)
{
mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, EINTF_TRIGGER_LOW, tpd_eint_handler, 0);
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
return ;
}
static void mtk_wcn_cmb_sdio_request_eirq(sdio_irq_handler_t irq_handler, void *data)
{
#if CONFIG_EINT_DEVICE_TREE
struct device_node *node;
u32 ints[2] = {0,0};
int ret = -EINVAL;
#endif
printk( KERN_INFO "enter %s\n", __func__);
mtk_wcn_sdio_irq_flag_set (0);
mtk_wcn_cmb_sdio_eirq_data = data;
mtk_wcn_cmb_sdio_eirq_handler = irq_handler;
#if 1
#if CONFIG_EINT_DEVICE_TREE
node = of_find_compatible_node(NULL, NULL, "mediatek, WIFI-eint");
if(node) {
of_property_read_u32_array(node, "debounce", ints, ARRAY_SIZE(ints));
mt_gpio_set_debounce(ints[0], ints[1]);
wifi_irq = irq_of_parse_and_map(node, 0);
ret = request_irq(wifi_irq, mtk_wcn_cmb_sdio_eirq_handler_stub, IRQF_TRIGGER_NONE,"WIFI-eint", NULL);
printk(KERN_DEBUG "WIFI EINT irq %d !!\n",wifi_irq);
atomic_set(&wifi_irq_flag, 0);/*default: irq enable*/
if(ret)
printk(KERN_ERR "WIFI EINT IRQ LINE NOT AVAILABLE!!\n");
else {
mtk_wcn_cmb_sdio_disable_eirq();/*not ,chip state is power off*/
}
}
else
printk(KERN_ERR "[%s] can't find wifi eint compatible node\n",__func__);
#else
mt_eint_registration(mtk_wcn_cmb_sdio_eint_num,
CUST_EINT_WIFI_TYPE,
mtk_wcn_cmb_sdio_eirq_handler_stub,
0);
#endif
#else
{
int i_ret = 0;
i_ret = request_irq(mtk_wcn_cmb_sdio_eint_num,
(irq_handler_t)mtk_wcn_cmb_sdio_eirq_handler_stub,
IRQF_TRIGGER_LOW,
"SDIO_EXT_IRQ",
NULL);
if (i_ret)
printk( KERN_ERR "request_irq for SDIO ext IRQ failed, i_ret(%d)\n", i_ret);
else
printk( KERN_ERR "request_irq for SDIO ext IRQ succeed, i_ret(%d)\n", i_ret);
}
#endif
#if CONFIG_EINT_DEVICE_TREE
#else
mt_eint_mask(mtk_wcn_cmb_sdio_eint_num);/*CUST_EINT_WIFI_NUM */
#endif
printk(KERN_INFO "exit %s\n", __func__);
}
/* platform device functions */
static void tpd_suspend(struct early_suspend *h) {
char sleep[2] = {0x07,0x01};
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
//MT6516_IRQMask(MT6516_TOUCH_IRQ_LINE);
i2c_master_send(i2c_client,sleep,2);
// workaround: power down tp will also pull down ic2 bus, affect other drivers
// so not pull down it.
//hwPowerDown(TPD_POWER_SOURCE,"TP");
}
void inno_irq_release(void)
{
mt_eint_mask(CUST_EINT_CMMB_NUM);
mt_set_gpio_pull_enable(GPIO_CMMB_EINT_PIN, 1);
mt_set_gpio_pull_select(GPIO_CMMB_EINT_PIN, 0);
mt_set_gpio_mode(GPIO_CMMB_EINT_PIN, GPIO_CMMB_EINT_PIN_M_GPIO); //set to eint MODE for enable eint function
inno_msg("CMMB GPIO EINT PIN mode:num:%d, %d, dir:%d,pullen:%d,pullup%d",GPIO_CMMB_EINT_PIN,mt_get_gpio_mode(GPIO_CMMB_EINT_PIN),
mt_get_gpio_dir(GPIO_CMMB_EINT_PIN),mt_get_gpio_pull_enable(GPIO_CMMB_EINT_PIN),mt_get_gpio_pull_select(GPIO_CMMB_EINT_PIN));
// mt_set_gpio_dir(GPIO_CMMB_EINT_PIN, GPIO_DIR_OUT); // set to input avoid of leak power
}
void c2k_gpio_irq_mask(int gpio)
{
int irq;
irq = c2k_gpio_to_irq(gpio);
if(irq < 0){
return ;
}
mt_eint_mask(irq);
}
void switch_int_to_host_and_mask(struct musb *musb)
{
#ifdef ID_PIN_USE_EX_EINT
mt_eint_set_polarity(IDDIG_EINT_PIN, MT_EINT_POL_NEG);
mt_eint_mask(IDDIG_EINT_PIN);
#else
musb_writel(musb->mregs,USB_L1INTM,(~IDDIG_INT_STATUS)&musb_readl(musb->mregs,USB_L1INTM)); //mask before change polarity
mb();
musb_writel(musb->mregs,USB_L1INTP,IDDIG_INT_STATUS);
#endif
DBG(0,"swtich_int_to_host_and_mask is done\n");
}
static int hw_irq_disable(void)
{
int retval = -1 ;
info_printk("TPD enter sleep start\n");
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
/* Set EINT PIN to Input*/
retval = mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_GPIO);
retval |= mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);
return retval;
}
//void tpd_suspend(struct i2c_client *client, pm_message_t message)
static void tpd_suspend( struct early_suspend *h )
{
int ret = 0;
unsigned char Wrbuf[2] = {0x14, 0x02};
tpd_halt = 1;
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
i2c_client->addr = ( i2c_client->addr & I2C_MASK_FLAG ) | I2C_ENEXT_FLAG;
ret = i2c_master_send(i2c_client, Wrbuf, 2);
if(ret != sizeof(Wrbuf))
{
TPD_DEBUG("[mtk-tpd] i2c write communcate error during suspend: 0x%x\n", ret);
}
}
void c2k_gpio_irq_mask(int gpio)
{
int irq;
irq = c2k_gpio_to_irq(gpio);
if (irq < 0)
return;
#if defined(CONFIG_MTK_LEGACY)
mt_eint_mask(irq);
#else
disable_irq_nosync(irq);
#endif
}
void mtk_wcn_cmb_sdio_request_eirq(sdio_irq_handler_t irq_handler, void *data)
{
mtk_wcn_sdio_irq_flag_set (0);
mtk_wcn_cmb_sdio_eirq_data = data;
mtk_wcn_cmb_sdio_eirq_handler = irq_handler;
//mt_eint_set_sens(mtk_wcn_cmb_sdio_eint_num, CUST_EINT_WIFI_SENSITIVE); /*CUST_EINT_WIFI_NUM */
//mt_eint_set_hw_debounce(mtk_wcn_cmb_sdio_eint_num, CUST_EINT_WIFI_DEBOUNCE_CN); /*CUST_EINT_WIFI_NUM */
mt_set_gpio_pull_enable(mtk_wcn_cmb_sdio_eint_pin, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(mtk_wcn_cmb_sdio_eint_pin, GPIO_PULL_UP);
mt_eint_registration(mtk_wcn_cmb_sdio_eint_num,
CUST_EINT_WIFI_POLARITY,
mtk_wcn_cmb_sdio_eirq_handler_stub,
0);
mt_eint_mask(mtk_wcn_cmb_sdio_eint_num);/*CUST_EINT_WIFI_NUM */
}
static void mtk_wcn_cmb_sdio_request_eirq(sdio_irq_handler_t irq_handler, void *data)
{
mtk_wcn_sdio_irq_flag_set (0);
mtk_wcn_cmb_sdio_eirq_data = data;
mtk_wcn_cmb_sdio_eirq_handler = irq_handler;
#if CUST_EINT_WIFI_DEBOUNCE_EN
mt_eint_set_hw_debounce(mtk_wcn_cmb_sdio_eint_num, CUST_EINT_WIFI_DEBOUNCE_CN); /*CUST_EINT_WIFI_NUM */
#endif
mt_set_gpio_pull_enable(mtk_wcn_cmb_sdio_eint_pin, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(mtk_wcn_cmb_sdio_eint_pin, GPIO_PULL_UP);
mt_eint_registration(mtk_wcn_cmb_sdio_eint_num/*CUST_EINT_WIFI_NUM */,
CUST_EINT_WIFI_TYPE,
mtk_wcn_cmb_sdio_eirq_handler_stub,
0);
mt_eint_mask(mtk_wcn_cmb_sdio_eint_num);/*CUST_EINT_WIFI_NUM */
}
static void mtk_wcn_cmb_sdio_disable_eirq(void)
{
#if CONFIG_EINT_DEVICE_TREE
if(atomic_read(&wifi_irq_flag))
{
printk(KERN_DEBUG "wifi eint has been disabled!\n");;
}
else
{
disable_irq_nosync(wifi_irq);
atomic_inc(&wifi_irq_flag);
//printk(KERN_DEBUG "disable WIFI EINT irq %d !!\n",wifi_irq);
}
#else
mt_eint_mask(mtk_wcn_cmb_sdio_eint_num); /* CUST_EINT_WIFI_NUM */
#endif
}
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;
}
void cm_disable_ext_md_exp_irq(void)
{
#ifdef CONFIG_OF
unsigned long flags;
#endif
EMD_MSG_INF("chr","cm_disable_ext_md_exp_irq,CUST_EINT_DT_EXT_MD_EXP_NUM(%d)\n",ext_md_exp_eint.irq_id);
#ifdef CONFIG_OF
spin_lock_irqsave(&ext_md_exp_eint.lock, flags);
if(ext_md_exp_eint.irq_reg) {
if(ext_md_exp_eint.irq_en_cnt>0) {
disable_irq_nosync(ext_md_exp_eint.irq_id);
ext_md_exp_eint.irq_en_cnt = 0;
}
}
spin_unlock_irqrestore(&ext_md_exp_eint.lock, flags);
#else
mt_eint_mask(ext_md_exp_eint.irq_id);
#endif
}
/* switch touch panel into deep sleep mode */
void _tpd_switch_sleep_mode(void) {
char sleep[2] = {0x07,0x00};
if (!tpd_status) {
TPD_DMESG("do not need to switch tpd into deep sleep m mode\n");
return;
}
TPD_DMESG("switch tpd into deep sleep mode\n");
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
//MT6516_IRQMask(MT6516_TOUCH_IRQ_LINE);
i2c_master_send(i2c_client,sleep,2);
tpd_status = 0;
// workaround: power down tp will also pull down ic2 bus, affect other drivers
// so not pull down it.
//hwPowerDown(TPD_POWER_SOURCE,"TP");
}
static void gpio_keys_gpio_delayed_work_func(struct work_struct *work)
{
struct gpio_button_data *bdata =
container_of(work, struct gpio_button_data, delayed_work.work);
unsigned char gpio_in = 0, pol = FALLING;
mutex_lock(&bdata->key_mutex);
gpio_in = mt_get_gpio_in(bdata->button->gpio);
pol = mt_eint_get_polarity(bdata->button->irq);
#ifdef KEYPAD_DEBUG
printk("[Hall] %s: %s %s, gpio_in:%d pol:%s\n",
__func__,
bdata->button->desc,
(atomic_read(&bdata->key_pressed) == PRESSED) ? "Press" : "Release",
gpio_in,
pol == RISING ? "Rise" : "Fall");
#endif
if((atomic_read(&bdata->key_pressed) == PRESSED) && (gpio_in == 1) && (pol == RISING)) {
mt_eint_mask(bdata->button->irq);
mt_eint_set_polarity(bdata->button->irq, FALLING);
atomic_set(&bdata->key_pressed, RELEASED);
input_report_key(bdata->input, bdata->button->code, RELEASED);
input_sync(bdata->input);
mt_eint_unmask(bdata->button->irq);
#ifdef MEIZU_TP_NOTIFIER
if(bdata->irq == M7X_HALL_IRQ_NUM)
gpio_key_notify(atomic_read(&bdata->key_pressed),NULL);
#endif
#ifdef KEYPAD_DEBUG
printk("[Hall] %s: Force Release!!\n", __func__);
#endif
}
mutex_unlock(&bdata->key_mutex);
}
void tpd_re_init(void)
{
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
#ifdef TPD_POWER_SOURCE_CUSTOM
hwPowerOn(TPD_POWER_SOURCE_CUSTOM, VOL_2800, "TP");
#else
hwPowerOn(MT65XX_POWER_LDO_VGP2, VOL_2800, "TP");
#endif
hwPowerOn(MT65XX_POWER_LDO_VGP1, VOL_2800, "TP");
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(5);
printk(" =============shockley==========fts ic reset\n");
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_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);
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
}
/*******************************************************
Function:
Goodix tool write function.
Input:
standard proc write function param.
Output:
Return write length.
********************************************************/
static ssize_t goodix_tool_write(struct file *filp, const char __user *buff, size_t len, loff_t *off)
{
s32 ret = 0;
GTP_DEBUG_FUNC();
GTP_DEBUG_ARRAY((u8 *)buff, len);
if(gtp_resetting == 1)
{
//GTP_ERROR("[Write]tpd_halt =1 fail!");
return FAIL;
}
ret = copy_from_user(&cmd_head, buff, CMD_HEAD_LENGTH);
if (ret)
{
GTP_ERROR("copy_from_user failed.");
}
GTP_DEBUG("wr :0x%02x.", cmd_head.wr);
if (1 == cmd_head.wr)
{
// copy_from_user(&cmd_head.data[cmd_head.addr_len], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
ret = copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if (ret)
{
GTP_ERROR("copy_from_user failed.");
}
memcpy(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len], cmd_head.addr, cmd_head.addr_len);
GTP_DEBUG_ARRAY(cmd_head.data, cmd_head.data_len + cmd_head.addr_len);
GTP_DEBUG_ARRAY((u8 *)&buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if (1 == cmd_head.flag)
{
if (FAIL == comfirm())
{
GTP_ERROR("[WRITE]Comfirm fail!");
return FAIL;
}
}
else if (2 == cmd_head.flag)
{
//Need interrupt!
}
if (tool_i2c_write(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len],
cmd_head.data_len + cmd_head.addr_len) <= 0)
{
GTP_ERROR("[WRITE]Write data failed!");
return FAIL;
}
GTP_DEBUG_ARRAY(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len], cmd_head.data_len + cmd_head.addr_len);
if (cmd_head.delay)
{
msleep(cmd_head.delay);
}
return cmd_head.data_len + CMD_HEAD_LENGTH;
}
else if (3 == cmd_head.wr) //Write ic type
{
memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
register_i2c_func();
return cmd_head.data_len + CMD_HEAD_LENGTH;
}
else if (5 == cmd_head.wr)
{
//memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
return cmd_head.data_len + CMD_HEAD_LENGTH;
}
else if (7 == cmd_head.wr)//disable irq!
{
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
#if GTP_ESD_PROTECT
gtp_esd_switch(i2c_client_point, SWITCH_OFF);
#endif
return CMD_HEAD_LENGTH;
}
else if (9 == cmd_head.wr) //enable irq!
{
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
#if GTP_ESD_PROTECT
gtp_esd_switch(i2c_client_point, SWITCH_ON);
#endif
return CMD_HEAD_LENGTH;
}
else if (17 == cmd_head.wr)
{
ret = copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if (ret)
{
GTP_DEBUG("copy_from_user failed.");
}
if (cmd_head.data[GTP_ADDR_LENGTH])
{
GTP_DEBUG("gtp enter rawdiff.");
gtp_rawdiff_mode = true;
}
else
{
gtp_rawdiff_mode = false;
GTP_DEBUG("gtp leave rawdiff.");
}
return CMD_HEAD_LENGTH;
}
#ifdef UPDATE_FUNCTIONS
else if (11 == cmd_head.wr) //Enter update mode!
{
if (FAIL == gup_enter_update_mode(gt_client))
{
return FAIL;
}
}
else if (13 == cmd_head.wr)//Leave update mode!
{
gup_leave_update_mode();
}
else if (15 == cmd_head.wr) //Update firmware!
{
show_len = 0;
total_len = 0;
memset(cmd_head.data, 0, cmd_head.data_len + 1);
memcpy(cmd_head.data, &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
GTP_DEBUG("update firmware, filename: %s", cmd_head.data);
if (FAIL == gup_update_proc((void *)cmd_head.data))
{
return FAIL;
}
}
#endif
else if (19 == cmd_head.wr) //load subsystem
{
ret = copy_from_user(&cmd_head.data[0], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if(0 == cmd_head.data[0])
{
if (FAIL == gup_load_calibration1())
{
return FAIL;
}
}
else if(1 == cmd_head.data[0])
{
if (FAIL == gup_load_calibration2())
{
return FAIL;
}
}
else if(2 == cmd_head.data[0])
{
if (FAIL == gup_recovery_calibration0())
{
return FAIL;
}
}
else if(3 == cmd_head.data[0])
{
if (FAIL == gup_load_calibration0(NULL))
{
return FAIL;
}
}
}
#if HOTKNOT_BLOCK_RW
else if (21 == cmd_head.wr)
{
u16 wait_hotknot_timeout = 0;
u8 rqst_hotknot_state;
ret = copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH],
&buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if (ret)
{
GTP_ERROR("copy_from_user failed.");
}
rqst_hotknot_state = cmd_head.data[GTP_ADDR_LENGTH];
wait_hotknot_state |= rqst_hotknot_state;
wait_hotknot_timeout = (cmd_head.data[GTP_ADDR_LENGTH + 1]<<8) +
cmd_head.data[GTP_ADDR_LENGTH + 2];
GTP_DEBUG("Goodix tool received wait polling state:0x%x,timeout:%d, all wait state:0x%x",
rqst_hotknot_state, wait_hotknot_timeout, wait_hotknot_state);
got_hotknot_state &= (~rqst_hotknot_state);
//got_hotknot_extra_state = 0;
switch(rqst_hotknot_state)
{
set_current_state(TASK_INTERRUPTIBLE);
case HN_DEVICE_PAIRED:
hotknot_paired_flag = 0;
wait_event_interruptible(bp_waiter, force_wake_flag ||
rqst_hotknot_state == (got_hotknot_state&rqst_hotknot_state));
wait_hotknot_state &= (~rqst_hotknot_state);
if(rqst_hotknot_state != (got_hotknot_state&rqst_hotknot_state))
{
GTP_ERROR("Wait 0x%x block polling waiter failed.", rqst_hotknot_state);
force_wake_flag = 0;
return FAIL;
}
break;
case HN_MASTER_SEND:
case HN_SLAVE_RECEIVED:
wait_event_interruptible_timeout(bp_waiter, force_wake_flag ||
rqst_hotknot_state == (got_hotknot_state&rqst_hotknot_state),
wait_hotknot_timeout);
wait_hotknot_state &= (~rqst_hotknot_state);
if(rqst_hotknot_state == (got_hotknot_state&rqst_hotknot_state))
{
return got_hotknot_extra_state;
}
else
{
GTP_ERROR("Wait 0x%x block polling waiter timeout.", rqst_hotknot_state);
force_wake_flag = 0;
return FAIL;
}
break;
case HN_MASTER_DEPARTED:
case HN_SLAVE_DEPARTED:
wait_event_interruptible_timeout(bp_waiter, force_wake_flag ||
rqst_hotknot_state == (got_hotknot_state&rqst_hotknot_state),
wait_hotknot_timeout);
wait_hotknot_state &= (~rqst_hotknot_state);
if(rqst_hotknot_state != (got_hotknot_state&rqst_hotknot_state))
{
GTP_ERROR("Wait 0x%x block polling waitor timeout.", rqst_hotknot_state);
force_wake_flag = 0;
return FAIL;
}
break;
default:
GTP_ERROR("Invalid rqst_hotknot_state in goodix_tool.");
break;
}
force_wake_flag = 0;
}
else if(23 == cmd_head.wr)
{
GTP_DEBUG("Manual wakeup all block polling waiter!");
got_hotknot_state = 0;
wait_hotknot_state = 0;
force_wake_flag = 1;
hotknot_paired_flag = 0;
wake_up_interruptible(&bp_waiter);
}
#endif
return CMD_HEAD_LENGTH;
}
/*******************************************************
Function:
Goodix tool write function.
Input:
standard proc write function param.
Output:
Return write length.
********************************************************/
static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len,
void *data)
{
u64 ret = 0;
GTP_DEBUG_FUNC();
GTP_DEBUG_ARRAY((u8 *) buff, len);
if(len < CMD_HEAD_LENGTH){
GTP_ERROR("copy_from_user out of range, failed.");
return -1;
}
ret = copy_from_user(&cmd_head, buff, CMD_HEAD_LENGTH);
if (ret) {
GTP_ERROR("copy_from_user failed.");
}
GTP_DEBUG("wr :0x%02x.", cmd_head.wr);
GTP_DEBUG("flag:0x%02x.", cmd_head.flag);
GTP_DEBUG("flag addr:0x%02x%02x.", cmd_head.flag_addr[0], cmd_head.flag_addr[1]);
GTP_DEBUG("flag val:0x%02x.", cmd_head.flag_val);
GTP_DEBUG("flag rel:0x%02x.", cmd_head.flag_relation);
GTP_DEBUG("circle :%d.", (s32) cmd_head.circle);
GTP_DEBUG("times :%d.", (s32) cmd_head.times);
GTP_DEBUG("retry :%d.", (s32) cmd_head.retry);
GTP_DEBUG("delay :%d.", (s32) cmd_head.delay);
GTP_DEBUG("data len:%d.", (s32) cmd_head.data_len);
GTP_DEBUG("addr len:%d.", (s32) cmd_head.addr_len);
GTP_DEBUG("addr:0x%02x%02x.", cmd_head.addr[0], cmd_head.addr[1]);
GTP_DEBUG("len:%d.", (s32) len);
GTP_DEBUG("buf[20]:0x%02x.", buff[CMD_HEAD_LENGTH]);
if (1 == cmd_head.wr) {
if((cmd_head.data == NULL)
|| (cmd_head.data_len > (DATA_LENGTH - GTP_ADDR_LENGTH))
|| (cmd_head.data_len > (len - CMD_HEAD_LENGTH)) )
{
GTP_ERROR("copy_from_user data out of range.");
return -1;
}
ret =
copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH], &buff[CMD_HEAD_LENGTH],
cmd_head.data_len);
if (ret) {
GTP_ERROR("copy_from_user failed.");
}
if((cmd_head.addr_len > sizeof(cmd_head.addr)))
{
GTP_ERROR("copy_from_user data out of range.");
return -1;
}
memcpy(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len], cmd_head.addr,
cmd_head.addr_len);
GTP_DEBUG_ARRAY(cmd_head.data, cmd_head.data_len + cmd_head.addr_len);
GTP_DEBUG_ARRAY((u8 *) &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if (1 == cmd_head.flag) {
if (FAIL == comfirm()) {
GTP_ERROR("[WRITE]Comfirm fail!");
return FAIL;
}
} else if (2 == cmd_head.flag) {
/* Need interrupt! */
}
if (tool_i2c_write(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len],
cmd_head.data_len + cmd_head.addr_len) <= 0) {
GTP_ERROR("[WRITE]Write data failed!");
return FAIL;
}
GTP_DEBUG_ARRAY(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len],
cmd_head.data_len + cmd_head.addr_len);
if (cmd_head.delay) {
msleep(cmd_head.delay);
}
return cmd_head.data_len + CMD_HEAD_LENGTH;
} else if (3 == cmd_head.wr) /* Write ic type */
{
if((cmd_head.data == NULL)
|| (cmd_head.data_len > sizeof(IC_TYPE[16]))
|| (cmd_head.data_len > (len - CMD_HEAD_LENGTH)) )
{
GTP_ERROR("copy_from_user data out of range.");
return -1;
}
memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
register_i2c_func();
return cmd_head.data_len + CMD_HEAD_LENGTH;
} else if (5 == cmd_head.wr) {
/* memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len); */
return cmd_head.data_len + CMD_HEAD_LENGTH;
} else if (7 == cmd_head.wr) /* disable irq! */
{
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
#if GTP_ESD_PROTECT
gtp_esd_switch(i2c_client_point, SWITCH_OFF);
#endif
return CMD_HEAD_LENGTH;
} else if (9 == cmd_head.wr) /* enable irq! */
{
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
#if GTP_ESD_PROTECT
gtp_esd_switch(i2c_client_point, SWITCH_ON);
#endif
return CMD_HEAD_LENGTH;
} else if (17 == cmd_head.wr) {
if((cmd_head.data == NULL)
|| (cmd_head.data_len > (DATA_LENGTH - GTP_ADDR_LENGTH))
|| (cmd_head.data_len > (len - CMD_HEAD_LENGTH)) )
{
GTP_ERROR("copy_from_user data out of range.");
return -1;
}
ret =
copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH], &buff[CMD_HEAD_LENGTH],
cmd_head.data_len);
if (ret) {
GTP_DEBUG("copy_from_user failed.");
}
if (cmd_head.data[GTP_ADDR_LENGTH]) {
GTP_DEBUG("gtp enter rawdiff.");
gtp_rawdiff_mode = true;
} else {
gtp_rawdiff_mode = false;
GTP_DEBUG("gtp leave rawdiff.");
}
return CMD_HEAD_LENGTH;
}
#ifdef UPDATE_FUNCTIONS
else if (11 == cmd_head.wr) /* Enter update mode! */
{
if (FAIL == gup_enter_update_mode(gt_client)) {
return FAIL;
}
} else if (13 == cmd_head.wr) /* Leave update mode! */
{
gup_leave_update_mode();
} else if (15 == cmd_head.wr) /* Update firmware! */
{
show_len = 0;
total_len = 0;
memset(cmd_head.data, 0, cmd_head.data_len + 1);
if((cmd_head.data == NULL)
|| (cmd_head.data_len > DATA_LENGTH)
|| (cmd_head.data_len > (len - CMD_HEAD_LENGTH)) )
{
GTP_ERROR("copy_from_user data out of range.");
return -1;
}
copy_from_user(cmd_head.data, &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
GTP_DEBUG("update firmware, filename: %s", cmd_head.data);
if (FAIL == gup_update_proc((void *)cmd_head.data)) {
return FAIL;
}
}
#endif
return CMD_HEAD_LENGTH;
}
void cyttsp4_mtk_gpio_interrupt_disable()
{
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
}
static void tpd_suspend(struct early_suspend *h)
{
int ret = 0;
int iRetry = 5;
const char data = 0x3;
//release all touch points
input_report_key(tpd->dev, BTN_TOUCH, 0);
input_mt_sync(tpd->dev);
input_sync(tpd->dev);
//NEGIN <touch panel> <DATE20130831> <tp proximity> zhangxiaofei
#ifdef TPD_PROXIMITY
if (tpd_proximity_flag == 1)
{
tpd_proximity_flag_one = 1;
return;
}
#endif
//END <touch panel> <DATE20130831> <tp proximity> zhangxiaofei
if ( g_pts ){
CTP_DBG("TPD enter sleep\n");
if (atomic_read(&g_pts->isp_opened)){
CTP_DBG("isp is already opened.");
return;
}
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
//mutex_lock(&g_pts->mutex);//Unlock on resume
mutex_trylock(&g_pts->mutex);//Unlock on resume
#ifdef CONFIG_TOUCHSCREEN_FT5X05_DISABLE_KEY_WHEN_SLIDE
fts_6x06_key_cancel();
#endif
#ifdef CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
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(2);
#ifdef MT6577
hwPowerDown(MT65XX_POWER_LDO_VGP2, "touch");
#else
hwPowerDown(MT65XX_POWER_LDO_VGP2, "touch");
#endif
#else //!CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
//make sure the WakeUp is high before it enter sleep mode,
//otherwise the touch can't be resumed.
//mt_set_gpio_mode(GPIO_CTP_EN_PIN, GPIO_CTP_EN_PIN_M_GPIO);
//mt_set_gpio_dir(GPIO_CTP_EN_PIN, GPIO_DIR_OUT);
//mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ONE);
//msleep(1);
while (iRetry) {
ret = i2c_smbus_write_i2c_block_data(g_pts->client, 0xA5, 1, &data); //TP enter sleep mode
if ( ret < 0 ){
TPD_DMESG("Enter sleep mode is %d\n", ret);
#ifdef MT6577
hwPowerDown(MT65XX_POWER_LDO_VGP2, "touch");
#else
//hwPowerDown(MT65XX_POWER_LDO_VGP2, "touch");
//mt_set_gpio_mode(GPIO_CTP_EN_PIN, GPIO_CTP_EN_PIN_M_GPIO);
//mt_set_gpio_dir(GPIO_CTP_EN_PIN, GPIO_DIR_OUT);
//mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ZERO);
#endif
msleep(2);
fts_6x06_hw_init();
}else{
break;
}
iRetry--;
msleep(100);
}
#endif//CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
#if 0//Android 4.0 don't need to report these up events.
ft6x06_complete_unfinished_event();
#endif
atomic_set( &g_pts->ts_sleepState, 1 );
}
}
void cyttsp4_mtk_gpio_interrupt_register()
{
//mt_eint_set_hw_debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINTF_TRIGGER_FALLING, eint_interrupt_handler, 0);
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
}
static int __devinit tpd_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int retval = TPD_OK;
int panel_version = 0;
int panel_vendor = 0;
int iRetry = 3;
tinno_ts_data *ts;
int ret = 0;
if ( tpd_load_status ){
CTP_DBG("Already probed a TP, needn't to probe any more!");
return -1;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev,"need I2C_FUNC_I2C");
ret = -ENODEV;
goto err_check_functionality_failed;
}
ts = kzalloc(sizeof(*ts), GFP_KERNEL);
if (ts == NULL) {
ret = -ENOMEM;
goto err_alloc_data_failed;
}
CTP_DBG("TPD enter tpd_probe ts=0x%p, TPD_RES_X=%d, TPD_RES_Y=%d, addr=0x%x\n", ts, TPD_RES_X, TPD_RES_Y, client->addr);
memset(ts, 0, sizeof(*ts));
g_pts = ts;
client->timing = I2C_MASTER_CLOCK;
ts->client = client;
ts->start_reg = 0x00;
atomic_set( &ts->ts_sleepState, 0 );
mutex_init(&ts->mutex);
i2c_set_clientdata(client, ts);
fts_6x06_hw_init();
msleep(120);
fts_iic_init(ts);
if ( fts_6x06_isp_init(ts) ){
goto err_isp_register;
}
while (iRetry) {
ret = ft6x06_get_vendor_version(ts, &panel_vendor, &panel_version);
if ( panel_version < 0 || panel_vendor<0 || ret<0 ){
CTP_DBG("Product version is %d\n", panel_version);
fts_6x06_hw_reset();
}else{
break;
}
iRetry--;
msleep(15);
}
if ( panel_version < 0 || panel_vendor<0 || ret<0 ){
goto err_get_version;
}
#ifdef TPD_HAVE_BUTTON
tinno_update_tp_button_dim(panel_vendor);
#endif
#ifdef CONFIG_TOUCHSCREEN_FT5X05_DISABLE_KEY_WHEN_SLIDE
if ( fts_keys_init(ts) ){
fts_keys_deinit();
goto err_get_version;
}
#endif
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);
//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, 0);
mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_TYPE, tpd_eint_interrupt_handler, 1);
ts->thread = kthread_run(touch_event_handler, ts, TPD_DEVICE);
if (IS_ERR(ts->thread)){
retval = PTR_ERR(ts->thread);
TPD_DMESG(TPD_DEVICE " failed to create kernel thread: %d\n", retval);
goto err_start_touch_kthread;
}
tpd_load_status = 1;
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
CTP_DBG("Touch Panel Device(%s) Probe PASS\n", fts_get_vendor_name(panel_vendor));
//BEGIN <tp> <DATE20130507> <tp version> zhangxiaofei
{
extern char tpd_desc[50];
extern int tpd_fw_version;
sprintf(tpd_desc, "%s", fts_get_vendor_name(panel_vendor));
tpd_fw_version = panel_version;
}
//END <tp> <DATE20130507> <tp version> zhangxiaofei
//LINE<tp><DATE20130619><add for focaltech debug>zhangxiaofei
#ifdef FTS_CTL_IIC
if (ft_rw_iic_drv_init(client) < 0)
dev_err(&client->dev, "%s:[FTS] create fts control iic driver failed\n",
__func__);
#endif
//BEGIN <touch panel> <DATE20130831> <tp proximity> zhangxiaofei
#if defined TPD_PROXIMITY
struct hwmsen_object obj_ps;
int err=0;
obj_ps.polling = 0;//interrupt mode
obj_ps.sensor_operate = tpd_ps_operate;
if((err = hwmsen_attach(ID_PROXIMITY, &obj_ps)))
{
APS_ERR("proxi_fts attach fail = %d\n", err);
}
else
{
APS_ERR("proxi_fts attach ok = %d\n", err);
}
#endif
//END <touch panel> <DATE20130831> <tp proximity> zhangxiaofei
//BEGIN<touch panel><date20131028><tp auto update>yinhuiyong
#if defined(FTS_AUTO_TP_UPGRADE)
focaltech_auto_upgrade();
#endif
//END<touch panel><date20131028><tp auto update>yinhuiyong
return 0;
err_start_touch_kthread:
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
err_get_version:
err_isp_register:
#ifdef CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
hwPowerDown(MT65XX_POWER_LDO_VGP2, "touch");
#endif
fts_6x06_isp_exit();
mutex_destroy(&ts->mutex);
g_pts = NULL;
kfree(ts);
err_alloc_data_failed:
err_check_functionality_failed:
CTP_DBG("Touch Panel Device Probe FAIL\n");
return -1;
}
static int touch_event_handler(void *para)
{
int i;
tinno_ts_point touch_point[TINNO_TOUCH_TRACK_IDS];
struct sched_param param = { .sched_priority = RTPM_PRIO_TPD };
tinno_ts_data *ts = (tinno_ts_data *)para;
sched_setscheduler(current, SCHED_RR, ¶m);
//BEGIN <touch panel> <DATE20130831> <tp proximity> zhangxiaofei
#if defined TPD_PROXIMITY
int err;
hwm_sensor_data sensor_data;
u8 proximity_status;
u8 state;
#endif
//END <touch panel> <DATE20130831> <tp proximity> zhangxiaofei
do {
set_current_state(TASK_INTERRUPTIBLE);
wait_event_interruptible(waiter, tpd_flag!=0);
tpd_flag = 0;
memset(touch_point, FTS_INVALID_DATA, sizeof(touch_point));
set_current_state(TASK_RUNNING);
//BEGIN <touch panel> <DATE20130831> <tp proximity> zhangxiaofei
#if defined TPD_PROXIMITY
if (tpd_proximity_flag == 1)
{
i2c_smbus_read_i2c_block_data(g_pts->client, TPD_PROXIMITY_ENABLE_REG, 1, &state);
TPD_PROXIMITY_DBG("proxi_5206 0xB0 state value is 1131 0x%02X\n", state);
if(!(state&0x01))
{
tpd_enable_ps(1);
}
i2c_smbus_read_i2c_block_data(g_pts->client, 0x01, 1, &proximity_status);
TPD_PROXIMITY_DBG("proxi_5206 0x01 value is 1139 0x%02X\n", proximity_status);
if (proximity_status == TPD_PROXIMITY_CLOSE_VALUE)
{
tpd_proximity_detect = 0;
}
else if(proximity_status == TPD_PROXIMITY_FARAWAY_VALUE)
{
tpd_proximity_detect = 1;
}
TPD_PROXIMITY_DBG("tpd_proximity_detect 1149 = %d\n", tpd_proximity_detect);
if ((err = tpd_read_ps()))
{
TPD_PROXIMITY_DBG("proxi_5206 read ps data 1156: %d\n", err);
}
sensor_data.values[0] = tpd_get_ps_value();
sensor_data.value_divide = 1;
sensor_data.status = SENSOR_STATUS_ACCURACY_MEDIUM;
if ((err = hwmsen_get_interrupt_data(ID_PROXIMITY, &sensor_data)))
{
TPD_PROXIMITY_DBG(" proxi_5206 call hwmsen_get_interrupt_data failed= %d\n", err);
}
}
#endif
//END <touch panel> <DATE20130831> <tp proximity> zhangxiaofei
//BEGIN <add changing flag> <DATE20130330> <add changing flag> zhangxiaofei
if(g_tp_charger_flag != g_pre_tp_charger_flag){
g_pre_tp_charger_flag = g_tp_charger_flag;
fts_ft6x06_switch_charger_status(g_tp_charger_flag);
}
//END <add changing flag> <DATE20130330> <add changing flag> zhangxiaofei
if (!tpd_touchinfo(ts, &touch_point)) {
//report muti point then
for ( i=0; i < TINNO_TOUCH_TRACK_IDS; i++ ){
if ( FTS_INVALID_DATA != touch_point[i].x ){
if ( FTS_EF_UP == touch_point[i].flag ){
if( test_bit(i, &ts->fingers_flag) ){
tpd_up(ts, ts->touch_point_pre[i].x, ts->touch_point_pre[i].y,
touch_point[i].pressure, i);
}else{
CTP_DBG("This is a invalid up event.(%d)", i);
}
}else{//FTS_EF_CONTACT or FTS_EF_DOWN
if ( test_bit(i, &ts->fingers_flag)
&& (FTS_EF_DOWN == touch_point[i].flag) ){
CTP_DBG("Ignore a invalid down event.(%d)", i);
continue;
}
tpd_down(ts, touch_point[i].x, touch_point[i].y,
touch_point[i].pressure, i);
}
}else if ( test_bit(i, &ts->fingers_flag) ){
CTP_DBG("Complete a invalid down or move event.(%d)", i);
tpd_up(ts, ts->touch_point_pre[i].x, ts->touch_point_pre[i].y,
touch_point[i].pressure, i);
}
}
input_sync(tpd->dev);
}
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
}while(!kthread_should_stop());
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
return 0;
}
INT32
wmt_plat_eirq_ctrl (
ENUM_PIN_ID id,
ENUM_PIN_STATE state
)
{
INT32 iret;
// TODO: [ChangeFeature][GeorgeKuo]: use another function to handle this, as done in gpio_ctrls
if ( (PIN_STA_INIT != state )
&& (PIN_STA_DEINIT != state )
&& (PIN_STA_EINT_EN != state )
&& (PIN_STA_EINT_DIS != state ) ) {
WMT_WARN_FUNC("WMT-PLAT:invalid PIN_STATE(%d) in eirq_ctrl for PIN(%d)\n", state, id);
return -1;
}
iret = -2;
switch (id) {
case PIN_BGF_EINT:
#ifdef GPIO_COMBO_BGF_EINT_PIN
if (PIN_STA_INIT == state) {
#if CUST_EINT_COMBO_BGF_DEBOUNCE_EN
mt_eint_set_hw_debounce(CUST_EINT_COMBO_BGF_NUM, CUST_EINT_COMBO_BGF_DEBOUNCE_CN);
#endif
mt_eint_registration(CUST_EINT_COMBO_BGF_NUM,
CUST_EINT_COMBO_BGF_POLARITY,
wmt_plat_bgf_eirq_cb,
0);
mt_eint_mask(CUST_EINT_COMBO_BGF_NUM); /*2*/
}
else if (PIN_STA_EINT_EN == state) {
mt_eint_unmask(CUST_EINT_COMBO_BGF_NUM);
WMT_DBG_FUNC("WMT-PLAT:BGFInt (en) \n");
}
else if (PIN_STA_EINT_DIS == state) {
mt_eint_mask(CUST_EINT_COMBO_BGF_NUM);
WMT_DBG_FUNC("WMT-PLAT:BGFInt (dis) \n");
}
else {
mt_eint_mask(CUST_EINT_COMBO_BGF_NUM);
/* de-init: nothing to do in ALPS, such as un-registration... */
}
#else
WMT_INFO_FUNC("WMT-PLAT:BGF EINT not defined\n", state);
#endif
iret = 0;
break;
case PIN_ALL_EINT:
#ifdef GPIO_COMBO_ALL_EINT_PIN
if (PIN_STA_INIT == state) {
#if 0
#if CUST_EINT_COMBO_ALL_DEBOUNCE_EN
mt_eint_set_hw_debounce(CUST_EINT_COMBO_ALL_NUM, CUST_EINT_COMBO_ALL_DEBOUNCE_CN);
#endif
mt_eint_registration(CUST_EINT_COMBO_ALL_NUM,
CUST_EINT_COMBO_ALL_TYPE,
combo_bgf_eirq_handler,
0);
#endif
mt_eint_mask(CUST_EINT_COMBO_ALL_NUM); /*2*/
WMT_DBG_FUNC("WMT-PLAT:ALLInt (INIT but not used yet) \n");
}
else if (PIN_STA_EINT_EN == state) {
/*mt_eint_unmask(CUST_EINT_COMBO_ALL_NUM);*/
WMT_DBG_FUNC("WMT-PLAT:ALLInt (EN but not used yet) \n");
}
else if (PIN_STA_EINT_DIS == state) {
mt_eint_mask(CUST_EINT_COMBO_ALL_NUM);
WMT_DBG_FUNC("WMT-PLAT:ALLInt (DIS but not used yet) \n");
}
else {
mt_eint_mask(CUST_EINT_COMBO_ALL_NUM);
WMT_DBG_FUNC("WMT-PLAT:ALLInt (DEINIT but not used yet) \n");
/* de-init: nothing to do in ALPS, such as un-registration... */
}
#else
WMT_INFO_FUNC("WMT-PLAT:ALL EINT not defined\n", state);
#endif
iret = 0;
break;
default:
WMT_WARN_FUNC("WMT-PLAT:unsupported EIRQ(PIN_ID:%d) in eirq_ctrl\n", id);
iret = -1;
break;
}
return iret;
}
static void mtk_wcn_cmb_sdio_disable_eirq(void)
{
mt_eint_mask(mtk_wcn_cmb_sdio_eint_num); /* CUST_EINT_WIFI_NUM */
}
static void musbfsh_port_suspend(struct musbfsh *musbfsh, bool do_suspend)
{
u8 power;
u8 intrusbe;
u8 intrusb;
void __iomem *mbase = musbfsh->mregs;
int retries = 0;
/* MYDBG("cpuid:%d\n", smp_processor_id()); */
/* NOTE: this doesn't necessarily put PHY into low power mode,
* turning off its clock; that's a function of PHY integration and
* MUSBFSH_POWER_ENSUSPEND. PHY may need a clock (sigh) to detect
* SE0 changing to connect (J) or wakeup (K) states.
*/
if (do_suspend) {
#ifdef CONFIG_MTK_DT_USB_SUPPORT
if (musbfsh_skip_port_suspend) {
MYDBG("\n");
musbfsh->port1_status |= USB_PORT_STAT_SUSPEND;
return;
}
#endif
/* clean MUSBFSH_INTR_SOF in MUSBFSH_INTRUSBE */
intrusbe = musbfsh_readb(mbase, MUSBFSH_INTRUSBE);
intrusbe &= ~MUSBFSH_INTR_SOF;
musbfsh_writeb(mbase, MUSBFSH_INTRUSBE, intrusbe);
mb(); /* flush POWER and PHY setting immediately */
/* clean MUSBFSH_INTR_SOF in MUSBFSH_INTRUSB */
intrusb = musbfsh_readb(mbase, MUSBFSH_INTRUSB);
intrusb |= MUSBFSH_INTR_SOF;
musbfsh_writeb(mbase, MUSBFSH_INTRUSB, intrusb);
mb(); /* flush POWER and PHY setting immediately */
retries = 10000;
intrusb = musbfsh_readb(mbase, MUSBFSH_INTRUSB);
while (!(intrusb & MUSBFSH_INTR_SOF)) {
intrusb = musbfsh_readb(mbase, MUSBFSH_INTRUSB);
if (retries-- < 1) {
MYDBG("\n");
break;
}
}
/* delay 10 us */
udelay(10);
/* set MUSBFSH_POWER_SUSPENDM in MUSBFSH_POWER_SUSPENDM */
power = musbfsh_readb(mbase, MUSBFSH_POWER);
#ifdef CONFIG_MTK_DT_USB_SUPPORT
#if defined(CONFIG_PM_RUNTIME) && defined(USB11_REMOTE_IRQ_NON_AUTO_MASK)
disable_remote_wake_up();
#endif
#endif
#ifdef MTK_USB_RUNTIME_SUPPORT
/*
* mask remote wake up IRQ between port suspend and bus suspend.
* hub.c will call set_port_feature first then
* usb_set_device_state, so if EINT comes between them,
* resume flow may see device state without USB_STATE_SUSPENDED
* and do nothing.
* So we postpone remote wake up IRQ until the suspend flow
* is all done (when bus_suspend is called). Since suspend flow
* may be interrupted (root hub is suspended, but not host
* controller), so we also unmaks EINT when resume is done.
*/
mt_eint_mask(CUST_EINT_MT6280_USB_WAKEUP_NUM);
#endif
retries = 10000;
#ifdef CONFIG_MTK_ICUSB_SUPPORT
if (skip_port_pm_attr.value) {
MYDBG("skip hw operation for port suspend\n");
} else {
power &= ~MUSBFSH_POWER_RESUME;
power |= MUSBFSH_POWER_SUSPENDM;
musbfsh_writeb(mbase, MUSBFSH_POWER, power);
/* Needed for OPT A tests */
power = musbfsh_readb(mbase, MUSBFSH_POWER);
while (power & MUSBFSH_POWER_SUSPENDM) {
power = musbfsh_readb(mbase, MUSBFSH_POWER);
if (retries-- < 1)
break;
}
}
#else
power &= ~MUSBFSH_POWER_RESUME;
power |= MUSBFSH_POWER_SUSPENDM;
musbfsh_writeb(mbase, MUSBFSH_POWER, power);
/* Needed for OPT A tests */
power = musbfsh_readb(mbase, MUSBFSH_POWER);
while (power & MUSBFSH_POWER_SUSPENDM) {
power = musbfsh_readb(mbase, MUSBFSH_POWER);
if (retries-- < 1) {
MYDBG("\n");
break;
}
}
#endif
mb(); /* flush POWER and PHY setting immediately */
WARNING("Root port suspended, power 0x%02x\n", power);
#ifdef CONFIG_MTK_DT_USB_SUPPORT
#if defined(CONFIG_PM_RUNTIME)
disable_usb11_clk();
#endif
#endif
musbfsh->port1_status |= USB_PORT_STAT_SUSPEND;
} else {
#ifdef CONFIG_MTK_DT_USB_SUPPORT
if (musbfsh_skip_port_resume) {
MYDBG("\n");
request_wakeup_md_timeout(0, 0);
musbfsh->port1_status |= MUSBFSH_PORT_STAT_RESUME;
musbfsh->rh_timer = jiffies + msecs_to_jiffies(20);
return;
}
#if defined(CONFIG_PM_RUNTIME)
enable_usb11_clk();
#endif
#endif
power = musbfsh_readb(mbase, MUSBFSH_POWER);
if (!(power & MUSBFSH_POWER_SUSPENDM)) {
WARNING("Root port resuming abort, power 0x%02x\n",
power);
if (power & MUSBFSH_POWER_RESUME)
goto finish;
else
return;
}
#ifdef CONFIG_MTK_DT_USB_SUPPORT
request_wakeup_md_timeout(0, 0);
#endif
#ifdef MTK_USB_RUNTIME_SUPPORT
/* ERR("EINT to wake up MD for resume\n"); */
/* request_wakeup_md_timeout(0, 0); //wx, wakeup MD first */
#endif
#ifdef CONFIG_MTK_ICUSB_SUPPORT
if (skip_port_pm_attr.value) {
MYDBG("skip hw operation for port resume\n");
} else {
power &= ~MUSBFSH_POWER_SUSPENDM;
power |= MUSBFSH_POWER_RESUME;
musbfsh_writeb(mbase, MUSBFSH_POWER, power);
}
#else
power &= ~MUSBFSH_POWER_SUSPENDM;
power |= MUSBFSH_POWER_RESUME;
musbfsh_writeb(mbase, MUSBFSH_POWER, power);
#endif
mb(); /* flush POWER and PHY setting immediately */
WARNING("Root port resuming, power 0x%02x\n", power);
finish:
/* later, GetPortStatus will stop RESUME signaling */
musbfsh->port1_status |= MUSBFSH_PORT_STAT_RESUME;
musbfsh->rh_timer = jiffies + msecs_to_jiffies(20);
}
}
