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