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                                 #if defined(CONFIG_MACH_RK2926_V86_VERSION_1_1)
 829                                 input_report_abs(ts->input_dev,  ABS_MT_POSITION_Y, 480 - MTDStructure[i].Pixel_Y);
 830                                 #else
 831                                 input_report_abs(ts->input_dev,  ABS_MT_POSITION_Y, MTDStructure[i].Pixel_Y);
 832                                 #endif
 833                                 input_report_abs(ts->input_dev,  ABS_MT_WIDTH_MAJOR, 100);
 834                                 DbgMsg("lr[%d](%d, %d)+\n", i, MTDStructure[i].Pixel_X, MTDStructure[i].Pixel_Y);
 835                         }else if(MTDStructure[i].Current_Pressed_area == AREA_NONE){
 836                                 DbgMsg("lr[%d](%d, %d)-\n", i, MTDStructure[i].Pixel_X, MTDStructure[i].Pixel_Y);
 837                                 input_mt_slot(ts->input_dev, i);
 838                                 input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, -1);
 839                         }
 840                         memcpy(&sitronix_ts_gMTDPreStructure[i], &MTDStructure[i], sizeof(MTD_STRUCTURE));
 841 #endif // SITRONIX_TOUCH_KEY
 842                 }
 843                 all_clear = 0;
 844 #ifdef SITRONIX_INT_POLLING_MODE
 845 #ifdef SITRONIX_MONITOR_THREAD
 846                 atomic_set(&iMonitorThreadPostpone,1);
 847 #endif // SITRONIX_MONITOR_THREAD
 848                 schedule_delayed_work(&ts->work, msecs_to_jiffies(INT_POLLING_MODE_INTERVAL));
 849 #endif // SITRONIX_INT_POLLING_MODE
 850         }
 851         else
 852         {
 853                 if(all_clear == 0)
 854                 {
 855                         DbgMsg("lr: all_clear\n");
 856                         for(i = 0; i < ts->max_touches; i++)
 857                         {
 858                                 input_mt_slot(ts->input_dev, i);
 859                                 input_report_abs(ts->input_dev,  ABS_MT_TRACKING_ID, -1);
 860                         }
 861                         all_clear = 1;
 862                 }
 863                 else
 864                 {
 865                         DbgMsg("ignore dummy finger leave\n");
 866                 }
 867 #ifdef SITRONIX_INT_POLLING_MODE
 868                 if (ts->use_irq){
 869                         sitronix_ts_irq_on = 1;
 870                         enable_irq(ts->irq);
 871                 }
 872 #endif // SITRONIX_INT_POLLING_MODE
 873         }
 874         input_sync(ts->input_dev);
 875
 876 exit_invalid_data:
 877 #if defined(SITRONIX_LEVEL_TRIGGERED)
 878         if (ts->use_irq){
 879                 sitronix_ts_irq_on = 1;
 880                 enable_irq(ts->irq);
 881         }
 882 #endif // defined(SITRONIX_LEVEL_TRIGGERED)
 883         if ((2 <= i2cErrorCount)){
 884                 printk("I2C abnormal in work_func(), reset it!\n");
 885                 if(sitronix_ts_gpts->reset_ic)
 886                         sitronix_ts_gpts->reset_ic();
 887                 i2cErrorCount = 0;
 888 #ifdef SITRONIX_MONITOR_THREAD
 889                 StatusCheckCount = 0;
 890 #endif // SITRONIX_MONITOR_THREAD
 891         }
 892 }
 893
 894
 895 static irqreturn_t sitronix_ts_irq_handler(int irq, void *dev_id)
 896 {
 897         struct sitronix_ts_data *ts = dev_id;
 898
 899 //      DbgMsg("%s\n", __FUNCTION__);
 900 //      printk("lr:%s\n", __FUNCTION__);
 901 #if defined(SITRONIX_LEVEL_TRIGGERED) || defined(SITRONIX_INT_POLLING_MODE)
 902         sitronix_ts_irq_on = 0;
 903         disable_irq_nosync(ts->irq);
 904 #endif // defined(SITRONIX_LEVEL_TRIGGERED) || defined(SITRONIX_INT_POLLING_MODE)
 905 #ifdef SITRONIX_MONITOR_THREAD
 906         atomic_set(&iMonitorThreadPostpone,1);
 907 #endif // SITRONIX_MONITOR_THREAD
 908 #ifndef SITRONIX_INT_POLLING_MODE
 909         schedule_work(&ts->work);
 910 #else
 911         schedule_delayed_work(&ts->work, msecs_to_jiffies(0));
 912 #endif // SITRONIX_INT_POLLING_MODE
 913         return IRQ_HANDLED;
 914 }
 915
 916 static int sitronix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
 917 {
 918 #if defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
 919         int i;
 920 #endif // defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
 921         struct sitronix_ts_data *ts;
 922         int ret = 0;
 923         uint16_t max_x = 0, max_y = 0;
 924         struct ft5x0x_platform_data *pdata;
 925         uint8_t dev_status = 0;
 926
 927 #ifdef CONFIG_RK_CONFIG
 928         struct port_config irq_cfg = get_port_config(irq);
 929
 930         client->irq = irq_cfg.gpio;
 931         tp_hw_init();
 932 #else
 933         pdata = client->dev.platform_data;
 934         if(pdata->init_platform_hw)
 935                 pdata->init_platform_hw();
 936 #endif
 937         printk("lr------> %s start ------\n", __FUNCTION__);
 938         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 939                 ret = -ENODEV;
 940                 goto err_check_functionality_failed;
 941         }
 942
 943         ts = kzalloc(sizeof(*ts), GFP_KERNEL);
 944         if (ts == NULL) {
 945                 ret = -ENOMEM;
 946                 goto err_alloc_data_failed;
 947         }
 948 #ifndef SITRONIX_INT_POLLING_MODE
 949         INIT_WORK(&ts->work, sitronix_ts_work_func);
 950 #else
 951         INIT_DELAYED_WORK(&ts->work, sitronix_ts_work_func);
 952 #endif // SITRONIX_INT_POLLING_MODE
 953         ts->client = client;
 954         if(client->irq != INVALID_GPIO)
 955                 ts->irq = gpio_to_irq(client->irq);
 956         i2c_set_clientdata(client, ts);
 957 #if 0
 958         if(pdata->reset_ic){
 959                 ts->reset_ic = pdata->reset_ic;
 960                 pdata->reset_ic();
 961                 mdelay(SITRONIX_TS_CHANGE_MODE_DELAY);
 962         }
 963 #endif
 964
 965         sitronix_ts_gpts = ts;
 966
 967         ret = sitronix_ts_get_device_status(ts, &dev_status);
 968         if((ret < 0) || (dev_status == 0x6))
 969                 goto err_device_info_error;
 970
 971         ret = sitronix_ts_get_touch_info(ts);
 972         if(ret < 0)
 973                 goto err_device_info_error;
 974
 975         //ret = sitronix_ts_identify(ts);
 976         //if(ret < 0)
 977         //      goto err_device_info_error;
 978
 979 #ifdef SITRONIX_MONITOR_THREAD
 980         //== Add thread to monitor chip
 981         atomic_set(&iMonitorThreadPostpone,1);
 982         SitronixMonitorThread = kthread_run(sitronix_ts_monitor_thread,"Sitronix","Monitorthread");
 983         if(IS_ERR(SitronixMonitorThread))
 984                 SitronixMonitorThread = NULL;
 985 #endif // SITRONIX_MONITOR_THREAD
 986
 987         ts->input_dev = input_allocate_device();
 988         if (ts->input_dev == NULL){
 989                 printk("Can not allocate memory for input device.");
 990                 ret = -ENOMEM;
 991                 goto err_input_dev_alloc_failed;
 992         }
 993
 994         ts->input_dev->name = "sitronix-i2c-touch-mt";
 995         //set_bit(EV_KEY, ts->input_dev->evbit);
 996         //set_bit(BTN_TOUCH, ts->input_dev->keybit);
 997         //set_bit(EV_ABS, ts->input_dev->evbit);
 998
 999 #if defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1000         ts->keyevent_input = input_allocate_device();
