drivers/input/touchscreen/sitronix_ts_a720.c

   1 /*
   2  * drivers/input/touchscreen/sitronix_i2c_touch.c
   3  *
   4  * Touchscreen driver for Sitronix (I2C bus)
   5  *
   6  * Copyright (C) 2011 Sitronix Technology Co., Ltd.
   7  *      Rudy Huang <rudy_huang@sitronix.com.tw>
   8  */
   9 /*
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by the Free
  12  * Software Foundation; either version 2 of the License, or (at your option)
  13  * any later version.
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/delay.h>
  18 #ifdef CONFIG_HAS_EARLYSUSPEND
  19 #include <linux/earlysuspend.h>
  20 #endif // CONFIG_HAS_EARLYSUSPEND
  21 #include "sitronix_ts_a720.h"
  22 #ifdef SITRONIX_FW_UPGRADE_FEATURE
  23 #include <linux/cdev.h>
  24 #include <asm/uaccess.h>
  25 #endif // SITRONIX_FW_UPGRADE_FEATURE
  26 #include <linux/i2c.h>
  27 #include <linux/input.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/slab.h> // to be compatible with linux kernel 3.2.15
  30 #include <linux/gpio.h>
  31 #include <mach/board.h>
  32 #ifdef CONFIG_RK_CONFIG
  33 #include <mach/config.h>
  34 #endif
  35 #include <linux/input/mt.h>
  36
  37 #ifdef SITRONIX_MONITOR_THREAD
  38 #include <linux/kthread.h>
  39 //#include <mach/gpio.h>
  40 #endif // SITRONIX_MONITOR_THREAD
  41
  42 #define TP_MODULE_NAME  SITRONIX_I2C_TOUCH_DRV_NAME
  43 #ifdef CONFIG_RK_CONFIG
  44
  45 enum {
  46 #if defined(RK2926_SDK_DEFAULT_CONFIG)
  47         DEF_EN = 1,
  48 #else
  49         DEF_EN = 0,
  50 #endif
  51         DEF_IRQ = 0x008001b0,
  52         DEF_RST = 0X000001a3,
  53         DEF_I2C = 2,
  54         DEF_ADDR = 0x60,
  55         DEF_X_MAX = 800,
  56         DEF_Y_MAX = 480,
  57 };
  58 static int en = DEF_EN;
  59 module_param(en, int, 0644);
  60
  61 static int irq = DEF_IRQ;
  62 module_param(irq, int, 0644);
  63 static int rst =DEF_RST;
  64 module_param(rst, int, 0644);
  65
  66 static int i2c = DEF_I2C;            // i2c channel
  67 module_param(i2c, int, 0644);
  68 static int addr = DEF_ADDR;           // i2c addr
  69 module_param(addr, int, 0644);
  70 static int x_max = DEF_X_MAX;
  71 module_param(x_max, int, 0644);
  72 static int y_max = DEF_Y_MAX;
  73 module_param(y_max, int, 0644);
  74
  75 static int tp_hw_init(void)
  76 {
  77         int ret = 0;
  78
  79         ret = gpio_request(get_port_config(irq).gpio, "tp_irq");
  80         if(ret < 0){
  81                 printk("%s: gpio_request(irq gpio) failed\n", __func__);
  82                 return ret;
  83         }
  84
  85         ret = port_output_init(rst, 1, "tp_rst");
  86         if(ret < 0){
  87                 printk("%s: port(rst) output init faild\n", __func__);
  88                 return ret;
  89         }
  90         mdelay(10);
  91         port_output_off(rst);
  92         mdelay(10);
  93         port_output_on(rst);
  94         msleep(300);
  95
  96          return 0;
  97 }
  98 #include "rk_tp.c"
  99 #endif
 100
 101
 102 #define DRIVER_AUTHOR           "Sitronix, Inc."
 103 #define DRIVER_NAME             "sitronix"
 104 #define DRIVER_DESC             "Sitronix I2C touch"
 105 #define DRIVER_DATE             "20120507"
 106 #define DRIVER_MAJOR            2
 107 #define DRIVER_MINOR            9
 108 #define DRIVER_PATCHLEVEL       1
 109
 110 MODULE_AUTHOR("Rudy Huang <rudy_huang@sitronix.com.tw>");
 111 MODULE_DESCRIPTION("Sitronix I2C multitouch panels");
 112 MODULE_LICENSE("GPL");
 113
 114 #ifdef SITRONIX_SENSOR_KEY
 115 #define SITRONIX_NUMBER_SENSOR_KEY 3
 116 int sitronix_sensor_key[SITRONIX_NUMBER_SENSOR_KEY] = {
 117         KEY_BACK, // bit 0
 118         KEY_HOMEPAGE,//KEY_HOME, // bit 1
 119         KEY_MENU, // bit 2
 120 };
 121 #endif // SITRONIX_SENSOR_KEY
 122
 123 #ifdef SITRONIX_TOUCH_KEY
 124 #define SITRONIX_NUMBER_TOUCH_KEY 4
 125
 126 #ifdef SITRONIX_KEY_BOUNDARY_MANUAL_SPECIFY
 127 #define SITRONIX_TOUCH_RESOLUTION_X 480 /* max of X value in display area */
 128 #define SITRONIX_TOUCH_RESOLUTION_Y 854 /* max of Y value in display area */
 129 #define SITRONIX_TOUCH_GAP_Y    10  /* Gap between bottom of display and top of touch key */
 130 #define SITRONIX_TOUCH_MAX_Y 915  /* resolution of y axis of touch ic */
 131 struct sitronix_AA_key sitronix_key_array[SITRONIX_NUMBER_TOUCH_KEY] = {
 132         {15, 105, SITRONIX_TOUCH_RESOLUTION_Y + SITRONIX_TOUCH_GAP_Y, SITRONIX_TOUCH_MAX_Y, KEY_MENU}, /* MENU */
 133         {135, 225, SITRONIX_TOUCH_RESOLUTION_Y + SITRONIX_TOUCH_GAP_Y, SITRONIX_TOUCH_MAX_Y, KEY_HOME},
 134         {255, 345, SITRONIX_TOUCH_RESOLUTION_Y + SITRONIX_TOUCH_GAP_Y, SITRONIX_TOUCH_MAX_Y, KEY_BACK}, /* KEY_EXIT */
 135         {375, 465, SITRONIX_TOUCH_RESOLUTION_Y + SITRONIX_TOUCH_GAP_Y, SITRONIX_TOUCH_MAX_Y, KEY_SEARCH},
 136 };
 137 #else
 138 #define SCALE_KEY_HIGH_Y 15
 139 struct sitronix_AA_key sitronix_key_array[SITRONIX_NUMBER_TOUCH_KEY] = {
 140         {0, 0, 0, 0, KEY_MENU}, /* MENU */
 141         {0, 0, 0, 0, KEY_HOME},
 142         {0, 0, 0, 0, KEY_BACK}, /* KEY_EXIT */
 143         {0, 0, 0, 0, KEY_SEARCH},
 144 };
 145
 146 #endif // SITRONIX_KEY_BOUNDARY_MANUAL_SPECIFY
 147 #endif // SITRONIX_TOUCH_KEY
 148 struct sitronix_ts_data {
 149         uint16_t addr;
 150         struct i2c_client *client;
 151         struct input_dev *input_dev;
 152 #if defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
 153         struct input_dev *keyevent_input;
 154 #endif // defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
 155         int use_irq;
 156         struct hrtimer timer;
 157 #ifndef SITRONIX_INT_POLLING_MODE
 158         struct work_struct  work;
 159 #else
 160         struct delayed_work work;
 161 #endif // SITRONIX_INT_POLLING_MODE
 162         void (*reset_ic)(void);
 163 #ifdef CONFIG_HAS_EARLYSUSPEND
 164         struct early_suspend early_suspend;
 165 #endif // CONFIG_HAS_EARLYSUSPEND
 166         uint8_t fw_revision[4];
 167         int resolution_x;
 168         int resolution_y;
 169         uint8_t max_touches;
 170         uint8_t touch_protocol_type;
 171         uint8_t pixel_length;
 172         int suspend_state;
 173         int irq;
 174 };
 175
 176 static unsigned char initkey_code[] =
 177 {
 178     KEY_BACK,  KEY_HOMEPAGE, KEY_MENU
 179 };
 180
 181 static int i2cErrorCount = 0;
 182
 183 #ifdef SITRONIX_MONITOR_THREAD
 184 static struct task_struct * SitronixMonitorThread = NULL;
 185 static int gMonitorThreadSleepInterval = 300; // 0.3 sec
 186 static atomic_t iMonitorThreadPostpone = ATOMIC_INIT(0);
 187
 188 static uint8_t PreCheckData[4] ;
 189 static int StatusCheckCount = 0;
 190 static int sitronix_ts_monitor_thread(void *data);
 191 static int sitronix_ts_delay_monitor_thread_start = DELAY_MONITOR_THREAD_START_PROBE;
 192 #endif // SITRONIX_MONITOR_THREAD
 193
 194 #ifdef CONFIG_HAS_EARLYSUSPEND
 195 static void sitronix_ts_early_suspend(struct early_suspend *h);
 196 static void sitronix_ts_late_resume(struct early_suspend *h);
 197 #endif // CONFIG_HAS_EARLYSUSPEND
 198
 199 static MTD_STRUCTURE sitronix_ts_gMTDPreStructure[SITRONIX_MAX_SUPPORTED_POINT]={{0}};
 200
 201 static struct sitronix_ts_data *sitronix_ts_gpts = NULL;
 202 static int sitronix_ts_irq_on = 0;
 203
 204 #ifdef SITRONIX_FW_UPGRADE_FEATURE
 205 int      sitronix_release(struct inode *, struct file *);
 206 int      sitronix_open(struct inode *, struct file *);
 207 ssize_t  sitronix_write(struct file *file, const char *buf, size_t count, loff_t *ppos);
 208 ssize_t  sitronix_read(struct file *file, char *buf, size_t count, loff_t *ppos);
 209 long     sitronix_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
 210 static struct cdev sitronix_cdev;
 211 static struct class *sitronix_class;
 212 static int sitronix_major = 0;
 213
 214 int  sitronix_open(struct inode *inode, struct file *filp)
 215 {
 216         return 0;
 217 }
 218 EXPORT_SYMBOL(sitronix_open);
 219
 220 int  sitronix_release(struct inode *inode, struct file *filp)
 221 {
 222         return 0;
 223 }
 224 EXPORT_SYMBOL(sitronix_release);
 225
 226 ssize_t  sitronix_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
 227 {
 228         int ret;
 229         char *tmp;
 230
 231         if (count > 8192)
 232                 count = 8192;
 233
 234         tmp = (char *)kmalloc(count,GFP_KERNEL);
 235         if (tmp==NULL)
 236                 return -ENOMEM;
 237         if (copy_from_user(tmp,buf,count)) {
 238                 kfree(tmp);
 239                 return -EFAULT;
 240         }
 241         UpgradeMsg("writing %zu bytes.\n", count);
 242
 243         ret = i2c_master_send(sitronix_ts_gpts->client, tmp, count);
 244         kfree(tmp);
 245         return ret;
 246 }
 247 EXPORT_SYMBOL(sitronix_write);
 248
 249 ssize_t  sitronix_read(struct file *file, char *buf, size_t count, loff_t *ppos)
 250 {
 251         char *tmp;
 252         int ret;
 253
 254         if (count > 8192)
 255                 count = 8192;
 256
 257         tmp = (char *)kmalloc(count,GFP_KERNEL);
 258         if (tmp==NULL)
 259                 return -ENOMEM;
 260
 261         UpgradeMsg("reading %zu bytes.\n", count);
 262
 263         ret = i2c_master_recv(sitronix_ts_gpts->client, tmp, count);
 264         if (ret >= 0)
 265                 ret = copy_to_user(buf,tmp,count)?-EFAULT:ret;
 266         kfree(tmp);
 267         return ret;
 268 }
 269 EXPORT_SYMBOL(sitronix_read);
 270
 271 static int sitronix_ts_resume(struct i2c_client *client);
 272 static int sitronix_ts_suspend(struct i2c_client *client, pm_message_t mesg);
 273 long     sitronix_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 274 {
 275         int err = 0;
 276         int retval = 0;
 277         uint8_t temp[4];
 278
 279         if (_IOC_TYPE(cmd) != SMT_IOC_MAGIC) return -ENOTTY;
 280         if (_IOC_NR(cmd) > SMT_IOC_MAXNR) return -ENOTTY;
 281         if (_IOC_DIR(cmd) & _IOC_READ)
 282                 err = !access_ok(VERIFY_WRITE,(void __user *)arg,\
 283                                  _IOC_SIZE(cmd));
 284         else if (_IOC_DIR(cmd) & _IOC_WRITE)
 285                 err =  !access_ok(VERIFY_READ,(void __user *)arg,\
 286                                   _IOC_SIZE(cmd));
 287         if (err) return -EFAULT;
 288
 289         switch(cmd) {
 290                 case IOCTL_SMT_GET_DRIVER_REVISION:
 291                         UpgradeMsg("IOCTL_SMT_GET_DRIVER_REVISION\n");
 292                         temp[0] = SITRONIX_TOUCH_DRIVER_VERSION;
 293                         if(copy_to_user((uint8_t __user *)arg, &temp[0], 1)){
 294                                 UpgradeMsg("fail to get driver version\n");
 295                                 retval = -EFAULT;
 296                         }
 297                         break;
 298                 case IOCTL_SMT_GET_FW_REVISION:
 299                         UpgradeMsg("IOCTL_SMT_GET_FW_REVISION\n");
 300                         if(copy_to_user((uint8_t __user *)arg, &sitronix_ts_gpts->fw_revision[0], 4))
 301                                         retval = -EFAULT;
 302                         break;
 303                 case IOCTL_SMT_ENABLE_IRQ:
 304                         UpgradeMsg("IOCTL_SMT_ENABLE_IRQ\n");
 305                         if(!sitronix_ts_irq_on){
 306                                 sitronix_ts_irq_on = 1;
 307                                 enable_irq(sitronix_ts_gpts->irq);
 308 #ifdef SITRONIX_MONITOR_THREAD
 309                                 atomic_set(&iMonitorThreadPostpone,1);
 310                                 SitronixMonitorThread = kthread_run(sitronix_ts_monitor_thread,"Sitronix","Monitorthread");
 311                                 if(IS_ERR(SitronixMonitorThread))
 312                                         SitronixMonitorThread = NULL;
 313 #endif // SITRONIX_MONITOR_THREAD
 314                         }
 315                         break;
 316                 case IOCTL_SMT_DISABLE_IRQ:
 317                         UpgradeMsg("IOCTL_SMT_DISABLE_IRQ\n");
 318                         if(sitronix_ts_irq_on){
 319                                 sitronix_ts_irq_on = 0;
 320                                 disable_irq_nosync(sitronix_ts_gpts->irq);
 321 #ifdef SITRONIX_MONITOR_THREAD
 322                                 if(SitronixMonitorThread){
 323                                         kthread_stop(SitronixMonitorThread);
 324                                         SitronixMonitorThread = NULL;
 325                                 }
 326 #endif // SITRONIX_MONITOR_THREAD
 327                         }
 328                         break;
 329                 case IOCTL_SMT_RESUME:
 330                         UpgradeMsg("IOCTL_SMT_RESUME\n");
 331                         sitronix_ts_resume(sitronix_ts_gpts->client);
 332                         break;
 333                 case IOCTL_SMT_SUSPEND:
 334                         UpgradeMsg("IOCTL_SMT_SUSPEND\n");
 335                         sitronix_ts_suspend(sitronix_ts_gpts->client, PMSG_SUSPEND);
 336                         break;
 337                 case IOCTL_SMT_HW_RESET:
 338                         UpgradeMsg("IOCTL_SMT_HW_RESET\n");
 339                         if(sitronix_ts_gpts->reset_ic)
 340                                 sitronix_ts_gpts->reset_ic();
 341                         break;
 342                 default:
 343                         retval = -ENOTTY;
 344         }
 345
 346         return retval;
 347 }
 348 EXPORT_SYMBOL(sitronix_ioctl);
 349 #endif // SITRONIX_FW_UPGRADE_FEATURE
 350
 351 static int sitronix_get_fw_revision(struct sitronix_ts_data *ts)
 352 {
 353         int ret = 0;
 354         uint8_t buffer[4];
 355
 356         buffer[0] = FIRMWARE_REVISION_3;
 357         ret = i2c_master_send(ts->client, buffer, 1);
 358         if (ret < 0){
 359                 printk("send fw revision command error (%d)\n", ret);
 360                 return ret;
 361         }
 362         ret = i2c_master_recv(ts->client, buffer, 4);
 363         if (ret < 0){
 364                 printk("read fw revision error (%d)\n", ret);
 365                 return ret;
 366         }else{
 367                 memcpy(ts->fw_revision, buffer, 4);
 368                 printk("fw revision (hex) = %x %x %x %x\n", buffer[0], buffer[1], buffer[2], buffer[3]);
 369         }
 370         return 0;
 371 }
 372
 373 static int sitronix_get_max_touches(struct sitronix_ts_data *ts)
 374 {
 375         int ret = 0;
 376         uint8_t buffer[1];
 377
 378         buffer[0] = MAX_NUM_TOUCHES;
 379         ret = i2c_master_send(ts->client, buffer, 1);
 380         if (ret < 0){
 381                 printk("send max touches command error (%d)\n", ret);
 382                 return ret;
 383         }
 384         ret = i2c_master_recv(ts->client, buffer, 1);
 385         if (ret < 0){
 386                 printk("read max touches error (%d)\n", ret);
 387                 return ret;
 388         }else{
 389                 ts->max_touches = buffer[0];
 390                 printk("max touches = %d \n",ts->max_touches);
 391         }
 392         return 0;
 393 }
 394
 395 static int sitronix_get_protocol_type(struct sitronix_ts_data *ts)
 396 {
 397         int ret = 0;
 398         uint8_t buffer[1];
 399
 400         buffer[0] = I2C_PROTOCOL;
 401         ret = i2c_master_send(ts->client, buffer, 1);
 402         if (ret < 0){
 403                 printk("send i2c protocol command error (%d)\n", ret);
 404                 return ret;
 405         }
 406         ret = i2c_master_recv(ts->client, buffer, 1);
 407         if (ret < 0){
 408                 printk("read i2c protocol error (%d)\n", ret);
 409                 return ret;
 410         }else{
 411                 ts->touch_protocol_type = buffer[0] & I2C_PROTOCOL_BMSK;
 412                 if(ts->touch_protocol_type == SITRONIX_A_TYPE)
 413                         ts->pixel_length = PIXEL_DATA_LENGTH_A;
 414                 else if(ts->touch_protocol_type == SITRONIX_B_TYPE)
 415                         ts->pixel_length = PIXEL_DATA_LENGTH_B;
 416                 else
 417                         ts->pixel_length = PIXEL_DATA_LENGTH_A;
 418                 printk("i2c protocol = %d \n", ts->touch_protocol_type);
 419         }
 420         return 0;
 421 }
 422
 423 static int sitronix_get_resolution(struct sitronix_ts_data *ts)
 424 {
 425         int ret = 0;
 426         uint8_t buffer[3];
 427
 428         buffer[0] = XY_RESOLUTION_HIGH;
 429         ret = i2c_master_send(ts->client, buffer, 1);
 430         if (ret < 0){
 431                 printk("send resolution command error (%d)\n", ret);
 432                 return ret;
 433         }
 434         ret = i2c_master_recv(ts->client, buffer, 3);
 435         if (ret < 0){
 436                 printk("read resolution error (%d)\n", ret);
 437                 return ret;
 438         }else{
 439                 ts->resolution_x = ((buffer[0] & (X_RES_H_BMSK << X_RES_H_SHFT)) << 4) | buffer[1];
 440                 ts->resolution_y = ((buffer[0] & Y_RES_H_BMSK) << 8) | buffer[2];
 441                 printk("resolution = %d x %d\n", ts->resolution_x, ts->resolution_y);
 442         }
 443         return 0;
 444 }
 445
 446 static int sitronix_ts_set_powerdown_bit(struct sitronix_ts_data *ts, int value)
 447 {
 448         int ret = 0;
 449         uint8_t buffer[2];
 450
 451         DbgMsg("%s, value = %d\n", __FUNCTION__, value);
 452         buffer[0] = DEVICE_CONTROL_REG;
 453         ret = i2c_master_send(ts->client, buffer, 1);
 454         if (ret < 0){
 455                 printk("send device control command error (%d)\n", ret);
 456                 return ret;
 457         }
 458
 459         ret = i2c_master_recv(ts->client, buffer, 1);
 460         if (ret < 0){
 461                 printk("read device control status error (%d)\n", ret);
 462                 return ret;
 463         }else{
 464                 DbgMsg("dev status = %d \n", buffer[0]);
 465         }
 466
 467         if(value == 0)
 468                 buffer[1] = buffer[0] & 0xfd;
 469         else
 470                 buffer[1] = buffer[0] | 0x2;
 471
 472         buffer[0] = DEVICE_CONTROL_REG;
 473         ret = i2c_master_send(ts->client, buffer, 2);
 474         if (ret < 0){
 475                 printk("write power down error (%d)\n", ret);
 476                 return ret;
 477         }
 478
 479         return 0;
 480 }
 481
 482 static int sitronix_ts_get_touch_info(struct sitronix_ts_data *ts)
 483 {
 484         int ret = 0;
 485         ret = sitronix_get_resolution(ts);
 486         if(ret < 0)
 487                 return ret;
 488         ret = sitronix_get_fw_revision(ts);
 489         if(ret < 0)
 490                 return ret;
 491         if((ts->fw_revision[0] == 0) && (ts->fw_revision[1] == 0)){
 492                 ts->touch_protocol_type = SITRONIX_B_TYPE;
 493                 ts->pixel_length = PIXEL_DATA_LENGTH_B;
 494                 ts->max_touches = 2;
 495                 printk("i2c protocol = %d \n", ts->touch_protocol_type);
 496                 printk("max touches = %d \n",ts->max_touches);
 497         }else{
 498                 ret = sitronix_get_protocol_type(ts);
 499                 if(ret < 0)
 500                         return ret;
 501                 if(ts->touch_protocol_type == SITRONIX_B_TYPE){
 502                         ts->max_touches = 2;
 503                         printk("max touches = %d \n",ts->max_touches);
 504                 }else{
 505                         ret = sitronix_get_max_touches(ts);
 506                         if(ret < 0)
 507                                 return ret;
 508                 }
 509         }
 510         return 0;
 511 }
 512
 513 static int sitronix_ts_get_device_status(struct sitronix_ts_data *ts, uint8_t *dev_status)
 514 {
 515         int ret = 0;
 516         uint8_t buffer[8];
 517
 518         DbgMsg("%s\n", __FUNCTION__);
 519         buffer[0] = STATUS_REG;
 520         ret = i2c_master_send(ts->client, buffer, 1);
 521         if (ret < 0){
 522                 printk("send status reg command error (%d)\n", ret);
 523                 return ret;
 524         }
 525
 526         ret = i2c_master_recv(ts->client, buffer, 8);
 527         if (ret < 0){
 528                 printk("read status reg error (%d)\n", ret);
 529                 return ret;
 530         }else{
 531                 DbgMsg("status reg = %d \n", buffer[0]);
 532         }
 533
 534         *dev_status = buffer[0] & 0xf;
 535
 536         return 0;
 537 }
 538
 539 static int sitronix_ts_Enhance_Function_control(struct sitronix_ts_data *ts, uint8_t *value)
 540 {
 541         int ret = 0;
 542         uint8_t buffer[4];
 543
 544         DbgMsg("%s\n", __FUNCTION__);
 545         buffer[0] = 0xF0;
 546         ret = i2c_master_send(ts->client, buffer, 1);
 547         if (ret < 0){
 548                 printk("send Enhance Function command error (%d)\n", ret);
 549                 return ret;
 550         }
 551
 552         ret = i2c_master_recv(ts->client, buffer, 1);
 553         if (ret < 0){
 554                 printk("read Enhance Functions status error (%d)\n", ret);
 555                 return ret;
 556         }else{
 557                 DbgMsg("Enhance Functions status = %d \n", buffer[0]);
 558         }
 559
 560         *value = buffer[0] & 0x4;
 561
 562         return 0;
 563 }
 564
 565 static int sitronix_ts_FW_Bank_Select(struct sitronix_ts_data *ts, uint8_t value)
 566 {
 567         int ret = 0;
 568         uint8_t buffer[1];
 569
 570         DbgMsg("%s\n", __FUNCTION__);
 571         buffer[0] = 0xF1;
 572         ret = i2c_master_send(ts->client, buffer, 1);
 573         if (ret < 0){
 574                 printk("send FW Bank Select command error (%d)\n", ret);
 575                 return ret;
 576         }
 577
 578         ret = i2c_master_recv(ts->client, buffer, 1);
 579         if (ret < 0){
 580                 printk("read FW Bank Select status error (%d)\n", ret);
 581                 return ret;
 582         }else{
 583                 DbgMsg("FW Bank Select status = %d \n", buffer[0]);
 584         }
 585
 586         buffer[1] = ((buffer[0] & 0xfc) | value);
 587         buffer[0] = 0xF1;
 588         ret = i2c_master_send(ts->client, buffer, 2);
 589         if (ret < 0){
 590                 printk("send FW Bank Select command error (%d)\n", ret);
 591                 return ret;
 592         }
 593
 594         return 0;
 595 }
 596
 597 static int sitronix_get_id_info(struct sitronix_ts_data *ts, uint8_t *id_info)
 598 {
 599         int ret = 0;
 600         uint8_t buffer[4];
 601
 602         buffer[0] = 0x0C;
 603         ret = i2c_master_send(ts->client, buffer, 1);
 604         if (ret < 0){
 605                 printk("send id info command error (%d)\n", ret);
 606                 return ret;
 607         }
 608         ret = i2c_master_recv(ts->client, buffer, 4);
 609         if (ret < 0){
 610                 printk("read id info error (%d)\n", ret);
 611                 return ret;
 612         }else{
 613                 memcpy(id_info, buffer, 4);
 614         }
 615         return 0;
 616 }
 617
 618 static int sitronix_ts_identify(struct sitronix_ts_data *ts)
 619 {
 620         int ret = 0;
 621         uint8_t id[4];
 622         uint8_t Enhance_Function = 0;
 623
 624         ret = sitronix_ts_FW_Bank_Select(ts, 1);
 625         if(ret < 0)
 626                 return ret;
 627         ret = sitronix_ts_Enhance_Function_control(ts, &Enhance_Function);
 628         if(ret < 0)
 629                 return ret;
 630         if(Enhance_Function == 0x4){
 631                 ret = sitronix_get_id_info(ts, &id[0]);
 632                 if(ret < 0)
 633                         return ret;
 634                 printk("id (hex) = %x %x %x %x\n", id[0], id[1], id[2], id[3]);
 635                 if((id[0] == 1)&&(id[1] == 2)&&(id[2] == 0xb)&&(id[3] == 1)){
 636                         return 0;
 637                 }else{
 638                         printk("Error: It is not Sitronix IC\n");
 639                         return -1;
 640                 }
 641         }else{
 642                 printk("Error: Can not get ID of Sitronix IC\n");
 643                 return -1;
 644         }
 645 }
 646
 647 #ifdef SITRONIX_MONITOR_THREAD
 648 static int sitronix_ts_monitor_thread(void *data)
 649 {
 650         int ret = 0;
 651         uint8_t buffer[4];
 652         int result = 0;
 653         int once = 1;
 654         DbgMsg("%s:\n", __FUNCTION__);
 655
 656         printk("delay %d ms\n", sitronix_ts_delay_monitor_thread_start);
 657         msleep(sitronix_ts_delay_monitor_thread_start);
 658         while(!kthread_should_stop()){
 659                 DbgMsg("%s:\n", "Sitronix_ts_monitoring");
 660                 if(atomic_read(&iMonitorThreadPostpone)){
 661                                 atomic_set(&iMonitorThreadPostpone,0);
 662                 }else{
 663                         if(once == 1){
 664                                 buffer[0] = DEVICE_CONTROL_REG;
 665                                 ret = i2c_master_send(sitronix_ts_gpts->client, buffer, 1);
 666                                 if (ret < 0){
 667                                         DbgMsg("send device control command error (%d)\n", ret);
 668                                         goto exit_i2c_invalid;
 669                                 }
 670                                 ret = i2c_master_recv(sitronix_ts_gpts->client, buffer, 1);
 671                                 if (ret < 0){
 672                                         DbgMsg("read device control status error (%d)\n", ret);
 673                                         goto exit_i2c_invalid;
 674                                 }else{
 675                                         DbgMsg("read DEVICE_CONTROL_REG status = %d \n", buffer[0]);
 676                                 }
 677                                 buffer[0] &= 0xf3;
 678                                 ret = i2c_master_send(sitronix_ts_gpts->client, buffer, 1);
 679                                 if (ret < 0){
 680                                         DbgMsg("write power down error (%d)\n", ret);
 681                                         goto exit_i2c_invalid;
 682                                 }
 683                                 once = 0;
 684                         }
 685                         buffer[0] = 0x40;
 686                         ret = i2c_master_send(sitronix_ts_gpts->client, buffer, 1);
 687                         if (ret < 0){
 688                                 DbgMsg("send device control command error (%d)\n", ret);
 689                                 goto exit_i2c_invalid;
 690                         }
 691                         ret = i2c_master_recv(sitronix_ts_gpts->client, buffer, 4);
 692                         if (ret < 0){
 693                                 DbgMsg("read device 1D data error (%d)\n", ret);
 694                                 goto exit_i2c_invalid;
 695                         }else{
 696                                 DbgMsg("1D data h40-43 = %d, %d, %d, %d \n", buffer[0], buffer[1], buffer[2], buffer[3]);
 697                                 result = 1;
 698                                 if ((PreCheckData[0] == buffer[0]) && (PreCheckData[1] == buffer[1]) &&
 699                                 (PreCheckData[2] == buffer[2]) && (PreCheckData[3] == buffer[3]))
 700                                         StatusCheckCount ++;
 701                                 else
 702                                         StatusCheckCount =0;
 703                                 PreCheckData[0] = buffer[0];
 704                                 PreCheckData[1] = buffer[1];
 705                                 PreCheckData[2] = buffer[2];
 706                                 PreCheckData[3] = buffer[3];
 707                                 if (3 <= StatusCheckCount){
 708                                         DbgMsg("IC Status doesn't update! \n");
 709                                         result = -1;
 710                                         StatusCheckCount = 0;
 711                                 }
 712                         }
 713                         if (-1 == result){
 714                                 printk("Chip abnormal, reset it!\n");
 715                                 if(sitronix_ts_gpts->reset_ic)
 716                                         sitronix_ts_gpts->reset_ic();
 717                                 i2cErrorCount = 0;
 718                                 StatusCheckCount = 0;
 719                         }
 720 exit_i2c_invalid:
 721                         if(0 == result){
 722                                 i2cErrorCount ++;
 723                                 if ((2 <= i2cErrorCount)){
 724                                         printk("I2C abnormal, reset it!\n");
 725                                         if(sitronix_ts_gpts->reset_ic)
 726                                                 sitronix_ts_gpts->reset_ic();
 727                                         i2cErrorCount = 0;
 728                                         StatusCheckCount = 0;
 729                                 }
 730                         }else
 731                                 i2cErrorCount = 0;
 732                 }
 733                 msleep(gMonitorThreadSleepInterval);
 734         }
 735         DbgMsg("%s exit\n", __FUNCTION__);
 736         return 0;
 737 }
 738 #endif // SITRONIX_MONITOR_THREAD
 739
 740 static void sitronix_ts_work_func(struct work_struct *work)
 741 {
 742         int tmp = 0, i = 0;
 743 #ifdef SITRONIX_TOUCH_KEY
 744         int j;
 745 #endif // SITRONIX_TOUCH_KEY
 746         int ret;
 747 #ifndef SITRONIX_INT_POLLING_MODE
 748         struct sitronix_ts_data *ts = container_of(work, struct sitronix_ts_data, work);
 749 #else
 750         struct sitronix_ts_data *ts = container_of(to_delayed_work(work), struct sitronix_ts_data, work);
 751 #endif // SITRONIX_INT_POLLING_MODE
 752         uint8_t buffer[2+ SITRONIX_MAX_SUPPORTED_POINT * PIXEL_DATA_LENGTH_A];
 753         static MTD_STRUCTURE MTDStructure[SITRONIX_MAX_SUPPORTED_POINT]={{0}};
 754         uint8_t PixelCount = 0;
 755         static uint8_t all_clear = 1;
 756
 757         DbgMsg("%s\n",  __FUNCTION__);
 758         if(ts->suspend_state){
 759                 goto exit_invalid_data;
 760         }
 761
 762         // get finger count
 763         buffer[0] = FINGERS;
 764         ret = i2c_master_send(ts->client, buffer, 1);
 765         if (ret < 0)
 766                 printk("send finger command error (%d)\n", ret);
 767         ret = i2c_master_recv(ts->client, buffer, 2 + ts->max_touches * ts->pixel_length);
 768         if (ret < 0) {
 769                 printk("read finger error (%d)\n", ret);
 770                 i2cErrorCount ++;
 771                 goto exit_invalid_data;
 772         }else{
 773                 i2cErrorCount = 0;
 774 #ifdef SITRONIX_FINGER_COUNT_REG_ENABLE
 775                 PixelCount = buffer[0] & FINGERS_BMSK ;
 776 #else
 777                 for(i = 0; i < ts->max_touches; i++){
 778                         if(buffer[2 + i * ts->pixel_length] >= 0x80)
 779                                 PixelCount++;
 780                 }
 781 #endif // SITRONIX_FINGER_COUNT_REG_ENABLE
 782                 DbgMsg("fingers = %d\n", PixelCount);
 783         }
 784         DbgMsg("key buffer[1] = %d\n", buffer[1]);
 785 #ifdef SITRONIX_SENSOR_KEY
 786         if (PixelCount == 0)
 787         {
 788                 for(i = 0; i < SITRONIX_NUMBER_SENSOR_KEY; i++){
 789                         if(buffer[1] & (1 << i)){
 790                                 DbgMsg("key[%d] down\n", i);
 791                                 input_event(ts->input_dev, EV_KEY, sitronix_sensor_key[i], 1);
 792                         }else{
 793                                 DbgMsg("key[%d] up\n", i);
 794                                 input_event(ts->input_dev, EV_KEY, sitronix_sensor_key[i], 0);
 795                         }
 796                 }
 797         }
 798 #endif // SITRONIX_SENSOR_KEY
 799
 800         for(i = 0; i < ts->max_touches; i++){
 801 #ifndef SITRONIX_TOUCH_KEY
 802                 if((buffer[2 + ts->pixel_length * i] >> X_COORD_VALID_SHFT) == 1){
 803                         MTDStructure[i].Pixel_X = ((buffer[2 + ts->pixel_length * i] & (X_COORD_H_BMSK << X_COORD_H_SHFT)) << 4) |  (buffer[2 + ts->pixel_length * i + X_COORD_L]);
 804                         MTDStructure[i].Pixel_Y = ((buffer[2 + ts->pixel_length * i] & Y_COORD_H_BMSK) << 8) |  (buffer[2 + ts->pixel_length * i + Y_COORD_L]);
 805                         MTDStructure[i].Current_Pressed_area = AREA_DISPLAY;
 806                 }else
 807                         MTDStructure[i].Current_Pressed_area = AREA_NONE;
 808 #endif // SITRONIX_TOUCH_KEY
 809         }
 810
 811         if(PixelCount != 0)
 812         {
 813                 for(i = 0; i < ts->max_touches; i++)
 814                 {
 815 #ifndef SITRONIX_TOUCH_KEY
 816                         if(MTDStructure[i].Current_Pressed_area == AREA_DISPLAY)
 817                         {
 818                                 tmp = MTDStructure[i].Pixel_X;
 819                                 MTDStructure[i].Pixel_X = MTDStructure[i].Pixel_Y;
 820                                 MTDStructure[i].Pixel_Y = tmp;
 821
 822                                 MTDStructure[i].Pixel_X = MTDStructure[i].Pixel_X < 50  ? 3 + MTDStructure[i].Pixel_X : MTDStructure[i].Pixel_X*97/100;
 823                                 MTDStructure[i].Pixel_Y = MTDStructure[i].Pixel_Y < 50  ? 3 + MTDStructure[i].Pixel_Y : MTDStructure[i].Pixel_Y*98/100;
 824                                 input_mt_slot(ts->input_dev, i);
 825                                 input_report_abs(ts->input_dev,  ABS_MT_TRACKING_ID, i);
 826                                 input_report_abs(ts->input_dev,  ABS_MT_TOUCH_MAJOR, 200);
 827                                 input_report_abs(ts->input_dev,  ABS_MT_POSITION_X, MTDStructure[i].Pixel_X);
 828                                 input_report_abs(ts->input_dev,  ABS_MT_POSITION_Y, MTDStructure[i].Pixel_Y);
 829                                 input_report_abs(ts->input_dev,  ABS_MT_WIDTH_MAJOR, 100);
 830                                 DbgMsg("lr[%d](%d, %d)+\n", i, MTDStructure[i].Pixel_X, MTDStructure[i].Pixel_Y);
 831                         }else if(MTDStructure[i].Current_Pressed_area == AREA_NONE){
 832                                 DbgMsg("lr[%d](%d, %d)-\n", i, MTDStructure[i].Pixel_X, MTDStructure[i].Pixel_Y);
 833                                 input_mt_slot(ts->input_dev, i);
 834                                 input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, -1);
 835                         }
 836                         memcpy(&sitronix_ts_gMTDPreStructure[i], &MTDStructure[i], sizeof(MTD_STRUCTURE));
 837 #endif // SITRONIX_TOUCH_KEY
 838                 }
 839                 all_clear = 0;
 840 #ifdef SITRONIX_INT_POLLING_MODE
 841 #ifdef SITRONIX_MONITOR_THREAD
 842                 atomic_set(&iMonitorThreadPostpone,1);
 843 #endif // SITRONIX_MONITOR_THREAD
 844                 schedule_delayed_work(&ts->work, msecs_to_jiffies(INT_POLLING_MODE_INTERVAL));
 845 #endif // SITRONIX_INT_POLLING_MODE
 846         }
 847         else
 848         {
 849                 if(all_clear == 0)
 850                 {
 851                         DbgMsg("lr: all_clear\n");
 852                         for(i = 0; i < ts->max_touches; i++)
 853                         {
 854                                 input_mt_slot(ts->input_dev, i);
 855                                 input_report_abs(ts->input_dev,  ABS_MT_TRACKING_ID, -1);
 856                         }
 857                         all_clear = 1;
 858                 }
 859                 else
 860                 {
 861                         DbgMsg("ignore dummy finger leave\n");
 862                 }
 863 #ifdef SITRONIX_INT_POLLING_MODE
 864                 if (ts->use_irq){
 865                         sitronix_ts_irq_on = 1;
 866                         enable_irq(ts->irq);
 867                 }
 868 #endif // SITRONIX_INT_POLLING_MODE
 869         }
 870         input_sync(ts->input_dev);
 871
 872 exit_invalid_data:
 873 #if defined(SITRONIX_LEVEL_TRIGGERED)
 874         if (ts->use_irq){
 875                 sitronix_ts_irq_on = 1;
 876                 enable_irq(ts->irq);
 877         }
 878 #endif // defined(SITRONIX_LEVEL_TRIGGERED)
 879         if ((2 <= i2cErrorCount)){
 880                 printk("I2C abnormal in work_func(), reset it!\n");
 881                 if(sitronix_ts_gpts->reset_ic)
 882                         sitronix_ts_gpts->reset_ic();
 883                 i2cErrorCount = 0;
 884 #ifdef SITRONIX_MONITOR_THREAD
 885                 StatusCheckCount = 0;
 886 #endif // SITRONIX_MONITOR_THREAD
 887         }
 888 }
 889
 890
 891 static irqreturn_t sitronix_ts_irq_handler(int irq, void *dev_id)
 892 {
 893         struct sitronix_ts_data *ts = dev_id;
 894
 895 //      DbgMsg("%s\n", __FUNCTION__);
 896 //      printk("lr:%s\n", __FUNCTION__);
 897 #if defined(SITRONIX_LEVEL_TRIGGERED) || defined(SITRONIX_INT_POLLING_MODE)
 898         sitronix_ts_irq_on = 0;
 899         disable_irq_nosync(ts->irq);
 900 #endif // defined(SITRONIX_LEVEL_TRIGGERED) || defined(SITRONIX_INT_POLLING_MODE)
 901 #ifdef SITRONIX_MONITOR_THREAD
 902         atomic_set(&iMonitorThreadPostpone,1);
 903 #endif // SITRONIX_MONITOR_THREAD
 904 #ifndef SITRONIX_INT_POLLING_MODE
 905         schedule_work(&ts->work);
 906 #else
 907         schedule_delayed_work(&ts->work, msecs_to_jiffies(0));
 908 #endif // SITRONIX_INT_POLLING_MODE
 909         return IRQ_HANDLED;
 910 }
 911
 912 static int sitronix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
 913 {
 914 #if defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
 915         int i;
 916 #endif // defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
 917         struct sitronix_ts_data *ts;
 918         int ret = 0;
 919         uint16_t max_x = 0, max_y = 0;
 920         struct ft5x0x_platform_data *pdata;
 921         uint8_t dev_status = 0;
 922
 923 #ifdef CONFIG_RK_CONFIG
 924         struct port_config irq_cfg = get_port_config(irq);
 925
 926         client->irq = irq_cfg.gpio;
 927         tp_hw_init();
 928 #else
 929         pdata = client->dev.platform_data;
 930         if(pdata->init_platform_hw)
 931                 pdata->init_platform_hw();
 932 #endif
 933         printk("lr------> %s start ------\n", __FUNCTION__);
 934         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 935                 ret = -ENODEV;
 936                 goto err_check_functionality_failed;
 937         }
 938
 939         ts = kzalloc(sizeof(*ts), GFP_KERNEL);
 940         if (ts == NULL) {
 941                 ret = -ENOMEM;
 942                 goto err_alloc_data_failed;
 943         }
 944 #ifndef SITRONIX_INT_POLLING_MODE
 945         INIT_WORK(&ts->work, sitronix_ts_work_func);
 946 #else
 947         INIT_DELAYED_WORK(&ts->work, sitronix_ts_work_func);
 948 #endif // SITRONIX_INT_POLLING_MODE
 949         ts->client = client;
 950         if(client->irq != INVALID_GPIO)
 951                 ts->irq = gpio_to_irq(client->irq);
 952         i2c_set_clientdata(client, ts);
 953 #if 0
 954         if(pdata->reset_ic){
 955                 ts->reset_ic = pdata->reset_ic;
 956                 pdata->reset_ic();
 957                 mdelay(SITRONIX_TS_CHANGE_MODE_DELAY);
 958         }
 959 #endif
 960
 961         sitronix_ts_gpts = ts;
 962
 963         ret = sitronix_ts_get_device_status(ts, &dev_status);
 964         if((ret < 0) || (dev_status == 0x6))
 965                 goto err_device_info_error;
 966
 967         ret = sitronix_ts_get_touch_info(ts);
 968         if(ret < 0)
 969                 goto err_device_info_error;
 970
 971         //ret = sitronix_ts_identify(ts);
 972         //if(ret < 0)
 973         //      goto err_device_info_error;
 974
 975 #ifdef SITRONIX_MONITOR_THREAD
 976         //== Add thread to monitor chip
 977         atomic_set(&iMonitorThreadPostpone,1);
 978         SitronixMonitorThread = kthread_run(sitronix_ts_monitor_thread,"Sitronix","Monitorthread");
 979         if(IS_ERR(SitronixMonitorThread))
 980                 SitronixMonitorThread = NULL;
 981 #endif // SITRONIX_MONITOR_THREAD
 982
 983         ts->input_dev = input_allocate_device();
 984         if (ts->input_dev == NULL){
 985                 printk("Can not allocate memory for input device.");
 986                 ret = -ENOMEM;
 987                 goto err_input_dev_alloc_failed;
 988         }
 989
 990         ts->input_dev->name = "sitronix-i2c-touch-mt";
 991         //set_bit(EV_KEY, ts->input_dev->evbit);
 992         //set_bit(BTN_TOUCH, ts->input_dev->keybit);
 993         //set_bit(EV_ABS, ts->input_dev->evbit);
 994
 995 #if defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
 996         ts->keyevent_input = input_allocate_device();
 997         if (ts->keyevent_input == NULL){
 998                 printk("Can not allocate memory for key input device.");
 999                 ret = -ENOMEM;
1000                 goto err_input_dev_alloc_failed;
1001         }
1002         ts->keyevent_input->name  = "sitronix-i2c-touch-key";
1003         //set_bit(EV_KEY, ts->keyevent_input->evbit);
1004 #endif // defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1005 #if defined(SITRONIX_SENSOR_KEY)
1006         for(i = 0; i < SITRONIX_NUMBER_SENSOR_KEY; i++){
1007                 //set_bit(sitronix_sensor_key[i], ts->keyevent_input->keybit);
1008         }
1009 #endif // defined(SITRONIX_SENSOR_KEY)
1010
1011 #ifndef SITRONIX_TOUCH_KEY
1012         max_x = ts->resolution_x;
1013         max_y = ts->resolution_y;
1014 #else
1015 #ifdef SITRONIX_KEY_BOUNDARY_MANUAL_SPECIFY
1016         for(i = 0; i < SITRONIX_NUMBER_TOUCH_KEY; i++){
1017                 //set_bit(sitronix_key_array[i].code, ts->keyevent_input->keybit);
1018         }
1019         max_x = SITRONIX_TOUCH_RESOLUTION_X;
1020         max_y = SITRONIX_TOUCH_RESOLUTION_Y;
1021 #else
1022         for(i = 0; i < SITRONIX_NUMBER_TOUCH_KEY; i++){
1023                 sitronix_key_array[i].x_low = ((ts->resolution_x / SITRONIX_NUMBER_TOUCH_KEY ) * i ) + 15;
1024                 sitronix_key_array[i].x_high = ((ts->resolution_x / SITRONIX_NUMBER_TOUCH_KEY ) * (i + 1)) - 15;
1025                 sitronix_key_array[i].y_low = ts->resolution_y - ts->resolution_y / SCALE_KEY_HIGH_Y;
1026                 sitronix_key_array[i].y_high = ts->resolution_y;
1027                 DbgMsg("key[%d] %d, %d, %d, %d\n", i, sitronix_key_array[i].x_low, sitronix_key_array[i].x_high, sitronix_key_array[i].y_low, sitronix_key_array[i].y_high);
1028                 //set_bit(sitronix_key_array[i].code, ts->keyevent_input->keybit);
1029
1030         }
1031         max_x = ts->resolution_x;
1032         max_y = ts->resolution_y - ts->resolution_y / SCALE_KEY_HIGH_Y;
1033 #endif // SITRONIX_KEY_BOUNDARY_MANUAL_SPECIFY
1034 #endif // SITRONIX_TOUCH_KEY
1035 #if defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1036         ret = input_register_device(ts->keyevent_input);
1037         if(ret < 0){
1038                 printk("Can not register key input device.");
1039                 goto err_input_register_device_failed;
1040         }
1041 #endif // defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1042
1043         __set_bit(EV_ABS, ts->input_dev->evbit);
1044         __set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);
1045         set_bit(ABS_MT_POSITION_X, ts->input_dev->absbit);
1046         set_bit(ABS_MT_POSITION_Y, ts->input_dev->absbit);
1047         set_bit(ABS_MT_TOUCH_MAJOR, ts->input_dev->absbit);
1048         set_bit(ABS_MT_WIDTH_MAJOR, ts->input_dev->absbit);
1049         ts->max_touches = 5;
1050
1051         input_mt_init_slots(ts->input_dev, ts->max_touches);
1052 #ifdef CONFIG_RK_CONFIG
1053         input_set_abs_params(ts->input_dev,ABS_MT_POSITION_X, 0, x_max, 0, 0);
1054         input_set_abs_params(ts->input_dev,ABS_MT_POSITION_Y, 0, y_max, 0, 0);
1055 #else
1056         input_set_abs_params(ts->input_dev,ABS_MT_POSITION_X, 0, 800, 0, 0);
1057         input_set_abs_params(ts->input_dev,ABS_MT_POSITION_Y, 0, 480, 0, 0);
1058 #endif
1059         input_set_abs_params(ts->input_dev,ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
1060
1061         for (i = 0; i < ARRAY_SIZE(initkey_code); i++) {
1062                 input_set_capability(ts->input_dev, EV_KEY, initkey_code[i]);
1063         }
1064
1065         ret = input_register_device(ts->input_dev);
1066         if(ret < 0){
1067                 printk("Can not register input device.");
1068                 goto err_input_register_device_failed;
1069         }
1070
1071         ts->suspend_state = 0;
1072         if (ts->irq){
1073         #ifdef CONFIG_RK_CONFIG
1074                 ret = request_irq(ts->irq, sitronix_ts_irq_handler,  irq_cfg.irq.irq_flags | IRQF_DISABLED, client->name, ts);
1075         #else
1076                 #ifdef SITRONIX_LEVEL_TRIGGERED
1077                 ret = request_irq(ts->irq, sitronix_ts_irq_handler, IRQF_TRIGGER_LOW | IRQF_DISABLED, client->name, ts);
1078                 #else
1079                 ret = request_irq(ts->irq, sitronix_ts_irq_handler, IRQF_TRIGGER_FALLING | IRQF_DISABLED, client->name, ts);
1080                 #endif // SITRONIX_LEVEL_TRIGGERED
1081         #endif // CONFIG_RK_CONFIG
1082                 if (ret == 0){
1083                         sitronix_ts_irq_on = 1;
1084                         ts->use_irq = 1;
1085                 }else
1086                         dev_err(&client->dev, "request_irq failed\n");
1087         }
1088 #ifdef CONFIG_HAS_EARLYSUSPEND
1089         ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
1090         ts->early_suspend.suspend = sitronix_ts_early_suspend;
1091         ts->early_suspend.resume = sitronix_ts_late_resume;
1092         register_early_suspend(&ts->early_suspend);
1093 #endif // CONFIG_HAS_EARLYSUSPEND
1094
1095         printk("lr------> %s end ------\n", __FUNCTION__);
1096
1097         return 0;
1098
1099 err_input_register_device_failed:
1100         input_free_device(ts->input_dev);
1101 #if defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1102         input_free_device(ts->keyevent_input);
1103 #endif // defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1104 err_input_dev_alloc_failed:
1105         kfree(ts);
1106 err_alloc_data_failed:
1107 err_check_functionality_failed:
1108 #ifdef SITRONIX_MONITOR_THREAD
1109         if(SitronixMonitorThread){
1110               kthread_stop(SitronixMonitorThread);
1111               SitronixMonitorThread = NULL;
1112         }
1113 #endif // SITRONIX_MONITOR_THREAD
1114 err_device_info_error:
1115         gpio_free(RK2928_PIN1_PA3);
1116         gpio_free(RK2928_PIN1_PB3);
1117
1118         return ret;
1119 }
1120
1121 static int sitronix_ts_remove(struct i2c_client *client)
1122 {
1123         struct sitronix_ts_data *ts = i2c_get_clientdata(client);
1124 #ifdef CONFIG_HAS_EARLYSUSPEND
1125         unregister_early_suspend(&ts->early_suspend);
1126 #endif // CONFIG_HAS_EARLYSUSPEND
1127 #ifdef SITRONIX_MONITOR_THREAD
1128         if(SitronixMonitorThread){
1129               kthread_stop(SitronixMonitorThread);
1130               SitronixMonitorThread = NULL;
1131         }
1132 #endif // SITRONIX_MONITOR_THREAD
1133         if (ts->use_irq)
1134                 free_irq(ts->irq, ts);
1135         else
1136                 hrtimer_cancel(&ts->timer);
1137         input_unregister_device(ts->input_dev);
1138 #if defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1139         input_unregister_device(ts->keyevent_input);
1140 #endif // defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1141         kfree(ts);
1142         return 0;
1143 }
1144
1145 static int sitronix_ts_suspend(struct i2c_client *client, pm_message_t mesg)
1146 {
1147         int ret = 0, i = 0;
1148         struct sitronix_ts_data *ts = i2c_get_clientdata(client);
1149
1150         DbgMsg("%s\n", __FUNCTION__);
1151 #ifdef SITRONIX_MONITOR_THREAD
1152         if(SitronixMonitorThread){
1153                 kthread_stop(SitronixMonitorThread);
1154                 SitronixMonitorThread = NULL;
1155         }
1156         sitronix_ts_delay_monitor_thread_start = DELAY_MONITOR_THREAD_START_RESUME;
1157 #endif // SITRONIX_MONITOR_THREAD
1158         if(ts->use_irq){
1159                 sitronix_ts_irq_on = 0;
1160                 disable_irq_nosync(ts->irq);
1161         }
1162         ts->suspend_state = 1;
1163
1164         ret = sitronix_ts_set_powerdown_bit(ts, 1);
1165 #ifdef SITRONIX_WAKE_UP_TOUCH_BY_INT
1166         gpio_direction_output(client->irq, 1);
1167 #endif // SITRONIX_WAKE_UP_TOUCH_BY_INT
1168         DbgMsg("%s return\n", __FUNCTION__);
1169
1170         for(i = 0; i < ts->max_touches; i++)
1171         {
1172                 input_mt_slot(ts->input_dev, i);
1173                 input_report_abs(ts->input_dev,  ABS_MT_TRACKING_ID, -1);
1174         }
1175         input_sync(ts->input_dev);
1176
1177         return 0;
1178 }
1179
1180 static int sitronix_ts_resume(struct i2c_client *client)
1181 {
1182 #ifdef SITRONIX_WAKE_UP_TOUCH_BY_INT
1183         unsigned int gpio;
1184 #else
1185         int ret;
1186 #endif // SITRONIX_WAKE_UP_TOUCH_BY_INT
1187         struct sitronix_ts_data *ts = i2c_get_clientdata(client);
1188
1189         DbgMsg("%s\n", __FUNCTION__);
1190
1191 #ifdef SITRONIX_WAKE_UP_TOUCH_BY_INT
1192         gpio = client->irq;
1193         gpio_set_value(gpio, 0);
1194         gpio_direction_input(gpio);
1195 #else
1196         ret = sitronix_ts_set_powerdown_bit(ts, 0);
1197 #endif // SITRONIX_WAKE_UP_TOUCH_BY_INT
1198
1199         ts->suspend_state = 0;
1200         if(ts->use_irq){
1201                 sitronix_ts_irq_on = 1;
1202                 enable_irq(ts->irq);
1203         }
1204 #ifdef SITRONIX_MONITOR_THREAD
1205         atomic_set(&iMonitorThreadPostpone,1);
1206         SitronixMonitorThread = kthread_run(sitronix_ts_monitor_thread,"Sitronix","Monitorthread");
1207         if(IS_ERR(SitronixMonitorThread))
1208                 SitronixMonitorThread = NULL;
1209 #endif // SITRONIX_MONITOR_THREAD
1210         DbgMsg("%s return\n", __FUNCTION__);
1211
1212         return 0;
1213 }
1214
1215 #ifdef CONFIG_HAS_EARLYSUSPEND
1216 static void sitronix_ts_early_suspend(struct early_suspend *h)
1217 {
1218         struct sitronix_ts_data *ts;
1219         DbgMsg("%s\n", __FUNCTION__);
1220         ts = container_of(h, struct sitronix_ts_data, early_suspend);
1221         sitronix_ts_suspend(ts->client, PMSG_SUSPEND);
1222 }
1223
1224 static void sitronix_ts_late_resume(struct early_suspend *h)
1225 {
1226         struct sitronix_ts_data *ts;
1227         DbgMsg("%s\n", __FUNCTION__);
1228         ts = container_of(h, struct sitronix_ts_data, early_suspend);
1229         sitronix_ts_resume(ts->client);
1230 }
1231 #endif // CONFIG_HAS_EARLYSUSPEND
1232
1233 static const struct i2c_device_id sitronix_ts_id[] = {
1234         { SITRONIX_I2C_TOUCH_DRV_NAME, 0 },
1235         { }
1236 };
1237
1238 static struct i2c_driver sitronix_ts_driver = {
1239         .probe          = sitronix_ts_probe,
1240         .remove         = sitronix_ts_remove,
1241         .id_table       = sitronix_ts_id,
1242         .driver = {
1243                 .name   = SITRONIX_I2C_TOUCH_DRV_NAME,
1244         },
1245 };
1246
1247 #ifdef SITRONIX_FW_UPGRADE_FEATURE
1248 static struct file_operations nc_fops = {
1249         .owner =        THIS_MODULE,
1250         .write          = sitronix_write,
1251         .read           = sitronix_read,
1252         .open           = sitronix_open,
1253         .unlocked_ioctl = sitronix_ioctl,
1254         .release        = sitronix_release,
1255 };
1256 #endif // SITRONIX_FW_UPGRADE_FEATURE
1257
1258 static int __devinit sitronix_ts_init(void)
1259 {
1260 #ifdef SITRONIX_FW_UPGRADE_FEATURE
1261         int result;
1262         int err = 0;
1263 #endif // SITRONIX_FW_UPGRADE_FEATURE
1264
1265 #ifdef CONFIG_RK_CONFIG
1266         int ret = tp_board_init();
1267
1268         if(ret < 0)
1269                 return ret;
1270 #endif
1271         printk("Sitronix touch driver %d.%d.%d\n", DRIVER_MAJOR, DRIVER_MINOR, DRIVER_PATCHLEVEL);
1272         printk("Release date: %s\n", DRIVER_DATE);
1273 #ifdef SITRONIX_FW_UPGRADE_FEATURE
1274         dev_t devno = MKDEV(sitronix_major, 0);
1275         result  = alloc_chrdev_region(&devno, 0, 1, SITRONIX_I2C_TOUCH_DEV_NAME);
1276         if(result < 0){
1277                 printk("fail to allocate chrdev (%d) \n", result);
1278                 return 0;
1279         }
1280         sitronix_major = MAJOR(devno);
1281         cdev_init(&sitronix_cdev, &nc_fops);
1282         sitronix_cdev.owner = THIS_MODULE;
1283         sitronix_cdev.ops = &nc_fops;
1284         err =  cdev_add(&sitronix_cdev, devno, 1);
1285         if(err){
1286                 printk("fail to add cdev (%d) \n", err);
1287                 return 0;
1288         }
1289
1290         sitronix_class = class_create(THIS_MODULE, SITRONIX_I2C_TOUCH_DEV_NAME);
1291         if (IS_ERR(sitronix_class)) {
1292                 result = PTR_ERR(sitronix_class);
1293                 unregister_chrdev(sitronix_major, SITRONIX_I2C_TOUCH_DEV_NAME);
1294                 printk("fail to create class (%d) \n", result);
1295                 return result;
1296         }
1297         device_create(sitronix_class, NULL, MKDEV(sitronix_major, 0), NULL, SITRONIX_I2C_TOUCH_DEV_NAME);
1298 #endif // SITRONIX_FW_UPGRADE_FEATURE
1299
1300
1301         return i2c_add_driver(&sitronix_ts_driver);
1302 }
1303
1304 static void __exit sitronix_ts_exit(void)
1305 {
1306 #ifdef SITRONIX_FW_UPGRADE_FEATURE
1307         dev_t dev_id = MKDEV(sitronix_major, 0);
1308 #endif // SITRONIX_FW_UPGRADE_FEATURE
1309         i2c_del_driver(&sitronix_ts_driver);
1310 #ifdef SITRONIX_FW_UPGRADE_FEATURE
1311         cdev_del(&sitronix_cdev);
1312
1313         device_destroy(sitronix_class, dev_id); //delete device node under /dev
1314         class_destroy(sitronix_class); //delete class created by us
1315         unregister_chrdev_region(dev_id, 1);
1316 #endif // SITRONIX_FW_UPGRADE_FEATURE
1317 }
1318
1319 module_init(sitronix_ts_init);
1320 module_exit(sitronix_ts_exit);
1321
1322 MODULE_DESCRIPTION("Sitronix Multi-Touch Driver");
1323 MODULE_LICENSE("GPL");