bkgpl/cyb4_linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
cyb4_linux/drivers/input/touchscreen/s3c_ts_iic.c

1604 lines
46 KiB
C
Raw Blame History

/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Copyright (c) 2009 Tony YC Huang <tony.yc.huang@qisda.com>
*
*/
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/arch/regs-irq.h>
#include <asm/arch/map.h>
#include <linux/miscdevice.h>
#include "s3c_ts_iic.h"
#include <asm/arch/regs-gpio.h>
//Tony test
#include <linux/kthread.h>
#include <linux/sched.h>
/* Qisda, howard hsu, 2010/01/27, TOUCH firmware update { */
#include <asm/uaccess.h> //for copy_from_user
/* } Qisda, howard hsu, 2010/01/27, TOUCH firmware update */
//Aaron, add for the feature of buffered touch data
#define USE_BUFFERED_TOUCH_DATA
/* Aaron, 20090122, add for CPU sleep prevention */
/* prevent cpu from sleep when any event happens */
#ifdef CONFIG_PM_PLATFORM_POWER_SAVING
# define CPU_SLEEP_PREVENT
#endif //#ifdef CONFIG_PM_PLATFORM_POWER_SAVING
int Cyio_PushEvent (char eventId, char unique);
#ifdef USE_BUFFERED_TOUCH_DATA
static int go_in_suspend = 0;
#endif
#ifdef CPU_SLEEP_PREVENT
extern unsigned int g_wakeup_event_occurs;
#endif
//Tony test
//#define IN_2416_EMU_BOARD
//#define QISDA_TEST_GPIO_PROBE
//Qisda Tony 090415 [
//#define POLLING_MODE
//#define KTHREAD_USE
//Qisda Tony 090415 ]
#define DEVICE_NAME "s3c2410-ts-iic"
#define TRUE 1
#define FALSE 0
#define printk(x...)
//#ifdef IN_2416_EMU_BOARD
//#define GPIO_NUM (0x3)
//#else
//#define GPIO_NUM (0x2)
//#endif
#define KEY_BUF_SIZE 1
struct s3c_ts_iic
{
struct input_dev *dev;
struct i2c_client *client;
struct platform_device *pdev;
long xp;
long yp;
unsigned int polling_time;
};
struct t_point
{
short x;
short y;
};
static struct platform_driver s3c_ts_iic_driver;
static struct work_struct workq_readdata;
static struct s3c_ts_iic *ts_iic;
static char *s3c_ts_iic_name = "TouchScreen Of IIC Type";
#ifdef QISDA_TEST_GPIO_PROBE
static void __iomem *g_pGPIOReg_GPFCON;
#endif
struct t_point keybuffer[KEY_BUF_SIZE];
static short IdxBottom = 0;
static struct timer_list touch_iic_timer_qisda;
#ifdef POLLING_MODE
static int need_calibration = FALSE;
#endif
#ifdef KTHREAD_USE
static wait_queue_head_t wait;
static struct task_struct *kmain_task = NULL;
#endif
//Tony test
#define NEW_TCOM_BOARD
//static void touch_iic_disable_interrupt(void) { printk("touch_iic_disable_interrupt\n"); writel(readl(S3C24XX_EINTMASK) | (0x1<<GPIO_NUM), S3C24XX_EINTMASK); }
//static void touch_iic_enable_interrupt(void) { printk("touch_iic_enable_interrupt\n"); writel(readl(S3C24XX_EINTMASK) & ~(0x1<<GPIO_NUM), S3C24XX_EINTMASK); }
//static void touch_iic_clear_interrupt_pending(void) { printk("touch_iic_clear_interrupt_pending\n"); writel(0x1<<GPIO_NUM, S3C24XX_EINTPEND); }
//static void touch_iic_set_interrupt_method(int eSM) {writel(readl(S3C24XX_EXTINT0) & ~(0x7<<(GPIO_NUM<<2)) | (eSM<<(GPIO_NUM<<2)),S3C24XX_EXTINT0);}
static void touhc_iic_timer_handler_qisda (unsigned long data)
{
schedule_work(&workq_readdata);
}
/*kit.mod 2009/11/17*/
#define TOUCH_IIC_CALIBRATION 1
#define TOUCH_IIC_SET_POLLING_TIME 2
#define TOUCH_DEVICE_POWER_STATE 3
#define TOUCH_DEVICE_ACTIVE_STATE 0 //Power State D0
#define TOUCH_DEVICE_SLEEP_STATE 1 //Power State D1
#define TOUCH_DEVICE_DEEPSLEEP_STATE 2 //Power State D2
#define TOUCH_DEVICE_POWEROFF_STATE 3 //Power State D3
/*kit.end*/
/* Qisda, howard hsu, 2010/01/27, TOUCH firmware update { */
#define TOUCH_IIC_FW_UPDATE 4
#define TOUCH_IIC_GET_FW_INFO 6 /* get fw version */
/* } Qisda, howard hsu, 2010/01/27, TOUCH firmware update */
/*kit.add 2010/01/30*/
#define TOUCH_IIC_T_SENSOR_ENABLE 5
/*kit.end*/
/*kit.add 2009/11/16*/
#define TOUCH_ACTIVE_POLLING_TIME 20 //default value
#define TOUCH_SLEEP_POLLING_TIME 20 //10
#define TOUCH_DEEPSLEEP_POLLING_TIME 20 //1
/*kit.end*/
/*kit.add 2009/11/04*/
static short isTouchPowerOff = 0;
static short touchPowerState = TOUCH_DEVICE_ACTIVE_STATE;
static short touchPollingTime = TOUCH_ACTIVE_POLLING_TIME;
extern unsigned int wkup_srce;
/*kit.end*/
/*
static void touch_iic_port_initialize(void)
{
#ifndef IN_2416_EMU_BOARD
//Set GPG3 pull-up, enable touch panel functions
writel(readl(S3C2410_GPGDAT) | (1<<3), S3C2410_GPGDAT);
writel(readl(S3C2410_GPGUP) | (0x2<<6),S3C2410_GPGUP);
writel(readl(S3C2410_GPGCON) | (0x1<<6),S3C2410_GPGCON);
#endif
//Qisda Tony 090415 [
#ifndef POLLING_MODE
#ifdef IN_2416_EMU_BOARD
s3c2410_gpio_cfgpin(S3C2410_GPF3, S3C2410_GPF3_EINT3);
s3c2410_gpio_pullup(S3C2410_GPF3, 2);
#else
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_EINT2);
s3c2410_gpio_pullup(S3C2410_GPF2, 2);
#endif
#endif
//Qisda Tony 090415 ]
}
*/
/*
static void touch_iic_init(void)
{
printk("touch_iic_init\n");
touch_iic_port_initialize();
//Qisda Tony 090415 [
#ifndef POLLING_MODE
touch_iic_disable_interrupt();
touch_iic_set_interrupt_method(S3C2410_EXTINT_FALLEDGE);
//Tony test
#ifndef KTHREAD_USE
init_timer(&touch_iic_timer_qisda);
touch_iic_timer_qisda.function =touhc_iic_timer_handler_qisda;
#endif
#endif
//Qisda Tony 090415 ]
memset(keybuffer,0x0,sizeof(keybuffer));
}
*/
#ifdef USE_BUFFERED_TOUCH_DATA
# define BUFFERED_DATA_LEN 16
/* Aaron: two coordinates on each point */
/* two bytes for each coordinate */
/* block read for max byte num=32, ((32/2)/2)=8 */
/* <=CHECK_LEN_EACH_TIME shall NOT be larger than 8, sync with qisda_iic.c */
# define CHECK_LEN_EACH_TIME 8
static int IsPanelPressed = 0;
static void bufferd_touch_point_handler (int WithRelease)
{
/* [0] is the index of check count */
/* [1] is the check length */
/* buffered data start from [2],x1_y1_x2_y2_x3_y3 */
int buffered_data[BUFFERED_DATA_LEN * 2 + (2 + 1)] = { 0 };
int i, IndexOffset;
//printk("bufferd_touch_point_handler: start\n");
buffered_data[1] = CHECK_LEN_EACH_TIME;
for ( i = 0; i < (BUFFERED_DATA_LEN / CHECK_LEN_EACH_TIME); i++ )
{
buffered_data[0] = i;
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_READ_BUFFERED_POSITION, buffered_data);
}
//Aaron: send input event.
if ( (buffered_data[2] == 0) && (buffered_data[3] == 0) )
{
/* If buffered data is empty, do nothing before return*/
return;
}
for ( i = 1; i < (BUFFERED_DATA_LEN + 1); i++ )
{
IndexOffset = 2 * i;
/* check if next point data is zero, which means no more data. */
if ( (i == BUFFERED_DATA_LEN) ||
(!buffered_data[IndexOffset + 2] && !buffered_data[IndexOffset + 2 + 1]) )
{
//TODO: send release event.
input_report_abs(ts_iic->dev, ABS_X, buffered_data[IndexOffset]);
input_report_abs(ts_iic->dev, ABS_Y, buffered_data[IndexOffset + 1]);
// //for debug
// //printk("\n bufferd_touch_point_handler: panel is touching(%d,%d)[%d]\n",buffered_data[IndexOffset],buffered_data[IndexOffset + 1],i);
if ( WithRelease )
{
if ( !IsPanelPressed )
{
/* in case that only one buffered data with release */
input_report_key(ts_iic->dev, BTN_TOUCH, 1);
input_report_abs(ts_iic->dev, ABS_PRESSURE, 1);
//printk("bufferd_touch_point_handler: panel is Pressed(only one buffered data)\n");
//maybe not necessary//IsPanelPressed = 1;
}
input_report_key(ts_iic->dev, BTN_TOUCH, 0);
input_report_abs(ts_iic->dev, ABS_PRESSURE, 0);
IsPanelPressed = 0;
//printk("bufferd_touch_point_handler: panel is Released(%d,%d)[%d]\n",buffered_data[IndexOffset],buffered_data[IndexOffset + 1],i);
}
input_sync(ts_iic->dev);
break;
}
//TODO: send press event
input_report_abs(ts_iic->dev, ABS_X, buffered_data[IndexOffset]);
input_report_abs(ts_iic->dev, ABS_Y, buffered_data[IndexOffset + 1]);
if ( !IsPanelPressed )
{
input_report_key(ts_iic->dev, BTN_TOUCH, 1);
input_report_abs(ts_iic->dev, ABS_PRESSURE, 1);
IsPanelPressed = 1;
printk("bufferd_touch_point_handler: panel is Pressed(%d,%d)\n", buffered_data[IndexOffset], buffered_data[IndexOffset + 1]);
// } else {
// //for debug
// printk("\n bufferd_touch_point_handler: panel is touching(%d,%d)[%d]\n",buffered_data[IndexOffset],buffered_data[IndexOffset + 1],i);
}
input_sync(ts_iic->dev);
}
}
#endif
static void ts_iic_workqueue (struct work_struct *work)
{
static int startpoint[2];
static int emptyKeyBuffer = TRUE;
int curpoint[2];
short i = 0;
#ifdef NEW_TCOM_BOARD
static int zeroCount = 0;
static int prevpoint[2];
#endif
//Qisda Tony 090415 [
#ifdef POLLING_MODE
# ifdef KTHREAD_USE
for (;; )
{
//This only get the interrupt periodically. No while loop in workqueue, use polling....
//Tony test
//Tony test
# ifndef NEW_TCOM_BOARD
# else
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_READ_POSITION, curpoint);
if ( (curpoint[0] == 0) || (curpoint[1] == 0) )
{
if ( emptyKeyBuffer == TRUE ) goto finished;
# ifdef NEW_TCOM_BOARD
else
{
if ( zeroCount < 3 )
{
zeroCount++;
goto finished;
}
else
{
//printk("\nooooo %d,%d\n",curpoint[0],curpoint[1]);
goto release;
}
}
# else
else goto release;
# endif
}
//key input
ts_iic->xp = keybuffer[IdxBottom].x = curpoint[0];
ts_iic->yp = keybuffer[IdxBottom].y = curpoint[1];
input_report_abs(ts_iic->dev, ABS_X, ts_iic->xp);
input_report_abs(ts_iic->dev, ABS_Y, ts_iic->yp);
input_report_key(ts_iic->dev, BTN_TOUCH, 1);
input_report_abs(ts_iic->dev, ABS_PRESSURE, 1);
input_sync(ts_iic->dev);
//printk("\n--%d,%d,%d\n",curpoint[0],curpoint[1],IdxBottom);
# ifdef NEW_TCOM_BOARD
prevpoint[0] = curpoint[0];
prevpoint[1] = curpoint[1];
# endif
if ( emptyKeyBuffer == TRUE )
{
emptyKeyBuffer = FALSE;
memcpy(startpoint, curpoint, sizeof (startpoint));
printk("\n--%d,%d,%d\n", startpoint[0], startpoint[1], IdxBottom);
}
IdxBottom++;
if ( IdxBottom >= KEY_BUF_SIZE )
IdxBottom = 0;
goto finished;
release:
printk("++%d,%d,%d\n", startpoint[0], startpoint[1], IdxBottom);
for ( i = 0; i < KEY_BUF_SIZE; ++i )
printk("%d,%d\n", keybuffer[i].x, keybuffer[i].y);
i = IdxBottom - 1;
if ( i <= -1 )
i = KEY_BUF_SIZE - 1;
startpoint[0] -= keybuffer[i].x;
startpoint[1] -= keybuffer[i].y;
//Put your gesture function here!!!!
/*if(( startpoint[1]<-50) || (startpoint[1]>50))
printk(KERN_ERR "ts_iic_workqueue okokokokokokokokok\n");*/
// Key input
if ( Cyio_PushEvent('R', 1) >= 0 )
{
Cyio_PushEvent((keybuffer[0].x >> 8) & 0xFF, 0);
Cyio_PushEvent((keybuffer[0].x >> 0) & 0xFF, 0);
Cyio_PushEvent((keybuffer[0].y >> 8) & 0xFF, 0);
Cyio_PushEvent((keybuffer[0].y >> 0) & 0xFF, 0);
}
memset(keybuffer, 0x0, sizeof (keybuffer));
memset(startpoint, 0x0, sizeof (startpoint));
IdxBottom = 0;
emptyKeyBuffer = TRUE;
//Key input
ts_iic->xp = ts_iic->yp = 0;
input_report_key(ts_iic->dev, BTN_TOUCH, 0);
input_report_abs(ts_iic->dev, ABS_PRESSURE, 0);
input_sync(ts_iic->dev);
# ifdef NEW_TCOM_BOARD
prevpoint[0] = 0;
prevpoint[1] = 0;
zeroCount = 0;
# endif
finished:
msleep(15);
# endif //#if NEW_TCOM_BOARD
}
# else //Not Ktherad_use
//This only get the interrupt periodically. No while loop in workqueue, use polling....
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_READ_POSITION, curpoint);
if ( (curpoint[0] == 0) || (curpoint[1] == 0) )
{
if ( emptyKeyBuffer == TRUE ) goto finished;
# ifdef NEW_TCOM_BOARD
else
{
if ( zeroCount < 3 )
{
zeroCount++;
goto finished;
}
else
{
//printk("\nooooo %d,%d\n", curpoint[0], curpoint[1]);
goto release;
}
}
# else
else goto release;
# endif
}
//key input
ts_iic->xp = keybuffer[IdxBottom].x = curpoint[0];
ts_iic->yp = keybuffer[IdxBottom].y = curpoint[1];
input_report_abs(ts_iic->dev, ABS_X, ts_iic->xp);
input_report_abs(ts_iic->dev, ABS_Y, ts_iic->yp);
input_report_key(ts_iic->dev, BTN_TOUCH, 1);
input_report_abs(ts_iic->dev, ABS_PRESSURE, 1);
input_sync(ts_iic->dev);
//printk("\n--%d,%d,%d\n",curpoint[0],curpoint[1],IdxBottom);
if ( emptyKeyBuffer == TRUE )
{
emptyKeyBuffer = FALSE;
memcpy(startpoint, curpoint, sizeof (startpoint));
printk("\n++%d,%d,%d\n", startpoint[0], startpoint[1], IdxBottom);
}
IdxBottom++;
if ( IdxBottom >= KEY_BUF_SIZE )
IdxBottom = 0;
goto finished;
release:
printk("--%d,%d,%d\n", curpoint[0], curpoint[1], IdxBottom);
for ( i = 0; i < KEY_BUF_SIZE; ++i )
printk("%d,%d\n", keybuffer[i].x, keybuffer[i].y);
i = IdxBottom - 1;
if ( i <= -1 )
i = KEY_BUF_SIZE - 1;
startpoint[0] -= keybuffer[i].x;
startpoint[1] -= keybuffer[i].y;
//Put your gesture function here!!!!
/*if(( startpoint[1]<-50) || (startpoint[1]>50))
printk(KERN_ERR "ts_iic_workqueue okokokokokokokokok\n");*/
// Key input
if ( Cyio_PushEvent('R', 1) >= 0 )
{
Cyio_PushEvent((keybuffer[0].x >> 8) & 0xFF, 0);
Cyio_PushEvent((keybuffer[0].x >> 0) & 0xFF, 0);
Cyio_PushEvent((keybuffer[0].y >> 8) & 0xFF, 0);
Cyio_PushEvent((keybuffer[0].y >> 0) & 0xFF, 0);
}
memset(keybuffer, 0x0, sizeof (keybuffer));
memset(startpoint, 0x0, sizeof (startpoint));
IdxBottom = 0;
emptyKeyBuffer = TRUE;
//Key input
ts_iic->xp = ts_iic->yp = 0;
input_report_key(ts_iic->dev, BTN_TOUCH, 0);
input_report_abs(ts_iic->dev, ABS_PRESSURE, 0);
input_sync(ts_iic->dev);
# ifdef NEW_TCOM_BOARD
prevpoint[0] = 0;
prevpoint[1] = 0;
zeroCount = 0;
# endif
finished:
if ( need_calibration )
{
printk("TOUCH_IIC_CALIBRATION...");
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_CALIBRATION, NULL);
need_calibration = FALSE;
printk("done\n");
}
touch_iic_timer_qisda.expires = jiffies + (HZ / ts_iic->polling_time);
mod_timer(&touch_iic_timer_qisda, touch_iic_timer_qisda.expires);
return;
# endif //KTHREAD_USE
#else // NOT POLLING_MODE
//This only get the interrupt
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_READ_POSITION, curpoint);
if ( (curpoint[0] == 0) || (curpoint[1] == 0) )
{
//printk("\n[%d] --%d,%d,%d\n", __LINE__, curpoint[0], curpoint[1], emptyKeyBuffer);
if ( emptyKeyBuffer == TRUE )
{
emptyKeyBuffer = FALSE;
# ifdef USE_BUFFERED_TOUCH_DATA
bufferd_touch_point_handler(1); /* with release */
go_in_suspend = 0;
# endif
goto finished;
}
else
{
//printk("goto release \n");
goto release;
}
}
# ifdef USE_BUFFERED_TOUCH_DATA
if ( go_in_suspend )
{
bufferd_touch_point_handler(0); /* without release */
go_in_suspend = 0;
}
# endif
//key input
ts_iic->xp = keybuffer[IdxBottom].x = curpoint[0];
ts_iic->yp = keybuffer[IdxBottom].y = curpoint[1];
input_report_abs(ts_iic->dev, ABS_X, ts_iic->xp);
input_report_abs(ts_iic->dev, ABS_Y, ts_iic->yp);
# ifdef USE_BUFFERED_TOUCH_DATA
if ( !IsPanelPressed )
{
input_report_key(ts_iic->dev, BTN_TOUCH, 1);
input_report_abs(ts_iic->dev, ABS_PRESSURE, 1);
IsPanelPressed = 1;
}
# else
input_report_key(ts_iic->dev, BTN_TOUCH, 1);
input_report_abs(ts_iic->dev, ABS_PRESSURE, 1);
# endif
input_sync(ts_iic->dev);
# ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPH12, S3C2410_GPH12_OUTP);
s3c2410_gpio_setpin(S3C2410_GPH12, 1);
# endif
//printk("\n[%d] --%d,%d,%d\n", __LINE__, curpoint[0], curpoint[1], emptyKeyBuffer);
if ( (startpoint[0] == 0) || (startpoint[1] == 0) )
{
emptyKeyBuffer = FALSE;
memcpy(startpoint, curpoint, sizeof (startpoint));
printk("\n++%d,%d,%d\n", startpoint[0], startpoint[1], IdxBottom);
}
IdxBottom++;
if ( IdxBottom >= KEY_BUF_SIZE )
IdxBottom = 0;
goto finished;
release:
printk("--%d,%d,%d\n", curpoint[0], curpoint[1], IdxBottom);
for ( i = 0; i < KEY_BUF_SIZE; ++i )
printk("%d,%d\n", keybuffer[i].x, keybuffer[i].y);
i = IdxBottom - 1;
if ( i <= -1 )
i = KEY_BUF_SIZE - 1;
startpoint[0] -= keybuffer[i].x;
startpoint[1] -= keybuffer[i].y;
//Put your gesture function here!!!!
/*if(( startpoint[1]<-50) || (startpoint[1]>50))
printk(KERN_ERR "ts_iic_workqueue okokokokokokokokok\n");*/
// Key input
if ( Cyio_PushEvent('R', 1) >= 0 )
{
Cyio_PushEvent((keybuffer[0].x >> 8) & 0xFF, 0);
Cyio_PushEvent((keybuffer[0].x >> 0) & 0xFF, 0);
Cyio_PushEvent((keybuffer[0].y >> 8) & 0xFF, 0);
Cyio_PushEvent((keybuffer[0].y >> 0) & 0xFF, 0);
}
memset(keybuffer, 0x0, sizeof (keybuffer));
memset(startpoint, 0x0, sizeof (startpoint));
IdxBottom = 0;
emptyKeyBuffer = TRUE;
//Key input
ts_iic->xp = ts_iic->yp = 0;
# ifdef USE_BUFFERED_TOUCH_DATA
IsPanelPressed = 0;
# endif
input_report_key(ts_iic->dev, BTN_TOUCH, 0);
input_report_abs(ts_iic->dev, ABS_PRESSURE, 0);
input_sync(ts_iic->dev);
# ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPH12, S3C2410_GPH12_OUTP);
s3c2410_gpio_setpin(S3C2410_GPH12, 0);
# endif
# ifdef NEW_TCOM_BOARD
prevpoint[0] = 0;
prevpoint[1] = 0;
zeroCount = 0;
# endif
del_timer(&touch_iic_timer_qisda);
enable_irq(IRQ_EINT2);
//touch_iic_clear_interrupt_pending();
//touch_iic_enable_interrupt();
return;
finished:
//msleep(15);
touch_iic_timer_qisda.expires = jiffies + (HZ / ts_iic->polling_time);
mod_timer(&touch_iic_timer_qisda, touch_iic_timer_qisda.expires);
return;
#endif
//Qisda Tony 090415 ]
}
//static void ts_iic_port_deinit(void)
//{
//}
//Qisda Tony 090415 [
#ifndef POLLING_MODE
static irqreturn_t touch_iic_isr (int irq, void *dev_id)
{
//static int count=0;
printk(KERN_ERR "\ntouch_iic_isr\n");
disable_irq(IRQ_EINT2);
# ifdef CPU_SLEEP_PREVENT
g_wakeup_event_occurs = 1;
//printk("touch_iic_isr: set g_wakeup_event_occurs\n");
# endif
//touch_iic_disable_interrupt();
//touch_iic_clear_interrupt_pending();
touch_iic_timer_qisda.expires = jiffies + (HZ / ts_iic->polling_time);
add_timer(&touch_iic_timer_qisda);
//It wait for kernel timer launch.
//schedule_work(&workq_readdata);
//Enable interrupt funciton will postphone at workqueue stage
//touch_iic_enable_interrupt();
return IRQ_HANDLED;
}
#endif
//Qisda Tony 090415 ]
static int s3c_ts_iic_open (struct inode *inode, struct file *file)
{
return 0;
}
/* Qisda, howard hsu, 2010/01/27, touch firmware update { */
#define NORMAL_SLAVE_ADDR 0x5C
#define BOOTLOADER_SLAVE_ADDR 0x5D
#define OPCODE_INIT 0
#define OPCODE_USER 1
#define OPCODE_AES 2
#define OPCODE_EEPROM 3
#define OPCODE_QUERY 8
typedef struct BLModeInfo
{
char Status;
char FlashLock;
char Version;
char Key;
} __attribute__ ((packed)) BLModeInfo;
int normalmode_read_eeprom (unsigned int eepr_addr, unsigned char *buff)
{
unsigned char tmp[4];
struct i2c_msg msg;
unsigned long nmsgs;
int ret = 0;
tmp[0] = 120;
tmp[1] = 0x01; //read
tmp[2] = (eepr_addr & 0xFF);
tmp[3] = eepr_addr >> 8;
nmsgs = 1;
msg.len = 4; //mem address
msg.addr = NORMAL_SLAVE_ADDR;
msg.flags = 0;
msg.buf = tmp;
ret = i2c_transfer(ts_iic->client->adapter, &msg, nmsgs);
nmsgs = 1;
msg.len = 1; //mem address
msg.addr = NORMAL_SLAVE_ADDR;
msg.flags = I2C_M_RD;
msg.buf = buff;
ret = i2c_transfer(ts_iic->client->adapter, &msg, nmsgs);
if ( ret < 0 )
printk("normalmode_read_eeprom error code:%d\n", ret);
return ret;
}
int normalmode_read_op (unsigned int mem_addr, unsigned char *buff)
{
unsigned char tmp[2];
struct i2c_msg msg[2];
unsigned long nmsgs;
int ret = 0;
tmp[0] = mem_addr;
//tmp[0]=mem_addr;
//tmp[1]=val;
nmsgs = 2;
msg[0].len = 1; //mem address
msg[0].addr = NORMAL_SLAVE_ADDR;
msg[0].flags = 0;
msg[0].buf = tmp;
msg[1].len = 1;
msg[1].addr = NORMAL_SLAVE_ADDR;
msg[1].flags = I2C_M_RD;
msg[1].buf = buff;
ret = i2c_transfer(ts_iic->client->adapter, &msg, nmsgs);
if ( ret < 0 )
printk("[normalmode_read_op] error:%d\n", ret);
else
printk("[normalmode_read_op] ok addr:%d value:%d\n", mem_addr, buff[0]);
return ret;
}
int normalmode_write_op (unsigned char mem_addr, unsigned char val)
{
unsigned char tmp[2];
struct i2c_msg msg;
unsigned long nmsgs;
int ret = 0;
tmp[0] = mem_addr;
tmp[1] = val;
nmsgs = 1;
msg.len = 2; //mem address
msg.addr = NORMAL_SLAVE_ADDR;
msg.flags = 0;
msg.buf = tmp;
ret = i2c_transfer(ts_iic->client->adapter, &msg, nmsgs);
if ( ret < 0 )
printk("[normalmode_write_op] error:%d\n", ret);
else
printk("[normalmode_write_op] ok addr:%d value:%d\n", mem_addr, val);
return ret;
}
int blmode_read_op (int opcode)
{
struct i2c_msg msg;
unsigned long nmsgs;
int ret = 0;
BLModeInfo *bl_info = vmalloc(sizeof (BLModeInfo));
nmsgs = 1;
msg.addr = BOOTLOADER_SLAVE_ADDR;
msg.flags = I2C_M_RD; //0 for write
msg.len = 4;
msg.buf = bl_info;
ret = i2c_transfer(ts_iic->client->adapter, &msg, nmsgs);
if ( ret < 0 )
{
printk("[blmode_read_op] error:%d\n", ret);
}
else
{
printk("[blmode_read_op] ok:[%x][%x][%x][%x]\n", bl_info->Status, bl_info->FlashLock, bl_info->Version, bl_info->Key);
if ( (bl_info->Status & 0x80) != 0 )
{
ret = -8;
}
else
{
if ( opcode == OPCODE_AES )
{
if ( bl_info->FlashLock == 0x00 )
printk("=Flash is locked\n");
else if ( bl_info->FlashLock == 0x05 )
printk("=Flash verified failed\n");
else if ( bl_info->FlashLock == 0xFF )
printk("=Flash is erased\n");
else if ( bl_info->FlashLock == 0xA5 )
printk("=Flash is unlocked\n");
else
printk("=Flash status Unknown(%x)\n", bl_info->FlashLock);
}
}
}
return ret;
}
int blmode_write_op (char *data_ptr)
{
struct i2c_msg msg;
unsigned long nmsgs;
int ret = 0;
nmsgs = 1;
msg.addr = BOOTLOADER_SLAVE_ADDR;
msg.flags = 0;
msg.len = 143;
msg.buf = data_ptr;
ret = i2c_transfer(ts_iic->client->adapter, &msg, nmsgs);
if ( ret < 0 )
{
printk("blmode_write_op error:%d\n", ret);
}
else
{
ret = data_ptr[0];
printk("opcode[%d] OK\n", data_ptr[0]);
}
return ret;
}
int blmode_wait_ready ()
{
unsigned int pin_state;
int count = 0;
int ret = 0;
do
{
pin_state = (__raw_readl(S3C2410_GPFDAT)&(1 << 2));
count++;
msleep(20);
} while ( (pin_state != 0) && (count < 100) ); //wait for 2 seconds
//printk("[blmode_wait_ready]count=%d pin=%d\n",count,pin_state);
ret = (pin_state == 0) ? 0 : 1;
return ret;
}
int get_touch_firmware_info (char *buff)
{
/* read version */
normalmode_read_op(119, buff);
}
int enter_blmode (int method)
{
disable_irq(IRQ_EINT2);
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_INP);
s3c2410_gpio_pullup(S3C2410_GPF2, 0);
if ( method == 0 )
{
printk("TP:HW_blmode entry\n");
//turn-off
#ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPD10, S3C2410_GPD10_OUTP);
s3c2410_gpio_setpin(S3C2410_GPD10, 0);
#else
s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
s3c2410_gpio_setpin(S3C2410_GPF5, 0);
#endif
msleep(2000);
#ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPD10, S3C2410_GPD10_OUTP);
s3c2410_gpio_setpin(S3C2410_GPD10, 1);
#else
s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
s3c2410_gpio_setpin(S3C2410_GPF5, 1);
#endif
//s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_INP);
//s3c2410_gpio_pullup(S3C2410_GPF2, 0);
blmode_read_op(OPCODE_QUERY);
blmode_wait_ready();
blmode_read_op(OPCODE_QUERY);
}
else
{
printk("TP:SW_blmode entry\n");
msleep(100);
normalmode_write_op(120, 5);
blmode_read_op(OPCODE_QUERY);
blmode_wait_ready();
blmode_read_op(OPCODE_QUERY);
}
}
int reset_touch ()
{
#ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPD10, S3C2410_GPD10_OUTP);
s3c2410_gpio_setpin(S3C2410_GPD10, 0);
#else
s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
s3c2410_gpio_setpin(S3C2410_GPF5, 0);
#endif
//s3c2410_gpio_cfgpin(S3C2410_GPC3, S3C2410_GPC3_OUTP); //?smart card
//s3c2410_gpio_setpin(S3C2410_GPC3, 0);
msleep(2000);
//on
//s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_INP);
//s3c2410_gpio_pullup(S3C2410_GPF2, 2);
#ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPD10, S3C2410_GPD10_OUTP);
s3c2410_gpio_setpin(S3C2410_GPD10, 1);
#else
s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
s3c2410_gpio_setpin(S3C2410_GPF5, 1);
#endif
msleep(400);
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_INIT, NULL);
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_EINT2);
s3c2410_gpio_pullup(S3C2410_GPF2, 2);
enable_irq(IRQ_EINT2);
msleep(100);
}
int update_touch_firmware (unsigned long size, char* frame_data)
{
unsigned int pin_state;
int count, count_max;
int opcode, result;
int i;
unsigned long offset = 0;
/*
disable_irq(IRQ_EINT2);
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_INP);
s3c2410_gpio_pullup(S3C2410_GPF2, 0);
msleep(100);
normalmode_write_op(120,5);
blmode_wait_ready();
blmode_read_op(OPCODE_QUERY);
*/
enter_blmode(0);
char *cmd_buff = vmalloc(143, GFP_KERNEL);
char *data_ptr = frame_data;
unsigned long limit = frame_data + size;
char *p_head;
char *p_tail;
count = 0;
do
{
p_head = strchr(data_ptr, '$');
if ( (p_head != NULL) && (p_tail < limit) )
{
p_tail = strchr(p_head + 1, 0xd);
if ( (p_tail != NULL) && (p_tail < limit) )
{
printk("p_head=%lu p_tail=%lu \n", p_head, p_tail);
unsigned long length = p_tail - p_head;
p_head++;
if ( length != 287 )
goto FAIL;
char tmpToken[3];
memset(tmpToken, 0, sizeof (tmpToken));
for ( i = 0; i < 143; i++ )
{
strncpy(tmpToken, p_head + i * 2, 2);
sprintf(cmd_buff + i, "%c", simple_strtol(tmpToken, NULL, 16));
}
count++;
printk("OpCode[%2x] CRC[%2x][%2x]\n", cmd_buff[0], cmd_buff[141], cmd_buff[142]);
opcode = blmode_write_op(cmd_buff);
printk("[blmode_write_op][%d]=%d\n", count, opcode);
if ( opcode < 0 )
{
goto FAIL;
}
if ( opcode != OPCODE_USER )
{
if ( blmode_wait_ready() != 0 )
goto FAIL_BUSY;
result = blmode_read_op(opcode);
printk("[blmode_read_op]=%d\n", result);
if ( result < 0 )
goto FAIL;
}
data_ptr = p_tail + 1;
if ( data_ptr > (limit - 280) )
{
printk("end of file,stop\n");
printk("curr:%lu limit:%lu\n", data_ptr, limit);
p_head = 0;
}
}
else
{
p_head = 0;
}
}
printk("==p_head=%lu\n", p_head);
} while ( p_head != 0 );
vfree(cmd_buff);
/* printk("restore EINT\n");
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_EINT2);
s3c2410_gpio_pullup(S3C2410_GPF2, 2);
enable_irq(IRQ_EINT2);
msleep(100); */
reset_touch();
return 0;
FAIL_BUSY:
printk("[FAIL]Dev is Busy\n");
FAIL:
return -1;
}
/* } Qisda, howard hsu, 2010/01/27, touch firmware update */
/*******************************/
/****** GPF2 => TP_INT ******/
/****** GPF5 => TOUCH_EN ******/
/*** GPC3 => T-Sensor Power ***/
/*******************************/
static int s3c_ts_iic_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
switch ( cmd )
{
case TOUCH_IIC_CALIBRATION:
#ifdef POLLING_MODE
need_calibration = TRUE;
#else
printk("TOUCH_IIC_CALIBRATION...");
disable_irq(IRQ_EINT2);
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_CALIBRATION, NULL);
printk("done\n");
enable_irq(IRQ_EINT2);
#endif
break;
case TOUCH_IIC_SET_POLLING_TIME:
if ( (arg < 1) || (arg > 80) )
{
printk("polling time should be 1-80\n");
}
else
{
ts_iic->polling_time = arg;
touchPollingTime = arg;
}
break;
/*kit.mod 2009/11/04*/
case TOUCH_DEVICE_POWER_STATE:
switch ( arg )
{
case TOUCH_DEVICE_ACTIVE_STATE:
if ( isTouchPowerOff )
{
isTouchPowerOff = 0;
#ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPD10, S3C2410_GPD10_OUTP);
s3c2410_gpio_setpin(S3C2410_GPD10, 1);
#else
s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
s3c2410_gpio_setpin(S3C2410_GPF5, 1);
#endif
msleep(200);
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_INIT, NULL);
/*kit.add 2010/01/20, for turn on TP_INT(GPF2) power*/
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_EINT2);
s3c2410_gpio_pullup(S3C2410_GPF2, 2);
/*kit.end*/
enable_irq(IRQ_EINT2);
}
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_ACTIVE_MODE, NULL);
/*kit.add 2009/11/16*/
ts_iic->polling_time = touchPollingTime;
touchPowerState = TOUCH_DEVICE_ACTIVE_STATE;
/*kit.end*/
printk("Touch Device => Active State\n");
break;
case TOUCH_DEVICE_SLEEP_STATE:
if ( isTouchPowerOff )
{
isTouchPowerOff = 0;
#ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPD10, S3C2410_GPD10_OUTP);
s3c2410_gpio_setpin(S3C2410_GPD10, 1);
#else
s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
s3c2410_gpio_setpin(S3C2410_GPF5, 1);
#endif
msleep(200);
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_INIT, NULL);
/*kit.add 2010/01/20, for turn on TP_INT(GPF2) power*/
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_EINT2);
s3c2410_gpio_pullup(S3C2410_GPF2, 2);
/*kit.end*/
enable_irq(IRQ_EINT2);
}
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_SLEEP_MODE, NULL);
/*kit.add 2009/11/16*/
ts_iic->polling_time = TOUCH_SLEEP_POLLING_TIME;
touchPowerState = TOUCH_DEVICE_SLEEP_STATE;
/*kit.end*/
printk("Touch Device => Sleep State\n");
break;
case TOUCH_DEVICE_DEEPSLEEP_STATE:
if ( isTouchPowerOff )
{
isTouchPowerOff = 0;
#ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPD10, S3C2410_GPD10_OUTP);
s3c2410_gpio_setpin(S3C2410_GPD10, 1);
#else
s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
s3c2410_gpio_setpin(S3C2410_GPF5, 1);
#endif
msleep(200);
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_INIT, NULL);
/*kit.add 2010/01/20, for turn on TP_INT(GPF2) power*/
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_EINT2);
s3c2410_gpio_pullup(S3C2410_GPF2, 2);
/*kit.end*/
enable_irq(IRQ_EINT2);
}
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_DEEPSLEEP_MODE, NULL);
/*kit.add 2009/11/16*/
ts_iic->polling_time = TOUCH_DEEPSLEEP_POLLING_TIME;
touchPowerState = TOUCH_DEVICE_DEEPSLEEP_STATE;
/*kit.end*/
printk("Touch Device => Deep Sleep State\n");
break;
case TOUCH_DEVICE_POWEROFF_STATE:
if ( isTouchPowerOff )
printk("Touch Device => Already Power Off State\n");
else
{
isTouchPowerOff = 1;
disable_irq(IRQ_EINT2);
/*kit.add 2010/01/20, turn off TP_INT(GPF2) power*/
/*test1: TP_INT(GPF2) => Input, Disable*/
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_INP);
s3c2410_gpio_pullup(S3C2410_GPF2, 0);
/*test2: TP_INT(GPF2) => Input, Pull Low*/
//s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_INP);
//s3c2410_gpio_setpin(S3C2410_GPF2, 1);
/*kit.end*/
/*Turn off touch power(TOUCH_EN)*/
#ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPD10, S3C2410_GPD10_OUTP);
s3c2410_gpio_setpin(S3C2410_GPD10, 0);
#else
s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
s3c2410_gpio_setpin(S3C2410_GPF5, 0);
#endif
printk("Touch Device => Power Off State\n");
}
/*kit.add 2009/11/16*/
touchPowerState = TOUCH_DEVICE_POWEROFF_STATE;
/*kit.end*/
break;
default:
printk("Touch Device => No Such Power State...\n");
}
break;
/*kit.end*/
/* Qisda, howard hsu, 2010/01/27, TOUCH firmware update { */
case TOUCH_IIC_FW_UPDATE:
{
printk("Call TOUCH_IIC_FW_UPDATE\n");
unsigned long fw_size = 0;
int result = 0;
if ( copy_from_user(&fw_size, (unsigned long*)arg, sizeof (unsigned long)) )
return -EFAULT;
unsigned char *fw_data = vmalloc(fw_size, GFP_KERNEL);
if ( copy_from_user(fw_data, (char*)((char *)arg + sizeof (unsigned long)), fw_size) )
return -EFAULT;
printk("FW_Size=%d\n", fw_size);
result = update_touch_firmware(fw_size, fw_data);
printk("TOUCH_IIC_FW_UPDATE Complete(result=%d)!!!\n", result);
vfree(fw_data);
return result;
}
break;
case TOUCH_IIC_GET_FW_INFO:
{
char info = 0;
get_touch_firmware_info(&info);
if ( copy_to_user((void *)arg, (const void *) & info, sizeof (char)) )
return -EFAULT;
}
break;
/* } Qisda, howard hsu, 2010/01/27, TOUCH firmware update */
/*kit.add 2010/01/30*/
case TOUCH_IIC_T_SENSOR_ENABLE:
{
switch ( arg )
{
case 0:
s3c2410_gpio_cfgpin(S3C2410_GPC3, S3C2410_GPC3_OUTP);
s3c2410_gpio_setpin(S3C2410_GPC3, 0);
printk("T-Sensor power off\n");
break;
case 1:
s3c2410_gpio_cfgpin(S3C2410_GPC3, S3C2410_GPC3_OUTP);
s3c2410_gpio_setpin(S3C2410_GPC3, 1);
printk("T-Sensor power on\n");
break;
default:
printk("T-Sensor no such command\n");
break;
}
}
break;
/*kit.end*/
default:
printk("No such command\n");
}
return 0;
}
/* File operations struct for character device */
static const struct file_operations s3c_ts_iic_fops = {
.owner = THIS_MODULE,
.ioctl = s3c_ts_iic_ioctl,
.open = s3c_ts_iic_open,
.release = NULL
};
int s3c_ts_iic_port_init (struct i2c_client *c)
{
int err = 0;
ts_iic->client = c;
err = c->driver->command(c, QISDA_IIC_INIT, NULL);
if ( err < 0 )
{
printk("Touch init faied\n");
goto fail;
}
//touch_iic_init();
//touch_iic_port_initialize();
//Qisda Tony 090415 [
#ifdef POLLING_MODE
# ifdef KTHREAD_USE
init_waitqueue_head(&wait);
kmain_task = kthread_create(ts_iic_workqueue, NULL, "ts_iic_kthread");
wake_up_process(kmain_task);
# else
init_timer(&touch_iic_timer_qisda);
touch_iic_timer_qisda.function = touhc_iic_timer_handler_qisda;
//touch_iic_timer_qisda.data;
touch_iic_timer_qisda.expires = jiffies + 10 * HZ;
add_timer(&touch_iic_timer_qisda);
# endif
#else //NOT POLLING_MODE
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_INP);
s3c2410_gpio_pullup(S3C2410_GPF2, 2);
# ifndef KTHREAD_USE
init_timer(&touch_iic_timer_qisda);
touch_iic_timer_qisda.function = touhc_iic_timer_handler_qisda;
# endif
set_irq_type(IRQ_EINT2, S3C2410_EXTINT_FALLEDGE);
err = request_irq(IRQ_EINT2, touch_iic_isr, SA_INTERRUPT, DEVICE_NAME, (void *)ts_iic->pdev);
if ( err )
{
printk("request_irq failed (IRQ_EINT2) !!!\n");
free_irq(IRQ_EINT2, ts_iic->dev);
//ts_iic_port_deinit();
goto fail;
}
//touch_iic_clear_interrupt_pending();
//touch_iic_enable_interrupt();
#endif //End of NOT POLLING_MODE
memset(keybuffer, 0x0, sizeof (keybuffer));
//Qisda Tony 090415 ]
if ( register_chrdev(TOUCH_MAJOR, "touch_cmd", &s3c_ts_iic_fops) )
{
printk("unable to get major %d\n", TOUCH_MAJOR);
}
printk("s3c_ts_iic_port_init is initialized!!\n");
#ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_pullup(S3C2410_GPD10, 2);
s3c2410_gpio_cfgpin(S3C2410_GPD10, S3C2410_GPD10_OUTP);
s3c2410_gpio_setpin(S3C2410_GPD10, 1);
#else
s3c2410_gpio_pullup(S3C2410_GPF5, 2);
s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
s3c2410_gpio_setpin(S3C2410_GPF5, 1);
#endif
/*Qisda Qube for open smartcard pwr*/
#if defined (CONFIG_QISDA_AS090B00_EVT1) || defined (CONFIG_QISDA_AS090B00_EVT1_1)
s3c2410_gpio_cfgpin(S3C2410_GPC3, S3C2410_GPC3_OUTP);
/*kit.mod 2009/12/25*/
s3c2410_gpio_setpin(S3C2410_GPC3, 0);
/*kit.end*/
#endif
/*Qisda Qube for open smartcard pwr*/
return 0;
fail:
platform_driver_unregister(&s3c_ts_iic_driver);
input_free_device(ts_iic->dev);
kfree(ts_iic);
return -EIO;
}
static int __init s3c_ts_iic_probe (struct platform_device *pdev)
{
struct input_dev *input_dev;
int err;
//Tony test
#ifdef QISDA_TEST_GPIO_PROBE
g_pGPIOReg_GPFCON = ioremap(0x56000050, 0x00100000);
writel(readl(g_pGPIOReg_GPFCON) | (0x1 << 0), g_pGPIOReg_GPFCON);
writel(readl(g_pGPIOReg_GPFCON + 0x04) | (0x1 << 0), g_pGPIOReg_GPFCON + 0x04);
writel(readl(g_pGPIOReg_GPFCON + 0x08) | (0x2 << 0), g_pGPIOReg_GPFCON + 0x08);
#endif
ts_iic = kzalloc(sizeof (struct s3c_ts_iic), GFP_KERNEL);
input_dev = input_allocate_device();
if ( !input_dev )
{
err = -ENOMEM;
goto fail;
}
ts_iic->dev = input_dev;
ts_iic->dev->evbit[0] = ts_iic->dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);
ts_iic->dev->keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
input_set_abs_params(ts_iic->dev, ABS_X, 0, 0xFFF, 0, 0);
input_set_abs_params(ts_iic->dev, ABS_Y, 0, 0xFFF, 0, 0);
input_set_abs_params(ts_iic->dev, ABS_PRESSURE, 0, 1, 0, 0);
ts_iic->dev->private = ts_iic;
ts_iic->dev->name = s3c_ts_iic_name;
ts_iic->dev->id.bustype = BUS_I2C;
ts_iic->dev->id.vendor = 0xDEAD;
ts_iic->dev->id.product = 0xBEEF;
ts_iic->dev->id.version = 0x0010;
platform_set_drvdata(pdev, ts_iic);
/* All went ok, so register to the input system */
err = input_register_device(ts_iic->dev);
if ( err )
{
goto fail;
}
ts_iic->pdev = pdev;
ts_iic->polling_time = 20;
INIT_WORK(&workq_readdata, ts_iic_workqueue);
//However, stop interrupt first. This is because the signal is emitted from the panel repeatedly
//Unless we set the interrupt mode of the the panel to stop emitting.
//touch_iic_disable_interrupt();
//printk("s3c_ts_iic_probe IRQ is initialized!!\n");
// touch panel enable in common-smdk.c
//writel((readl(S3C2416_GPKCON) & ~(1<<5) | (1<<4)), S3C2416_GPKCON);
//writel((readl(S3C2416_GPKDAT) | (1<<2)), S3C2416_GPKDAT);
return 0;
fail:
input_free_device(input_dev);
kfree(ts_iic);
return -EIO;
}
static int s3c_ts_iic_remove (struct platform_device *dev)
{
return 0;
}
#ifdef CONFIG_PM
static int s3c_ts_iic_suspend (struct platform_device *dev, pm_message_t state)
{
/*kit.add 2010/01/06, turn off Tilt-Sensor power*/
s3c2410_gpio_cfgpin(S3C2410_GPC3, S3C2410_GPC3_OUTP);
s3c2410_gpio_setpin(S3C2410_GPC3, 0);
/*kit.end*/
/*kit.test 2010/01/30, turn off SPI_INT power*/
s3c2410_gpio_cfgpin(S3C2410_GPF3, S3C2410_GPF3_INP);
s3c2410_gpio_pullup(S3C2410_GPF3, 0); /* pull-up/down disable */
/*kit.end*/
/*kit.add 2009/11/04*/
if ( wkup_srce == 1 )
{
printk("\nTouch Suspend: Add touch to wakeup source, do not turn off touch power...\n");
}
//else if(wkup_srce == 0)
else
{
if ( !isTouchPowerOff )
{
printk("\nTouch Suspend: Do not add touch to wakeup source, turn off touch power...\n");
disable_irq(IRQ_EINT2);
/*kit.add 2010/01/20, turn off TP_INT(GPF2) power*/
/*test1: TP_INT(GPF2) => Input, Disable*/
//s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_INP);
//s3c2410_gpio_pullup(S3C2410_GPF2, 0);
/*test2: TP_INT(GPF2) => Input, Pull Low*/
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_INP);
s3c2410_gpio_setpin(S3C2410_GPF2, 1);
/*kit.end*/
/*turn off TOUCH_EN power*/
# ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPD10, S3C2410_GPD10_OUTP);
s3c2410_gpio_setpin(S3C2410_GPD10, 0);
# else
s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
s3c2410_gpio_setpin(S3C2410_GPF5, 0);
# endif
}
}
/*kit.end*/
# ifdef USE_BUFFERED_TOUCH_DATA
go_in_suspend = 1;
# endif
return 0;
}
static int s3c_ts_iic_resume (struct platform_device *pdev)
{
/*kit.add 2010/01/06, for Tilt-Sensor power*/
s3c2410_gpio_cfgpin(S3C2410_GPC3, S3C2410_GPC3_OUTP);
s3c2410_gpio_setpin(S3C2410_GPC3, 1);
/*kit.end*/
/*kit.test 2010/01/30, for SPI_INT power*/
s3c2410_gpio_cfgpin(S3C2410_GPF3, S3C2410_GPF3_EINT3);
s3c2410_gpio_pullup(S3C2410_GPF3, 2); /* pull-up enable */
/*kit.end*/
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_INIT, NULL);
/*kit.add 2009/11/04*/
if ( wkup_srce == 1 )
{
printk("\nTouch Resume: Touch is wakeup source\n");
}
//else if(wkup_srce == 0)
else
{
printk("\nTouch Resume: Touch is not wakeup source, turn on touch power and enable IRQ...\n");
if ( !isTouchPowerOff )
{
/*turn on TOUCH_EN power*/
# ifdef CONFIG_QISDA_BK060B00
s3c2410_gpio_cfgpin(S3C2410_GPD10, S3C2410_GPD10_OUTP);
s3c2410_gpio_setpin(S3C2410_GPD10, 1);
# else
s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
s3c2410_gpio_setpin(S3C2410_GPF5, 1);
# endif
msleep(200);
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_INIT, NULL);
/*kit.add 2010/01/20, config TP_INT(GPF2) to interrupt*/
s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_EINT2);
s3c2410_gpio_pullup(S3C2410_GPF2, 2);
/*kit.end*/
enable_irq(IRQ_EINT2);
switch ( touchPowerState )
{
case TOUCH_DEVICE_ACTIVE_STATE:
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_ACTIVE_MODE, NULL);
ts_iic->polling_time = touchPollingTime;
touchPowerState = TOUCH_DEVICE_ACTIVE_STATE;
break;
case TOUCH_DEVICE_SLEEP_STATE:
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_SLEEP_MODE, NULL);
ts_iic->polling_time = TOUCH_SLEEP_POLLING_TIME;
touchPowerState = TOUCH_DEVICE_SLEEP_STATE;
break;
case TOUCH_DEVICE_DEEPSLEEP_STATE:
ts_iic->client->driver->command(ts_iic->client, QISDA_IIC_DEEPSLEEP_MODE, NULL);
ts_iic->polling_time = TOUCH_DEEPSLEEP_POLLING_TIME;
touchPowerState = TOUCH_DEVICE_DEEPSLEEP_STATE;
break;
case TOUCH_DEVICE_POWEROFF_STATE:
touchPowerState = TOUCH_DEVICE_DEEPSLEEP_STATE;
break;
default:
break;
}
}
}
/*kit.end*/
return 0;
}
#else
# define s3c_ts_iic_suspend NULL
# define s3c_ts_iic_resume NULL
#endif
static struct platform_driver s3c_ts_iic_driver = {
.probe = s3c_ts_iic_probe,
.remove = s3c_ts_iic_remove,
.suspend = s3c_ts_iic_suspend,
.resume = s3c_ts_iic_resume,
.driver =
{
.owner = THIS_MODULE,
.name = DEVICE_NAME,
},
};
//static char banner[] __initdata = KERN_INFO "Touchscreen driver Of IIC type for Qisda\n";
static int __init s3c_ts_iic_init (void)
{
return platform_driver_register(&s3c_ts_iic_driver);
}
static void __exit s3c_ts_iic_exit (void)
{
platform_driver_unregister(&s3c_ts_iic_driver);
}
module_init (s3c_ts_iic_init);
module_exit (s3c_ts_iic_exit);
MODULE_AUTHOR ("Tony.YC.Huang@qisda.com");
MODULE_DESCRIPTION ("Touchscreen driver Of IIC type for Qisda");
MODULE_LICENSE ("GPL");
//Qisda Tony 090406, add Auo touch i2c driver ]
Reference in New Issue View Git Blame Copy Permalink