1001         if (ts->keyevent_input == NULL){
1002                 printk("Can not allocate memory for key input device.");
1003                 ret = -ENOMEM;
1004                 goto err_input_dev_alloc_failed;
1005         }
1006         ts->keyevent_input->name  = "sitronix-i2c-touch-key";
1007         //set_bit(EV_KEY, ts->keyevent_input->evbit);
1008 #endif // defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1009 #if defined(SITRONIX_SENSOR_KEY)
1010         for(i = 0; i < SITRONIX_NUMBER_SENSOR_KEY; i++){
1011                 //set_bit(sitronix_sensor_key[i], ts->keyevent_input->keybit);
1012         }
1013 #endif // defined(SITRONIX_SENSOR_KEY)
1014
1015 #ifndef SITRONIX_TOUCH_KEY
1016         max_x = ts->resolution_x;
1017         max_y = ts->resolution_y;
1018 #else
1019 #ifdef SITRONIX_KEY_BOUNDARY_MANUAL_SPECIFY
1020         for(i = 0; i < SITRONIX_NUMBER_TOUCH_KEY; i++){
1021                 //set_bit(sitronix_key_array[i].code, ts->keyevent_input->keybit);
1022         }
1023         max_x = SITRONIX_TOUCH_RESOLUTION_X;
1024         max_y = SITRONIX_TOUCH_RESOLUTION_Y;
1025 #else
1026         for(i = 0; i < SITRONIX_NUMBER_TOUCH_KEY; i++){
1027                 sitronix_key_array[i].x_low = ((ts->resolution_x / SITRONIX_NUMBER_TOUCH_KEY ) * i ) + 15;
1028                 sitronix_key_array[i].x_high = ((ts->resolution_x / SITRONIX_NUMBER_TOUCH_KEY ) * (i + 1)) - 15;
1029                 sitronix_key_array[i].y_low = ts->resolution_y - ts->resolution_y / SCALE_KEY_HIGH_Y;
1030                 sitronix_key_array[i].y_high = ts->resolution_y;
1031                 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);
1032                 //set_bit(sitronix_key_array[i].code, ts->keyevent_input->keybit);
1033
1034         }
1035         max_x = ts->resolution_x;
1036         max_y = ts->resolution_y - ts->resolution_y / SCALE_KEY_HIGH_Y;
1037 #endif // SITRONIX_KEY_BOUNDARY_MANUAL_SPECIFY
1038 #endif // SITRONIX_TOUCH_KEY
1039 #if defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1040         ret = input_register_device(ts->keyevent_input);
1041         if(ret < 0){
1042                 printk("Can not register key input device.");
1043                 goto err_input_register_device_failed;
1044         }
1045 #endif // defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1046
1047         __set_bit(EV_ABS, ts->input_dev->evbit);
1048         __set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);
1049         set_bit(ABS_MT_POSITION_X, ts->input_dev->absbit);
1050         set_bit(ABS_MT_POSITION_Y, ts->input_dev->absbit);
1051         set_bit(ABS_MT_TOUCH_MAJOR, ts->input_dev->absbit);
1052         set_bit(ABS_MT_WIDTH_MAJOR, ts->input_dev->absbit);
1053         ts->max_touches = 5;
1054
1055         input_mt_init_slots(ts->input_dev, ts->max_touches);
1056 #ifdef CONFIG_RK_CONFIG
1057         input_set_abs_params(ts->input_dev,ABS_MT_POSITION_X, 0, x_max, 0, 0);
1058         input_set_abs_params(ts->input_dev,ABS_MT_POSITION_Y, 0, y_max, 0, 0);
1059 #else
1060         input_set_abs_params(ts->input_dev,ABS_MT_POSITION_X, 0, 800, 0, 0);
1061         input_set_abs_params(ts->input_dev,ABS_MT_POSITION_Y, 0, 480, 0, 0);
1062 #endif
1063         input_set_abs_params(ts->input_dev,ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
1064
1065         for (i = 0; i < ARRAY_SIZE(initkey_code); i++) {
1066                 input_set_capability(ts->input_dev, EV_KEY, initkey_code[i]);
1067         }
1068
1069         ret = input_register_device(ts->input_dev);
1070         if(ret < 0){
1071                 printk("Can not register input device.");
1072                 goto err_input_register_device_failed;
1073         }
1074
1075         ts->suspend_state = 0;
1076         if (ts->irq){
1077         #ifdef CONFIG_RK_CONFIG
1078                 ret = request_irq(ts->irq, sitronix_ts_irq_handler,  irq_cfg.irq.irq_flags | IRQF_DISABLED, client->name, ts);
1079         #else
1080                 #ifdef SITRONIX_LEVEL_TRIGGERED
1081                 ret = request_irq(ts->irq, sitronix_ts_irq_handler, IRQF_TRIGGER_LOW | IRQF_DISABLED, client->name, ts);
1082                 #else
1083                 ret = request_irq(ts->irq, sitronix_ts_irq_handler, IRQF_TRIGGER_FALLING | IRQF_DISABLED, client->name, ts);
1084                 #endif // SITRONIX_LEVEL_TRIGGERED
1085         #endif // CONFIG_RK_CONFIG
1086                 if (ret == 0){
1087                         sitronix_ts_irq_on = 1;
1088                         ts->use_irq = 1;
1089                 }else
1090                         dev_err(&client->dev, "request_irq failed\n");
1091         }
1092 #ifdef CONFIG_HAS_EARLYSUSPEND
1093         ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
1094         ts->early_suspend.suspend = sitronix_ts_early_suspend;
1095         ts->early_suspend.resume = sitronix_ts_late_resume;
1096         register_early_suspend(&ts->early_suspend);
1097 #endif // CONFIG_HAS_EARLYSUSPEND
1098
1099         printk("lr------> %s end ------\n", __FUNCTION__);
1100
1101         return 0;
1102
1103 err_input_register_device_failed:
1104         input_free_device(ts->input_dev);
1105 #if defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1106         input_free_device(ts->keyevent_input);
1107 #endif // defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1108 err_input_dev_alloc_failed:
1109         kfree(ts);
1110 err_alloc_data_failed:
1111 err_check_functionality_failed:
1112 #ifdef SITRONIX_MONITOR_THREAD
1113         if(SitronixMonitorThread){
1114               kthread_stop(SitronixMonitorThread);
1115               SitronixMonitorThread = NULL;
1116         }
1117 #endif // SITRONIX_MONITOR_THREAD
1118 err_device_info_error:
1119         gpio_free(RK2928_PIN1_PA3);
1120         gpio_free(RK2928_PIN1_PB3);
1121
1122         return ret;
1123 }
1124
1125 static int sitronix_ts_remove(struct i2c_client *client)
1126 {
1127         struct sitronix_ts_data *ts = i2c_get_clientdata(client);
1128 #ifdef CONFIG_HAS_EARLYSUSPEND
1129         unregister_early_suspend(&ts->early_suspend);
1130 #endif // CONFIG_HAS_EARLYSUSPEND
1131 #ifdef SITRONIX_MONITOR_THREAD
1132         if(SitronixMonitorThread){
1133               kthread_stop(SitronixMonitorThread);
1134               SitronixMonitorThread = NULL;
1135         }
1136 #endif // SITRONIX_MONITOR_THREAD
1137         if (ts->use_irq)
1138                 free_irq(ts->irq, ts);
1139         else
1140                 hrtimer_cancel(&ts->timer);
1141         input_unregister_device(ts->input_dev);
1142 #if defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1143         input_unregister_device(ts->keyevent_input);
1144 #endif // defined(SITRONIX_SENSOR_KEY) || defined (SITRONIX_TOUCH_KEY)
1145         kfree(ts);
1146         return 0;
1147 }
1148
1149 static int sitronix_ts_suspend(struct i2c_client *client, pm_message_t mesg)
1150 {
1151         int ret = 0, i = 0;
1152         struct sitronix_ts_data *ts = i2c_get_clientdata(client);
1153
1154         DbgMsg("%s\n", __FUNCTION__);
1155 #ifdef SITRONIX_MONITOR_THREAD
1156         if(SitronixMonitorThread){
1157                 kthread_stop(SitronixMonitorThread);
1158                 SitronixMonitorThread = NULL;
1159         }
1160         sitronix_ts_delay_monitor_thread_start = DELAY_MONITOR_THREAD_START_RESUME;
1161 #endif // SITRONIX_MONITOR_THREAD
1162         if(ts->use_irq){
1163                 sitronix_ts_irq_on = 0;
1164                 disable_irq_nosync(ts->irq);
1165         }
1166         ts->suspend_state = 1;
1167
1168         ret = sitronix_ts_set_powerdown_bit(ts, 1);
1169 #ifdef SITRONIX_WAKE_UP_TOUCH_BY_INT
1170         gpio_direction_output(client->irq, 1);
1171 #endif // SITRONIX_WAKE_UP_TOUCH_BY_INT
1172         DbgMsg("%s return\n", __FUNCTION__);
1173
1174         for(i = 0; i < ts->max_touches; i++)
1175         {
1176                 input_mt_slot(ts->input_dev, i);
1177                 input_report_abs(ts->input_dev,  ABS_MT_TRACKING_ID, -1);
1178         }
1179         input_sync(ts->input_dev);
1180
1181         return 0;
1182 }
1183
1184 static int sitronix_ts_resume(struct i2c_client *client)
1185 {
1186 #ifdef SITRONIX_WAKE_UP_TOUCH_BY_INT
1187         unsigned int gpio;
1188 #else
1189         int ret;
1190 #endif // SITRONIX_WAKE_UP_TOUCH_BY_INT
1191         struct sitronix_ts_data *ts = i2c_get_clientdata(client);
1192
1193         DbgMsg("%s\n", __FUNCTION__);
1194
1195 #ifdef SITRONIX_WAKE_UP_TOUCH_BY_INT
1196         gpio = client->irq;
1197         gpio_set_value(gpio, 0);
1198         gpio_direction_input(gpio);
1199 #else
1200         ret = sitronix_ts_set_powerdown_bit(ts, 0);
1201 #endif // SITRONIX_WAKE_UP_TOUCH_BY_INT
1202
1203         ts->suspend_state = 0;
1204         if(ts->use_irq){
1205                 sitronix_ts_irq_on = 1;
1206                 enable_irq(ts->irq);
1207         }
1208 #ifdef SITRONIX_MONITOR_THREAD
1209         atomic_set(&iMonitorThreadPostpone,1);
1210         SitronixMonitorThread = kthread_run(sitronix_ts_monitor_thread,"Sitronix","Monitorthread");
1211         if(IS_ERR(SitronixMonitorThread))
1212                 SitronixMonitorThread = NULL;
1213 #endif // SITRONIX_MONITOR_THREAD
1214         DbgMsg("%s return\n", __FUNCTION__);
1215
1216         return 0;
1217 }
1218
1219 #ifdef CONFIG_HAS_EARLYSUSPEND
1220 static void sitronix_ts_early_suspend(struct early_suspend *h)
1221 {
1222         struct sitronix_ts_data *ts;
1223         DbgMsg("%s\n", __FUNCTION__);
1224         ts = container_of(h, struct sitronix_ts_data, early_suspend);
1225         sitronix_ts_suspend(ts->client, PMSG_SUSPEND);
1226 }
1227
1228 static void sitronix_ts_late_resume(struct early_suspend *h)
1229 {
1230         struct sitronix_ts_data *ts;
1231         DbgMsg("%s\n", __FUNCTION__);
1232         ts = container_of(h, struct sitronix_ts_data, early_suspend);
1233         sitronix_ts_resume(ts->client);
1234 }
1235 #endif // CONFIG_HAS_EARLYSUSPEND
1236
1237 static const struct i2c_device_id sitronix_ts_id[] = {
1238         { SITRONIX_I2C_TOUCH_DRV_NAME, 0 },
1239         { }
1240 };
1241
1242 static struct i2c_driver sitronix_ts_driver = {
1243         .probe          = sitronix_ts_probe,
1244         .remove         = sitronix_ts_remove,
1245         .id_table       = sitronix_ts_id,
1246         .driver = {
1247                 .name   = SITRONIX_I2C_TOUCH_DRV_NAME,
1248         },
1249 };
1250
1251 #ifdef SITRONIX_FW_UPGRADE_FEATURE
1252 static struct file_operations nc_fops = {
1253         .owner =        THIS_MODULE,
1254         .write          = sitronix_write,
1255         .read           = sitronix_read,
1256         .open           = sitronix_open,
1257         .unlocked_ioctl = sitronix_ioctl,
1258         .release        = sitronix_release,
1259 };
1260 #endif // SITRONIX_FW_UPGRADE_FEATURE
1261
1262 static int __init sitronix_ts_init(void)
1263 {
1264 #ifdef SITRONIX_FW_UPGRADE_FEATURE
1265         int result;
1266         int err = 0;
1267 #endif // SITRONIX_FW_UPGRADE_FEATURE
1268
1269 #ifdef CONFIG_RK_CONFIG
1270         int ret = tp_board_init();
1271
1272         if(ret < 0)
1273                 return ret;
1274 #endif
1275         printk("Sitronix touch driver %d.%d.%d\n", DRIVER_MAJOR, DRIVER_MINOR, DRIVER_PATCHLEVEL);
1276         printk("Release date: %s\n", DRIVER_DATE);
1277 #ifdef SITRONIX_FW_UPGRADE_FEATURE
1278         dev_t devno = MKDEV(sitronix_major, 0);
1279         result  = alloc_chrdev_region(&devno, 0, 1, SITRONIX_I2C_TOUCH_DEV_NAME);
1280         if(result < 0){
1281                 printk("fail to allocate chrdev (%d) \n", result);
1282                 return 0;
1283         }
1284         sitronix_major = MAJOR(devno);
1285         cdev_init(&sitronix_cdev, &nc_fops);
1286         sitronix_cdev.owner = THIS_MODULE;
1287         sitronix_cdev.ops = &nc_fops;
1288         err =  cdev_add(&sitronix_cdev, devno, 1);
1289         if(err){
1290                 printk("fail to add cdev (%d) \n", err);
1291                 return 0;
1292         }
1293
1294         sitronix_class = class_create(THIS_MODULE, SITRONIX_I2C_TOUCH_DEV_NAME);
1295         if (IS_ERR(sitronix_class)) {
1296                 result = PTR_ERR(sitronix_class);
1297                 unregister_chrdev(sitronix_major, SITRONIX_I2C_TOUCH_DEV_NAME);
1298                 printk("fail to create class (%d) \n", result);
1299                 return result;
1300         }
1301         device_create(sitronix_class, NULL, MKDEV(sitronix_major, 0), NULL, SITRONIX_I2C_TOUCH_DEV_NAME);
1302 #endif // SITRONIX_FW_UPGRADE_FEATURE
1303
1304
1305         return i2c_add_driver(&sitronix_ts_driver);
1306 }
1307
1308 static void __exit sitronix_ts_exit(void)
1309 {
1310 #ifdef SITRONIX_FW_UPGRADE_FEATURE
1311         dev_t dev_id = MKDEV(sitronix_major, 0);
1312 #endif // SITRONIX_FW_UPGRADE_FEATURE
1313         i2c_del_driver(&sitronix_ts_driver);
1314 #ifdef SITRONIX_FW_UPGRADE_FEATURE
1315         cdev_del(&sitronix_cdev);
1316
1317         device_destroy(sitronix_class, dev_id); //delete device node under /dev
1318         class_destroy(sitronix_class); //delete class created by us
1319         unregister_chrdev_region(dev_id, 1);
1320 #endif // SITRONIX_FW_UPGRADE_FEATURE
1321 }
1322
1323 module_init(sitronix_ts_init);
1324 module_exit(sitronix_ts_exit);
1325
1326 MODULE_DESCRIPTION("Sitronix Multi-Touch Driver");
1327 MODULE_LICENSE("GPL");