/**
* Function called when the user closes file
*
* @return 0 on success, a negative value on failure.
*/
int
open_nfc_custom_release(struct inode *inode, struct file *filp)
{
struct open_nfc_custom_device *p_device = filp->private_data;
ENTER();
if (!p_device) {
printk("open_nfc_custom_release: Internal error p_device is missing\n");
return -ENODEV;
}
mutex_lock(&p_device->mutex);
opennfc_struct_cleanup(p_device); /* Go back to PROBED state */
#ifndef WAKE_AND_PURGE_I2C_ON_LOAD
// disable_irq(p_device->irqout);
mt65xx_eint_mask(CUST_EINT_NFC_NUM);
#endif /* WAKE_AND_PURGE_I2C_ON_LOAD */
mutex_unlock(&p_device->mutex);
return 0;
}
int hdmi_drv_power_on(void)
{
int ret = 0;
HDMI_FUNC();
mt65xx_eint_mask(CUST_EINT_MHL_NUM);
#if 1
SiiMhlTxHwGpioResume();
//pmic_config_interface(0x87,0x1,0x01,0x0);
/* Vanzo:lubaoquan on: Tue, 21 May 2013 22:35:29 +0800
* TODO: replace this line with your comment
*/
hwPowerOn(MT65XX_POWER_LDO_VGP5, VOL_1200, "HDMI");
// End of Vanzo: lubaoquan
#endif
//msleep(100);
SiiMhlTxHwReset(5,5);
//xuecheng
HalInstallCheckDeviceCB(SiiCheckDevice);
HalAcquireIsrLock();
siHdmiTx_VideoSel(HDMI_720P60);
siHdmiTx_AudioSel(I2S_44);
ret = SiiMhlTxInitialize(EVENT_POLL_INTERVAL_MS);
HalReleaseIsrLock();
mt65xx_eint_unmask(CUST_EINT_MHL_NUM);
return ret;
}
/* Function to manage low power suspend */
void tpd_suspend(struct early_suspend *h)
{
if(tpd_debuglog==1) {
TPD_DMESG("[mtk-tpd] %s\n", __FUNCTION__);
}
tpd_halt = 1;
while(1){
if(tpd_flag == 1) msleep(1000);
else break;
}
mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
#ifdef TPD_POWER_SOURCE_CUSTOM
hwPowerDown(TPD_POWER_SOURCE_CUSTOM, "TP");
#endif
#ifdef TPD_POWER_SOURCE_1800
hwPowerDown(TPD_POWER_SOURCE_1800, "TP");
#endif
#ifdef GPIO_CTP_EN_PIN
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
mdelay(1);
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);
}
static void _mt8193_irq_handler(void)
{
MT8193_DRV_FUNC();
atomic_set(&mt8193_nlh_event, 1);
wake_up_interruptible(&mt8193_nlh_wq);
mt65xx_eint_mask(CUST_EINT_EINT_HDMI_HPD_NUM);
}
void inno_irq_release(void)
{
mt65xx_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 oem_gpio_irq_mask(int gpio)
{
int irq;
irq = oem_gpio_to_irq(gpio);
if(irq < 0){
return ;
}
mt65xx_eint_mask(irq);
}
static void pn544_disable_irq(struct pn544_dev *pn544_dev)
{
unsigned long flags;
spin_lock_irqsave(&pn544_dev->irq_enabled_lock, flags);
if (pn544_dev->irq_enabled) {
mt65xx_eint_mask(EINT_NUM);
pn544_dev->irq_enabled = false;
}
spin_unlock_irqrestore(&pn544_dev->irq_enabled_lock, flags);
}
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);
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);
//LINE<JIRA_ID><DATE20130320><BUG_INFO>zenghaihui
if(g_tp_charger_flag != g_pre_tp_charger_flag)
{
g_pre_tp_charger_flag = g_tp_charger_flag;
g_need_refresh_tp_flag = 1;
}
if(g_need_refresh_tp_flag)
{
g_need_refresh_tp_flag = 0;
fts_ft5316_switch_charger_status(g_tp_charger_flag);
}
if (!tpd_touchinfo(ts, &touch_point)) {
if(ts->pcount > 0)
{
for ( i=0; i < ts->pcount; i++ )
{
tpd_down(ts, touch_point[i].x, touch_point[i].y, touch_point[i].pressure, touch_point[i].touch_id);//<20120714><for multi-touch id>wangyanhui
}
input_sync(tpd->dev);
}
else
{
tpd_up(ts, touch_point[0].x, touch_point[0].y, touch_point[0].pressure, touch_point[0].touch_id);
input_sync(tpd->dev);
}
}
mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
}while(!kthread_should_stop());
mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
return 0;
}
static void mt_combo_bgf_request_irq(void *data)
{
mt65xx_eint_set_sens(CUST_EINT_COMBO_BGF_NUM, CUST_EINT_COMBO_BGF_SENSITIVE);
mt65xx_eint_set_hw_debounce(CUST_EINT_COMBO_BGF_NUM, CUST_EINT_COMBO_BGF_DEBOUNCE_CN);
mt65xx_eint_registration(CUST_EINT_COMBO_BGF_NUM,
CUST_EINT_COMBO_BGF_DEBOUNCE_EN,
CUST_EINT_COMBO_BGF_POLARITY,
combo_bgf_eirq_handler,
0);
mt65xx_eint_mask(CUST_EINT_COMBO_BGF_NUM); /*2*/
return;
}
//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;
mt65xx_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);
}
}
static void combo_sdio_request_eirq(sdio_irq_handler_t irq_handler, void *data)
{
mt65xx_eint_set_sens(combo_sdio_eint_num, CUST_EINT_WIFI_SENSITIVE); /*CUST_EINT_WIFI_NUM */
mt65xx_eint_set_hw_debounce(combo_sdio_eint_num, CUST_EINT_WIFI_DEBOUNCE_CN); /*CUST_EINT_WIFI_NUM */
mt65xx_eint_registration(combo_sdio_eint_num/*CUST_EINT_WIFI_NUM */,
CUST_EINT_WIFI_DEBOUNCE_EN,
CUST_EINT_WIFI_POLARITY,
combo_sdio_eirq_handler_stub,
0);
mt65xx_eint_mask(combo_sdio_eint_num);/*CUST_EINT_WIFI_NUM */
combo_sdio_eirq_handler = irq_handler;
combo_sdio_eirq_data = data;
}
static ssize_t pn544_dev_write(struct file *filp, const char __user *buf, size_t count, loff_t *offset)
{
struct pn544_dev *pn544_dev;
int ret, i;
char tmp[MAX_BUFFER_SIZE];
pn544_dev = filp->private_data;
if (count > MAX_BUFFER_SIZE)
count = MAX_BUFFER_SIZE;
if (copy_from_user(tmp, buf, count)) {
pr_err("pn544 %s : failed to copy from user space\n", __func__);
return -EFAULT;
}
printk("pn544 copy from user:"******" %02X", tmp[i]);
}
printk("\n");
if (pn544_dev->irq_enabled) {
mt65xx_eint_mask(EINT_NUM);
pn544_dev->irq_enabled = false;
printk("pn544 write mask eint\n");
}
printk("pn544 %s : writing %zu bytes.\n", __func__, count);
/* Write data */
ret = i2c_master_send(pn544_dev->client, tmp, count);
if (ret != count) {
pr_err("pn544 %s : i2c_master_send returned %d\n", __func__, ret);
ret = -EIO;
}
printk("pn544 PC->IFD:");
for(i = 0; i < count; i++) {
printk(" %02X", tmp[i]);
}
printk("\n");
if (!pn544_dev->irq_enabled) {
mt65xx_eint_unmask(EINT_NUM);
pn544_dev->irq_enabled = true;
printk("pn544 write unmask eint\n");
}
return ret;
}
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;
mt65xx_eint_set_sens(mtk_wcn_cmb_sdio_eint_num, CUST_EINT_WIFI_SENSITIVE); /*CUST_EINT_WIFI_NUM */
mt65xx_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);
mt65xx_eint_registration(mtk_wcn_cmb_sdio_eint_num/*CUST_EINT_WIFI_NUM */,
CUST_EINT_WIFI_DEBOUNCE_EN,
CUST_EINT_WIFI_POLARITY,
mtk_wcn_cmb_sdio_eirq_handler_stub,
0);
mt65xx_eint_mask(mtk_wcn_cmb_sdio_eint_num);/*CUST_EINT_WIFI_NUM */
}
/**
* Device/Driver binding: probe
*
* @return 0 if successfull, or error code
*/
static int
opennfc_probe(struct i2c_client *client, const struct i2c_device_id *idp)
{
int rc = 0;
struct open_nfc_custom_device *p_device = open_nfc_p_device;
ENTER();
if (!p_device) {
printk("opennfc_probe: Internal error p_device is missing\n");
return -ENODEV;
}
mutex_lock(&p_device->mutex);
if (p_device->state != CUSTOM_INIT) {
rc = EEXIST;
goto out;
}
p_device->i2c_client = client;
i2c_set_clientdata(client, p_device);
#if 0
rc = request_irq(p_device->irqout, open_nfc_i2c_interrupt, IRQF_TRIGGER_HIGH, "IRQOUT_input", p_device);
if (rc < 0) {
printk(KERN_ERR "opennfc_probe : failed to register IRQOUT\n");
goto out;
}
#endif
/* The IRQ can be trigged here at most once, because we are holding the mutex (cannot be re-enabled after disable) */
#ifndef WAKE_AND_PURGE_I2C_ON_LOAD
// disable_irq(p_device->irqout);
mt65xx_eint_mask(CUST_EINT_NFC_NUM);
#endif /* WAKE_AND_PURGE_I2C_ON_LOAD */
p_device->state = CUSTOM_PROBED;
out:
mutex_unlock(&p_device->mutex);
return rc;
}
void hdmi_drv_power_on(void)
{
HDMI_FUNC();
mt65xx_eint_mask(CUST_EINT_HDMI_HPD_NUM);
SiiMhlTxHwGpioResume();
pmic_config_interface(0x87,0x1,0x01,0x0);
//msleep(100);
SiiMhlTxHwReset(50,200);
//xuecheng
HalInstallCheckDeviceCB(SiiCheckDevice);
HalAcquireIsrLock();
siHdmiTx_VideoSel(HDMI_720P60);
siHdmiTx_AudioSel(I2S_44);
SiiMhlTxInitialize(EVENT_POLL_INTERVAL_MS);
HalReleaseIsrLock();
mt65xx_eint_unmask(CUST_EINT_HDMI_HPD_NUM);
}
static irqreturn_t
open_nfc_i2c_interrupt(int irq, void *dev_id)
{
struct open_nfc_custom_device *p_device = open_nfc_p_device;
ENTER();
// disable_irq_nosync(irq);
mt65xx_eint_mask(CUST_EINT_NFC_NUM);
if (!p_device) {
printk("open_nfc_i2c_interrupt: Internal error p_device is missing, disabing the IRQ\n");
} else {
/* continue the processing outside the irq handler */
schedule_work(&p_device->irqout_event_work);
}
return IRQ_HANDLED;
}
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:
mt65xx_eint_unmask(CUST_EINT_WIFI_NUM);
break;
case PIN_STA_EINT_DIS:
mt65xx_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;
}
static void hall_eint_work_callback(struct work_struct *work)
{
bool cover;
u8 old_state = hall_cover_state;
mt65xx_eint_mask(CUST_EINT_MHALL_NUM);
DOCK_DEBUG("[hall] hall_cover_state = %d\n", hall_cover_state );
hall_cover_state = !mt_get_gpio_in(GPIO_MHALL_EINT_PIN);
if ( old_state == hall_cover_state )
{
DOCK_ERR("[hall] no hall state changed!!!\n");
//mt65xx_eint_unmask(CUST_EINT_MHALL_NUM);
//return;
}
switch_set_state((struct switch_dev *)&hall_data, hall_cover_state);
//input_report_switch(kpd_input_dev, SW_LID, hall_cover_state);
//input_sync(kpd_input_dev);
mt65xx_eint_set_polarity(CUST_EINT_MHALL_NUM, !old_state);
mt65xx_eint_unmask(CUST_EINT_MHALL_NUM);
}
/* platform device functions */
void tpd_suspend(struct early_suspend *h)
{
TPD_DEBUG("[mtk-tpd] Suspend++.\n");
if(isUpgrade ==1)
{
TPD_DEBUG("Magnum tp is Upgrading.....\r\n");
return;
}
mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
if(tpd_down_state){
tpd_up(down_x,down_y,NULL);
//Ivan input_report_abs(tpd->dev, ABS_MT_TRACKING_ID, 0);
input_sync(tpd->dev);
msleep(200);
}
tpd_status = 0;
tinno_tp_power_off();
TPD_DEBUG("[mtk-tpd] Suspend--.tpd_down_state=%d\n",tpd_down_state);
if (ft5316_i2c_client == NULL)
return;
}
/**
* Specific cleanup, when driver module is removed.
*
* @return void
*/
void
open_nfc_custom_exit(void)
{
struct open_nfc_custom_device *p_device;
ENTER();
p_device = open_nfc_p_device;
if (p_device == NULL)
return;
/* Go back to PROBED state if needed */
opennfc_struct_cleanup(p_device);
/* Remove the IRQ handler */
// free_irq(p_device->irqout, p_device);
mt65xx_eint_mask(CUST_EINT_NFC_NUM);
/* stop any pending work */
cancel_work_sync(&p_device->irqout_event_work);
i2c_del_driver(&open_nfc_i2c_driver);
/* release the other GPIO */
gpio_free(GPIO_NFC_VEN_PIN);
gpio_free(GPIO_NFC_EINT_PIN);
del_timer(&p_device->sResetTimer);
del_timer(&p_device->rx_timer);
mutex_destroy(&p_device->mutex);
/* free the custom device context */
kfree(p_device);
open_nfc_p_device = NULL;
}
/* Function to manage low power suspend */
void tpd_suspend(struct early_suspend *h)
{
//if(tpd_debuglog==1) {
//TPD_DMESG("[mtk-tpd] %s\n", __FUNCTION__);
//}
tpd_halt = 1;
mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
#if 0
uint8_t bfffer[2] = {0x01,0x00};
tpd_i2c_master_rs_send(i2c_client,bfffer,1<<8|1);
bfffer[1] &= ~0x0E;
tpd_i2c_master_send(i2c_client,bfffer,2);
#ifdef TPD_HAVE_POWER_ON_OFF
/*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
#endif
tpd_hw_disable();
}
static void combo_sdio_disable_eirq(void)
{
mt65xx_eint_mask(combo_sdio_eint_num); /* CUST_EINT_WIFI_NUM */
}
void mt_combo_bgf_disable_irq(void)
{
mt65xx_eint_mask(CUST_EINT_COMBO_BGF_NUM);
return;
}
static void mtk_wcn_cmb_sdio_disable_eirq(void)
{
mt65xx_eint_mask(mtk_wcn_cmb_sdio_eint_num); /* CUST_EINT_WIFI_NUM */
}
static int gt927_diffdata_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data)
{
int driving_num = 0;
int sensing_num = 0;
int i;
char *ptr = page;
u8 *buf;
mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
driving_num += (config[27 + GTP_ADDR_LENGTH] & 0x1F);
driving_num += (config[28 + GTP_ADDR_LENGTH] & 0x1F);
sensing_num += (config[29 + GTP_ADDR_LENGTH] & 0x0F);
sensing_num += (config[29 + GTP_ADDR_LENGTH] & 0xF0) >> 4;
GTP_INFO("TPD driving_num %d", driving_num);
GTP_INFO("TPD sensing_num %d", sensing_num);
buf = (u8 *)kzalloc(driving_num * sensing_num, GFP_KERNEL);
//0x8040 write 1 for rawdata/diff access
buf[0] = 1;
i2c_write_bytes(i2c_client_point, GTP_REG_SLEEP, buf, 1);
// wait for normal INT finished
while (tpd_flag == 1)
{
msleep(20);
}
msleep(100);
//check for raw data ready
i2c_read_bytes(i2c_client_point, GTP_READ_COOR_ADDR, buf, 1);
while (buf[0] == 0)
{
//wait for data ready
GTP_INFO("Wati for raw data");
i2c_read_bytes(i2c_client_point, GTP_READ_COOR_ADDR, buf, 1);
GTP_INFO("0x814E : %2X", buf[0]);
buf[0] &= 0x80;
msleep(5);
}
i2c_read_bytes(i2c_client_point, GTP_DIFFDATA_REG, buf, driving_num * sensing_num);
for (i = 0 ; i < driving_num * sensing_num; i = i + 1)
{
ptr += sprintf(ptr, "%d\t", buf[i]);
if ((i % (sensing_num)) == (sensing_num - 1))
ptr += sprintf(ptr, "\n");
}
//clear data ready status
buf[0] = 0;
i2c_write_bytes(i2c_client_point, GTP_READ_COOR_ADDR, buf, 1);
//0x8040 write 0 for leaving rawdata/diff access mode
buf[0] = 0;
i2c_write_bytes(i2c_client_point, GTP_REG_SLEEP, buf, 1);
mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
kfree(buf);
*eof = 1;
return (ptr - page);
}
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 ){
printk("[ft5x06] %s:Already probed a TP, needn't to probe any more!",__func__);
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(tinno_ts_data), GFP_KERNEL);
if (ts == NULL) {
ret = -ENOMEM;
goto err_alloc_data_failed;
}
printk("[ft5x06] %s:TPD enter tpd_probe ts=0x%p, TPD_RES_X=%d, TPD_RES_Y=%d, addr=0x%x\n", __func__, ts, TPD_RES_X, TPD_RES_Y, client->addr);
memset(ts, 0, sizeof(tinno_ts_data));
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_5x06_hw_init();
msleep(120);
fts_iic_init(ts);
if ( fts_5x06_isp_init(ts) ){
goto err_isp_register;
}
while (iRetry) {
ret = ft5x06_get_vendor_version(ts, &panel_vendor, &panel_version);
if ( panel_version < 0 || panel_vendor<0 || ret<0 ){
printk("[ft5x06] %s: Product version is %d\n", __func__, panel_version);
fts_5x06_hw_reset();
}else{
printk("[ft5x06] %s: panel_vendor =%x, panel_version=%x\n", __func__, panel_vendor, panel_version);
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);
ts->thread = kthread_run(touch_event_handler, ts, TPD_DEVICE);
if (IS_ERR(ts->thread)){
retval = PTR_ERR(ts->thread);
printk("[ft5x06] %s: failed to create kernel thread: %d\n", __func__, retval);
goto err_start_touch_kthread;
}
tpd_load_status = 1;
mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
printk("[ft5x06] %s:Touch Panel Device(%s) Probe PASS\n", __func__, fts_get_vendor_name(panel_vendor));
//#if defined (TINNO_ANDROID_S9091) || defined (TINNO_ANDROID_S8121) || defined(TINNO_ANDROID_S8111B)
#if 1
{
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;
}
#endif
//LINE<JIRA_ID><DATE20130402><add for focaltech debug>zenghaihui
#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
//LINE<JIRA_ID><DATE20130320><add charger flag>zenghaihui
g_need_refresh_tp_flag = 1;
return 0;
err_start_touch_kthread:
mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
err_get_version:
err_isp_register:
#ifdef CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
hwPowerDown(MT65XX_POWER_LDO_VGP5, "touch");
#endif
fts_5x06_isp_exit();
mutex_destroy(&ts->mutex);
g_pts = NULL;
kfree(ts);
err_alloc_data_failed:
err_check_functionality_failed:
printk("[ft5x06] %s:Touch Panel Device Probe FAIL\n", __func__);
return -1;
}
static void tpd_suspend(struct early_suspend *h)
{
int ret = 0;
int iRetry = 5;
const char data = 0x3;
if ( g_pts ){
CTP_DBG("TPD enter sleep\n");
if (atomic_read(&g_pts->isp_opened)){
CTP_DBG("isp is already opened.");
return;
}
mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
mutex_lock(&g_pts->mutex);//Unlock on resume
#ifdef CONFIG_TOUCHSCREEN_FT5X05_DISABLE_KEY_WHEN_SLIDE
fts_5x06_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);
#if 1 // def MT6577
hwPowerDown(MT65XX_POWER_LDO_VGP5, "touch");
#else
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
#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);
#if 1 // def MT6577
hwPowerDown(MT65XX_POWER_LDO_VGP5, "touch");
#else
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_5x06_hw_init();
}else{
break;
}
iRetry--;
msleep(100);
}
#endif//CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
atomic_set( &g_pts->ts_sleepState, 1 );
}
}
void cm_disable_ext_md_wakeup_irq(void)
{
mt65xx_eint_mask(CUST_EINT_DT_EXT_MD_WK_UP_NUM);
}
void cm_disable_ext_md_wdt_irq(void)
{
mt65xx_eint_mask(CUST_EINT_DT_EXT_MD_WDT_NUM);
}
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) {
mt65xx_eint_set_sens(CUST_EINT_COMBO_BGF_NUM, CUST_EINT_COMBO_BGF_SENSITIVE);
mt65xx_eint_set_hw_debounce(CUST_EINT_COMBO_BGF_NUM, CUST_EINT_COMBO_BGF_DEBOUNCE_CN);
mt65xx_eint_registration(CUST_EINT_COMBO_BGF_NUM,
CUST_EINT_COMBO_BGF_DEBOUNCE_EN,
CUST_EINT_COMBO_BGF_POLARITY,
wmt_plat_bgf_eirq_cb,
0);
mt65xx_eint_mask(CUST_EINT_COMBO_BGF_NUM); /*2*/
}
else if (PIN_STA_EINT_EN == state) {
mt65xx_eint_unmask(CUST_EINT_COMBO_BGF_NUM);
WMT_DBG_FUNC("WMT-PLAT:BGFInt (en) \n");
}
else if (PIN_STA_EINT_DIS == state) {
mt65xx_eint_mask(CUST_EINT_COMBO_BGF_NUM);
WMT_DBG_FUNC("WMT-PLAT:BGFInt (dis) \n");
}
else {
mt65xx_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
mt65xx_eint_set_sens(CUST_EINT_COMBO_ALL_NUM, CUST_EINT_COMBO_ALL_SENSITIVE);
mt65xx_eint_set_hw_debounce(CUST_EINT_COMBO_ALL_NUM, CUST_EINT_COMBO_ALL_DEBOUNCE_CN);
mt65xx_eint_registration(CUST_EINT_COMBO_ALL_NUM,
CUST_EINT_COMBO_ALL_DEBOUNCE_EN,
CUST_EINT_COMBO_ALL_POLARITY,
combo_bgf_eirq_handler,
0);
#endif
mt65xx_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) {
/*mt65xx_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) {
mt65xx_eint_mask(CUST_EINT_COMBO_ALL_NUM);
WMT_DBG_FUNC("WMT-PLAT:ALLInt (DIS but not used yet) \n");
}
else {
mt65xx_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;
}