/*----------------------------------------------------------------------------*/
static void hall_eint_work(struct work_struct *work)
{
int err;
HALL_LOG("hall_eint_work()\n");
if((err = hall_read_status(&g_hall_ptr->hall_status)))
{
HALL_ERR("hall_read_value: %d\n", err);
}
if (g_hall_ptr->hall_status == 1)
{
HALL_ERR("HALL OPEN!!! \n");
mt_eint_set_polarity(CUST_EINT_HALL_COVER_NUM, MT_POLARITY_LOW);
}
else
{
HALL_ERR("HALL CLOSE!!! \n");
mt_eint_set_polarity(CUST_EINT_HALL_COVER_NUM, MT_POLARITY_HIGH);
}
input_report_switch(g_hall_ptr->idev, g_hall_ptr->sw_code, g_hall_ptr->hall_status);
input_sync(g_hall_ptr->idev);
mt_eint_unmask(CUST_EINT_HALL_COVER_NUM);
}
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);
}
/* switch touch panel back to normal mode */
void _tpd_switch_normal_mode(void) {
char wakeup[2] = {0x07,0x02};
char threshold[2] = {0x09, 0x04};
char gesture[2] = {0x08, 0x11};
char sleeptime[2] = {0x0d, 0x01};
char idletime[2] = {0x0c, 0xff};
int i;
if (tpd_status) {
TPD_DMESG("do not need to switch tpd back to normal mode\n");
return;
}
TPD_DMESG("switch tpd back to normal mode\n");
for(i=0;i<TPD_WAKEUP_TRIAL;i++) {
i2c_master_send(i2c_client,wakeup,2);
if(i2c_master_send(i2c_client,wakeup,2)==2) break;
msleep(TPD_WAKEUP_DELAY);
}
i2c_master_send(i2c_client,gesture,2);
i2c_master_send(i2c_client,threshold,2);
i2c_master_send(i2c_client,idletime,2);
i2c_master_send(i2c_client,sleeptime,2);
//MT6516_IRQUnmask(MT6516_TOUCH_IRQ_LINE);
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
tpd_status = 1;
}
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 gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
{
unsigned char pressed = RELEASED, state_prev = RELEASED, input_value = 0xff;
unsigned long flags;
spin_lock_irqsave(&bdata->lock, flags);
input_value = mt_get_gpio_in(bdata->button->gpio);
pressed = (input_value ? 1 : 0) ^ bdata->button->active_low;
state_prev = atomic_read(&bdata->key_pressed);
#ifdef KEYPAD_DEBUG
if(pressed == state_prev) {
printk("[Hall] %s: error, %s prev:%s gpio_in_now:%d\n",
__func__,
bdata->button->desc,
(state_prev == PRESSED)?"Pressed":"Released",
input_value);
}
#endif
atomic_set(&bdata->key_pressed, (pressed == PRESSED) ? PRESSED : RELEASED);
input_report_key(bdata->input, bdata->button->code, pressed);
input_sync(bdata->input);
spin_unlock_irqrestore(&bdata->lock, flags);
mt_eint_unmask(bdata->button->irq);
}
static int touch_event_handler(void *arg)
{
struct sched_param param = { .sched_priority = RTPM_PRIO_TPD };
struct tp_driver_data * data = (struct tp_driver_data*) arg ;
if(!data)
return -ENODEV ;
sched_setscheduler(current, SCHED_RR, ¶m);
do
{
set_current_state(TASK_INTERRUPTIBLE);
wait_event_interruptible(waiter, tpd_flag != 0);
tpd_flag = 0 ;
set_current_state(TASK_RUNNING);
if(data->out.report_func&& !exitThread){
dbg_printk("++++:%pf\n",data->out.report_func);
data->out.report_func(data->out.driver_data) ;
dbg_printk("----\n");
}
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
}while (!exitThread);
dbg_printk("!!!!!!!!!!!!!!kthread exit!!!!!!!!!!!!\n");
return 0;
}
static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata)
{
unsigned char input_value = 0xff;
unsigned long flags;
//unsigned int code;
spin_lock_irqsave(&bdata->lock, flags);
input_value = mt_get_gpio_in(bdata->button->gpio);
if( bdata->irq != M7X_HALL_IRQ_NUM) {
atomic_set(&bdata->key_pressed, (atomic_read(&bdata->key_pressed) == RELEASED)?PRESSED:RELEASED );
input_report_key(bdata->input, bdata->button->code, atomic_read(&bdata->key_pressed));
input_sync(bdata->input);
} else {
if( atomic_read(&bdata->key_pressed)==CLOSED ) {
//code = 0x15;
input_report_switch(bdata->input, bdata->button->code, RELEASED);
input_sync(bdata->input);
atomic_set(&bdata->key_pressed, REMOVED);
#ifdef KEY_HALL_DEBUG
key_hall_press = REMOVED;
#endif
} else {
//code = 0x15;
input_report_switch(bdata->input, bdata->button->code, PRESSED);
input_sync(bdata->input);
atomic_set(&bdata->key_pressed, CLOSED);
#ifdef KEY_HALL_DEBUG
key_hall_press = CLOSED;
#endif
}
}
spin_unlock_irqrestore(&bdata->lock, flags);
#ifdef MEIZU_TP_NOTIFIER
if(bdata->irq == M7X_HALL_IRQ_NUM)
gpio_key_notify(atomic_read(&bdata->key_pressed),NULL);
#endif
if( atomic_read(&bdata->key_pressed)==PRESSED ) {
schedule_delayed_work(&bdata->delayed_work, msecs_to_jiffies(bdata->timer_debounce));
} else {
/*
* cant use cancel_delayed_work_sync() in the context
*/
cancel_delayed_work(&bdata->delayed_work);
}
#ifdef KEYPAD_DEBUG
printk("[Hall] %s: %s--%s gpio_in:%d\n",
__func__,
bdata->button->desc,
(atomic_read(&bdata->key_pressed) == PRESSED)?"Pressed":"Released",
input_value);
#endif
mt_eint_unmask(bdata->button->irq);
}
void Unmask_MHL_Intr(void)
{
#ifdef CUST_EINT_MHL_NUM
mt_eint_unmask(CUST_EINT_MHL_NUM);
#endif
return ;
}
//add by lihua BUG_ID:NULL Description: add node 2013-10-29 (end)
static int mhall_thread_kthread(void *x)
{
while(1)
{
s32 mhall_value;
wait_event_interruptible(mhall_thread_wq, atomic_read(&mhall_wakeup_flag));
atomic_set(&mhall_wakeup_flag, 0);
#if 0
kpd_pwrkey_pmic_handler(1);
msleep(100);
kpd_pwrkey_pmic_handler(0);
#endif
// mt_set_gpio_mode(GPIO_MHALL_EINT_PIN, GPIO_MHALL_EINT_PIN_M_GPIO);
// mt_set_gpio_dir(GPIO_MHALL_EINT_PIN, GPIO_DIR_IN);
// mt_set_gpio_pull_enable(GPIO_MHALL_EINT_PIN, GPIO_PULL_DISABLE);
mhall_value = mt_get_gpio_in(GPIO_MHALL_EINT_PIN);
MHALL_ERR("%s: fangxing mhall_value = %d \n",__func__,mhall_value);
if(mhall_value == 1 ) {
input_report_key(mhall_input_dev, KEY_MHALL_UP, 1);
input_sync(mhall_input_dev);
msleep(10);
input_report_key(mhall_input_dev, KEY_MHALL_UP, 0);
input_sync(mhall_input_dev);
// mt_eint_mask(CUST_EINT_MHALL_NUM);
// och165twad_mhall_eint_config_polarity(CUST_EINT_POLARITY_LOW);
mt_eint_set_polarity(GPIO_MHALL_EINT_PIN,0);
mt_eint_unmask(CUST_EINT_MHALL_NUM);
mhall_flag = 1;//add by lihua BUG_ID:NULL Description: add node 2013-10-29
} else {
input_report_key(mhall_input_dev, KEY_MHALL_DOWN, 1);
input_sync(mhall_input_dev);
msleep(10);
input_report_key(mhall_input_dev, KEY_MHALL_DOWN, 0);
input_sync(mhall_input_dev);
// mt_eint_mask(CUST_EINT_MHALL_NUM);
// och165twad_mhall_eint_config_polarity(CUST_EINT_POLARITY_HIGH);
mt_eint_set_polarity(GPIO_MHALL_EINT_PIN,1);
mt_eint_unmask(CUST_EINT_MHALL_NUM);
mhall_flag = 0;//add by lihua BUG_ID:NULL Description: add node 2013-10-29
}
}
}
static void tpd_resume(struct early_suspend *h)
{
char data;
#ifdef TPD_PROXIMITY
if (tpd_proximity_flag == 1)
{
if(tpd_proximity_flag_one == 1)
{
tpd_proximity_flag_one = 0;
TPD_DMESG(TPD_DEVICE " tpd_proximity_flag_one \n");
return;
}
}
#endif
if ( g_pts ){
CTP_DBG("TPD wake up\n");
if (atomic_read(&g_pts->isp_opened)){
CTP_DBG("isp is already opened.");
return;
}
#ifdef CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
fts_6x06_hw_init();
#else //!CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
//BEGIN <JIRA ID (KeyCode)> <DATE> <BUG INFO> zhangxiaofei
//mt_set_gpio_mode(GPIO_CTP_WAKE_PIN, GPIO_CTP_WAKE_PIN_M_GPIO);
//mt_set_gpio_dir(GPIO_CTP_WAKE_PIN, GPIO_DIR_OUT);
//mt_set_gpio_out(GPIO_CTP_WAKE_PIN, GPIO_OUT_ZERO);
//msleep(1);
//mt_set_gpio_mode(GPIO_CTP_WAKE_PIN, GPIO_CTP_WAKE_PIN_M_GPIO);
//mt_set_gpio_dir(GPIO_CTP_WAKE_PIN, GPIO_DIR_OUT);
//mt_set_gpio_out(GPIO_CTP_WAKE_PIN, GPIO_OUT_ONE);
//END <JIRA ID (KeyCode)> <DATE> <BUG INFO> zhangxiaofei
//BEGIN <tp> <DATE20130507> <tp resume> zhangxiaofei
// reset ctp
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_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);
msleep(200);//add this line
CTP_DBG("TPD wake up done\n");
//END <tp> <DATE20130507> <tp resume> zhangxiaofei
#endif//CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
mutex_unlock(&g_pts->mutex);//Lock on suspend
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
atomic_set( &g_pts->ts_sleepState, 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 c2k_gpio_irq_unmask(int gpio)
{
int irq;
irq = c2k_gpio_to_irq(gpio);
if(irq < 0){
return ;
}
mt_eint_unmask(irq);
}
void switch_int_to_device(struct musb *musb)
{
#ifdef ID_PIN_USE_EX_EINT
mt_eint_set_polarity(IDDIG_EINT_PIN, MT_EINT_POL_POS);
mt_eint_unmask(IDDIG_EINT_PIN);
#else
musb_writel(musb->mregs,USB_L1INTP,0);
musb_writel(musb->mregs,USB_L1INTM,IDDIG_INT_STATUS|musb_readl(musb->mregs,USB_L1INTM));
#endif
DBG(0,"switch_int_to_device is done\n");
}
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 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);
mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_TYPE, tpd_eint_interrupt_handler, 1);
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
printk("MediaTek touch panel i2c probe success\n");
return 0;
}
static int txc_irq_init(struct txc_data *txc)
{
int ret;
int irq;
mt_set_gpio_dir(GPIO_IR_EINT_PIN, GPIO_DIR_IN);
mt_set_gpio_mode(GPIO_IR_EINT_PIN, GPIO_MODE_00);
mt_eint_set_sens(CUST_EINT_INTI_INT_NUM, MT_EDGE_SENSITIVE);
mt_eint_registration(CUST_EINT_INTI_INT_NUM, EINTF_TRIGGER_FALLING, txc_irq_handler, 0);
mt_eint_unmask(CUST_EINT_INTI_INT_NUM);
return ret;
}
static void tpd_resume(struct early_suspend *h)
{
#ifdef CONFIG_TOUCHSCREEN_SWEEP2WAKE
printk("[SWEEP2WAKE]: resume\n");
scr_suspended = false;
if ((sweep2wake == 0 || sweep2wake == 3) && doubletap2wake == 0) {
#endif
if ( g_pts ){
CTP_DBG("TPD wake up\n");
if (atomic_read(&g_pts->isp_opened)){
CTP_DBG("isp is already opened.");
return;
}
#ifdef CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
fts_5x06_hw_init();
#else //!CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
mt_set_gpio_mode(GPIO_CTP_WAKE_PIN, GPIO_CTP_WAKE_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_CTP_WAKE_PIN, GPIO_DIR_OUT);
mt_set_gpio_out(GPIO_CTP_WAKE_PIN, GPIO_OUT_ZERO);
msleep(1);
mt_set_gpio_mode(GPIO_CTP_WAKE_PIN, GPIO_CTP_WAKE_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_CTP_WAKE_PIN, GPIO_DIR_OUT);
mt_set_gpio_out(GPIO_CTP_WAKE_PIN, GPIO_OUT_ONE);
#endif//CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
mutex_unlock(&g_pts->mutex);//Lock on suspend
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
atomic_set( &g_pts->ts_sleepState, 0 );
}
#ifdef CONFIG_TOUCHSCREEN_SWEEP2WAKE
} else if ((sweep2wake > 0 && sweep2wake < 3) || doubletap2wake > 0)
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
#endif
}
static void bq24196_irq_init(void)
{
int ret;
/*unmask CHRG_FAULT and BAT_FAULT */
ret = bq24196_i2c_update_reg(bq_data, BQ24196_REG_MISC_CONTROL, 0x3, 0x3);
mt_set_gpio_dir(GPIO_BQ_INT_PIN, GPIO_DIR_IN);
mt_set_gpio_mode(GPIO_BQ_INT_PIN, GPIO_MODE_00);
mt_eint_set_sens(GPIO_BQ_INT_NUM, MT_LEVEL_SENSITIVE);
mt_eint_registration(GPIO_BQ_INT_NUM, EINTF_TRIGGER_LOW, bq24196_irq_handler, 0);
mt_eint_unmask(GPIO_BQ_INT_NUM);
}
void c2k_gpio_irq_unmask(int gpio)
{
int irq;
irq = c2k_gpio_to_irq(gpio);
if (irq < 0)
return;
#if defined(CONFIG_MTK_LEGACY)
mt_eint_unmask(irq);
#else
enable_irq(irq);
#endif
}
static void fcover_key_handler(unsigned long data)
{
bool pressed;
u8 old_state = fcover_key_state;
fcover_key_state = !fcover_key_state;
pressed = (fcover_key_state == !!FCOVER_KEY_POLARITY);
printk("\r\n leanda fcover_key_eint_handler in pressed=%d, fcover_key_state=%d,old_state=%d \r\n", pressed, fcover_key_state, old_state);
if(pressed) // close
{
fcover_close_flag = 0;
input_report_key(kpd_input_dev, KEY_FCOVER_1, 1);
input_sync(kpd_input_dev);
mdelay(1);
input_report_key(kpd_input_dev, KEY_FCOVER_1, 0);
input_sync(kpd_input_dev);
printk("report Linux keycode = %u\n", KEY_FCOVER_1);
//======================test=========================
#ifdef KERNEL_OPEN_FCOVER
if(lcm_backlight_flag == 1)
{
kpd_backlight_handler(1, KPD_PWRKEY_MAP);
input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, 1);
input_sync(kpd_input_dev);
printk("report Linux keycode = %u\n", KPD_PWRKEY_MAP);
mdelay(1);
kpd_backlight_handler(0, KPD_PWRKEY_MAP);
input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, 0);
input_sync(kpd_input_dev);
printk("report Linux keycode = %u\n", KPD_PWRKEY_MAP);
}
#endif
//======================end===========================
}
else // open
{
fcover_close_flag = 1;
input_report_key(kpd_input_dev, KEY_FCOVER_2, 1);
input_sync(kpd_input_dev);
mdelay(1);
input_report_key(kpd_input_dev, KEY_FCOVER_2, 0);
input_sync(kpd_input_dev);
printk("report Linux keycode = %u\n", KEY_FCOVER_2);
}
/* for detecting the return to old_state */
mt_eint_set_polarity(FCOVER_KEY_EINT, old_state);
mt_eint_unmask(FCOVER_KEY_EINT);
}
//void tpd_resume(struct i2c_client *client)
static void tpd_resume( struct early_suspend *h )
{
int ret = 0;
unsigned char Wrbuf[2] = {0x14, 0x00};
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 resume: 0x%x\n", ret);
}
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
tpd_halt = 0;
}
static int hw_irq_enable(void)
{
int retval = -1 ;
/* Recovery EINT Mode */
retval = mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);
retval |=mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);
retval |=mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_ENABLE);
retval |=mt_set_gpio_pull_select(GPIO_CTP_EINT_PIN, GPIO_PULL_UP);
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
info_printk("TPD wake up\n");
return retval;
}
/*
* register irq handler
* parmaters pass by inno_core
* @handler - if101 irq handler function pointer
* @irq_type - if101 irq type (falling edge detect or rising)
*/
int inno_irq_setup(void (*interrupthandler)(void ))
{
mt_set_gpio_mode(GPIO_CMMB_EINT_PIN, GPIO_CMMB_EINT_PIN_M_EINT); //set to eint MODE for enable eint function
mt_set_gpio_dir(GPIO_CMMB_EINT_PIN, GPIO_DIR_IN);
#if 1
mt_set_gpio_pull_enable(GPIO_CMMB_EINT_PIN, 1);
mt_set_gpio_pull_select(GPIO_CMMB_EINT_PIN, 1);
#endif
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));
// rename the functions mt65xx_eint_xx by mt_eint_xx rui
mt_eint_registration(CUST_EINT_CMMB_NUM, EINTF_TRIGGER_FALLING, interrupthandler, 0); // 0:auto mask is no
mt_eint_unmask(CUST_EINT_CMMB_NUM);
// mt_eint_mask(CUST_EINT_CMMB_NUM);
return 0;
}
static void mtk_wcn_cmb_sdio_enable_eirq(void)
{
#if CONFIG_EINT_DEVICE_TREE
if(!atomic_read(&wifi_irq_flag))
{
printk(KERN_DEBUG "wifi eint has been enabled\n");;
}
else
{
enable_irq(wifi_irq);
atomic_dec(&wifi_irq_flag);
//printk(KERN_DEBUG " enable WIFI EINT irq %d !!\n",wifi_irq);
}
#else
mt_eint_unmask(mtk_wcn_cmb_sdio_eint_num);/* CUST_EINT_WIFI_NUM */
#endif
}
int hall_setup_eint(void)
{
/*configure to GPIO function, external interrupt*/
mt_set_gpio_mode(GPIO_HALL_COVER_PIN, GPIO_HALL_COVER_PIN_M_EINT);
mt_set_gpio_dir(GPIO_HALL_COVER_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_HALL_COVER_PIN, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO_HALL_COVER_PIN, GPIO_PULL_UP);
HALL_LOG("hall_setup_eint 111\n");
mt_eint_set_hw_debounce(CUST_EINT_HALL_COVER_NUM , CUST_EINT_HALL_COVER_DEBOUNCE_CN);
mt_eint_registration(CUST_EINT_HALL_COVER_NUM , CUST_EINT_HALL_COVER_TYPE, hall_eint_func, 0);
mt_eint_unmask(CUST_EINT_HALL_COVER_NUM );
HALL_LOG("hall_setup_eint 222\n");
return 0;
}
static void tpd_resume(struct early_suspend *h) {
char wakeup[2] = {0x07,0x02};
char threshold[2] = {0x09, 0x04};
char gesture[2] = {0x08, 0x11};
char sleeptime[2] = {0x0d, 0x01};
char idletime[2] = {0x0c, 0xff};
int i;
for(i=0;i<TPD_WAKEUP_TRIAL;i++) {
i2c_master_send(i2c_client,wakeup,2);
if(i2c_master_send(i2c_client,wakeup,2)==2) break;
msleep(TPD_WAKEUP_DELAY);
}
i2c_master_send(i2c_client,gesture,2);
i2c_master_send(i2c_client,threshold,2);
i2c_master_send(i2c_client,idletime,2);
i2c_master_send(i2c_client,sleeptime,2);
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
//MT6516_EINTIRQUnmask(CUST_EINT_TOUCH_PANEL_NUM);
}
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_enable_ext_md_exp_irq(void)
{
#ifdef CONFIG_OF
unsigned long flags;
#endif
EMD_MSG_INF("chr","cm_enable_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) {
enable_irq(ext_md_exp_eint.irq_id);
ext_md_exp_eint.irq_en_cnt = 1;
}
}
spin_unlock_irqrestore(&ext_md_exp_eint.lock, flags);
#else
mt_eint_unmask(ext_md_exp_eint.irq_id);
#endif
}
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);
}
static int mhl_irq_kthread(void *data)
{
struct sched_param param = { .sched_priority = RTPM_PRIO_SCRN_UPDATE };
sched_setscheduler(current, SCHED_RR, ¶m);
for( ;; ) {
set_current_state(TASK_INTERRUPTIBLE);
wait_event_interruptible(mhl_irq_wq, atomic_read(&mhl_irq_event));
set_current_state(TASK_RUNNING);
printk("mhl_irq_kthread, mhl irq received\n");
//hdmi_update_impl();
atomic_set(&mhl_irq_event, 0);
SiiMhlTxDeviceIsr();
if (kthread_should_stop())
break;
#ifdef CUST_EINT_MHL_NUM
mt_eint_unmask(CUST_EINT_MHL_NUM);
#endif
}
return 0;
}
