drivers/input/touchscreen/i30_ts.c

   1 /*
   2  * drivers/input/touchscreen/ft5x0x_ts.c
   3  *
   4  * FocalTech ft5x0x TouchScreen driver.
   5  *
   6  * Copyright (c) 2010  Focal tech Ltd.
   7  *
   8  * This software is licensed under the terms of the GNU General Public
   9  * License version 2, as published by the Free Software Foundation, and
  10  * may be copied, distributed, and modified under those terms.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  *
  18  *      note: only support mulititouch  Wenfs 2010-10-01
  19  */
  20
  21 #include <linux/input.h>
  22 #include <linux/input/mt.h>
  23 #include <linux/module.h>
  24 #include <linux/init.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/kernel.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/spi/spi.h>
  29 #include <linux/slab.h>
  30 #include <linux/fcntl.h>
  31 #include <linux/delay.h>
  32 #include <linux/device.h>
  33 #include <linux/timer.h>
  34 #include <linux/jiffies.h>
  35 #include <linux/miscdevice.h>
  36 #include <linux/types.h>
  37 #include <linux/io.h>
  38 #include <linux/delay.h>
  39 #include <linux/ioport.h>
  40 #include <linux/input-polldev.h>
  41 #include <linux/i2c.h>
  42 #include <linux/workqueue.h>
  43 #ifdef CONFIG_ANDROID_POWER
  44 #include <linux/android_power.h>
  45 #endif
  46 #include <mach/hardware.h>
  47 #include <asm/setup.h>
  48 #include <asm/mach-types.h>
  49 #include <asm/mach/arch.h>
  50 #include <asm/mach/map.h>
  51 #include <asm/mach/flash.h>
  52 #include <asm/hardware/gic.h>
  53 #include <mach/iomux.h>
  54 #include <mach/gpio.h>
  55 #include <mach/irqs.h>
  56 //#include <mach/rk29_iomap.h>
  57 #include <mach/board.h>
  58 //#include <mach/rk29_nand.h>
  59 //#include <mach/rk29_camera.h>                          /* ddl@rock-chips.com : camera support */
  60 #include <media/soc_camera.h>                               /* ddl@rock-chips.com : camera support */
  61 //#include <mach/vpu_mem.h>
  62 #include <mach/sram.h>
  63 #include <linux/earlysuspend.h>
  64 #ifdef CONFIG_RK_CONFIG
  65 #include <mach/config.h>
  66 #include <linux/regulator/rk29-pwm-regulator.h>
  67 #endif
  68 static struct early_suspend ft5306_power;
  69
  70
  71
  72
  73 #define CONFIG_FT5X0X_MULTITOUCH  1
  74 #define MAX_POINT                 5
  75 #define FT5306_IIC_SPEED          50*1000    //300*1000
  76 #define FT5X0X_REG_THRES          0x80         /* Thresshold, the threshold be low, the sensitivy will be high */
  77 #define FT5X0X_REG_REPORT_RATE    0x88         /* **************report rate, in unit of 10Hz **************/
  78 #define FT5X0X_REG_PMODE          0xA5         /* Power Consume Mode 0 -- active, 1 -- monitor, 3 -- sleep */
  79 #define FT5X0X_REG_FIRMID         0xA6         /* ***************firmware version **********************/
  80 #define FT5X0X_REG_NOISE_MODE     0xb2         /* to enable or disable power noise, 1 -- enable, 0 -- disable */
  81 #define SCREEN_MAX_X              800
  82 #define SCREEN_MAX_Y              480
  83 #define PRESS_MAX                 255
  84 #define FT5X0X_NAME                   "ft5x0x_ts"//"synaptics_i2c_rmi"//"synaptics-rmi-ts"//
  85 #define TOUCH_MAJOR_MAX           200
  86 #define WIDTH_MAJOR_MAX           200
  87 //FT5X0X_REG_PMODE
  88 #define PMODE_ACTIVE              0x00
  89 #define PMODE_MONITOR             0x01
  90 #define PMODE_STANDBY             0x02
  91 #define PMODE_HIBERNATE           0x03
  92
  93 #define TP_MODULE_NAME  FT5X0X_NAME
  94 #ifdef CONFIG_RK_CONFIG
  95
  96 enum {
  97 #if defined(RK2928_PHONEPAD_DEFAULT_CONFIG)
  98         DEF_EN = 1,
  99 #else
 100         DEF_EN = 0,
 101 #endif
 102         DEF_IRQ = 0x002003c7,
 103         DEF_RST = 0X000003d5,
 104         DEF_I2C = 2,
 105         DEF_ADDR = 0x38,
 106         DEF_X_MAX = 800,
 107         DEF_Y_MAX = 480,
 108         DEF_TP_LDO = 4,
 109 };
 110 static int en = DEF_EN;
 111 module_param(en, int, 0644);
 112
 113 static int irq = DEF_IRQ;
 114 module_param(irq, int, 0644);
 115 static int rst =DEF_RST;
 116 module_param(rst, int, 0644);
 117
 118 static int i2c = DEF_I2C;            // i2c channel
 119 module_param(i2c, int, 0644);
 120 static int addr = DEF_ADDR;           // i2c addr
 121 module_param(addr, int, 0644);
 122 static int x_max = DEF_X_MAX;
 123 module_param(x_max, int, 0644);
 124 static int y_max = DEF_Y_MAX;
 125 module_param(y_max, int, 0644);
 126 static int tp_ldo = DEF_TP_LDO;
 127 module_param(tp_ldo, int, 0644);
 128
 129 static int tp_hw_init(void)
 130 {
 131         int ret = 0;
 132
 133         pmic_ldo_set(tp_ldo, 0);
 134
 135         ret = gpio_request(get_port_config(irq).gpio, "tp_irq");
 136         if(ret < 0){
 137                 printk("%s: gpio_request(irq gpio) failed\n", __func__);
 138                 return ret;
 139         }
 140
 141         ret = port_output_init(rst, 1, "tp_rst");
 142         if(ret < 0){
 143                 printk("%s: port(rst) output init faild\n", __func__);
 144                 return ret;
 145         }
 146         msleep(50);
 147         pmic_ldo_set(tp_ldo, 1);
 148         msleep(300);
 149
 150          return 0;
 151 }
 152 static int tp_hw_exit(void)
 153 {
 154         return 0;
 155 }
 156 static int tp_hw_suspend(void)
 157 {
 158         port_output_off(rst);
 159         return 0;
 160 }
 161 static int tp_hw_resume(void)
 162 {
 163         port_output_on(rst);
 164         return 0;
 165 }
 166 #include "rk_tp.c"
 167 #endif
 168
 169
 170
 171 struct ts_event {
 172         s16  cur_touch_id[MAX_POINT];
 173     s16  last_touch_id[MAX_POINT];
 174 };
 175
 176 struct tp_event {
 177         u16     x;
 178         u16     y;
 179     s16 id;
 180         u16     pressure;
 181         u8  touch_point;
 182         u8  flag;
 183 };
 184
 185 struct ft5x0x_ts_data {
 186         struct i2c_client *client;
 187         struct input_dev        *input_dev;
 188         int    irq;
 189         struct ts_event         event;
 190         struct work_struct      pen_event_work;
 191         struct workqueue_struct *ts_workqueue;
 192 };
 193 static struct i2c_client *this_client;
 194
 195 /***********************************************************************/
 196
 197 #define    FTS_PACKET_LENGTH        128
 198
 199
 200 static u8 CTPM_FW[]=
 201 {
 202 //#include "ft5406_app.i"
 203 };
 204
 205 typedef enum
 206 {
 207     ERR_OK,
 208     ERR_MODE,
 209     ERR_READID,
 210     ERR_ERASE,
 211     ERR_STATUS,
 212     ERR_ECC,
 213     ERR_DL_ERASE_FAIL,
 214     ERR_DL_PROGRAM_FAIL,
 215     ERR_DL_VERIFY_FAIL
 216 }E_UPGRADE_ERR_TYPE;
 217
 218 /***********************************************************************/
 219
 220 /***********************************************************************
 221     [function]:
 222                            callback:                send data to ctpm by i2c interface;
 223     [parameters]:
 224                             txdata[in]:              data buffer which is used to send data;
 225                             length[in]:              the length of the data buffer;
 226     [return]:
 227                             FTS_TRUE:              success;
 228                             FTS_FALSE:             fail;
 229 ************************************************************************/
 230 static int fts_i2c_txdata(u8 *txdata, int length)
 231 {
 232         int ret;
 233
 234         struct i2c_msg msg;
 235
 236         msg.addr = this_client->addr;
 237         msg.flags = 0;
 238         msg.len = length;
 239         msg.buf = txdata;
 240         msg.scl_rate = FT5306_IIC_SPEED;
 241
 242         ret = i2c_transfer(this_client->adapter, &msg, 1);
 243         if (ret < 0)
 244                 pr_err("%s i2c write error: %d\n", __func__, ret);
 245
 246         return ret;
 247 }
 248
 249 /***********************************************************************
 250     [function]:
 251                            callback:               write data to ctpm by i2c interface;
 252     [parameters]:
 253                             buffer[in]:             data buffer;
 254                             length[in]:            the length of the data buffer;
 255     [return]:
 256                             FTS_TRUE:            success;
 257                             FTS_FALSE:           fail;
 258 ************************************************************************/
 259 static bool  i2c_write_interface(u8* pbt_buf, int dw_lenth)
 260 {
 261     int ret;
 262     ret=i2c_master_send(this_client, pbt_buf, dw_lenth);
 263     if(ret<=0)
 264     {
 265         printk("[TSP]i2c_write_interface error line = %d, ret = %d\n", __LINE__, ret);
 266         return false;
 267     }
 268
 269     return true;
 270 }
 271
 272 /***********************************************************************
 273     [function]:
 274                            callback:                read register value ftom ctpm by i2c interface;
 275     [parameters]:
 276                         reg_name[in]:         the register which you want to write;
 277                             tx_buf[in]:              buffer which is contained of the writing value;
 278     [return]:
 279                             FTS_TRUE:              success;
 280                             FTS_FALSE:             fail;
 281 ************************************************************************/
 282 static bool fts_register_write(u8 reg_name, u8* tx_buf)
 283 {
 284         u8 write_cmd[2] = {0};
 285
 286         write_cmd[0] = reg_name;
 287         write_cmd[1] = *tx_buf;
 288
 289         /*call the write callback function*/
 290         return i2c_write_interface(write_cmd, 2);
 291 }
 292
 293 /***********************************************************************
 294 [function]:
 295                       callback:         send a command to ctpm.
 296 [parameters]:
 297                           btcmd[in]:       command code;
 298                           btPara1[in]:     parameter 1;
 299                           btPara2[in]:     parameter 2;
 300                           btPara3[in]:     parameter 3;
 301                       num[in]:         the valid input parameter numbers,
 302                                            if only command code needed and no
 303                                            parameters followed,then the num is 1;
 304 [return]:
 305                           FTS_TRUE:      success;
 306                           FTS_FALSE:     io fail;
 307 ************************************************************************/
 308 static bool cmd_write(u8 btcmd,u8 btPara1,u8 btPara2,u8 btPara3,u8 num)
 309 {
 310     u8 write_cmd[4] = {0};
 311
 312     write_cmd[0] = btcmd;
 313     write_cmd[1] = btPara1;
 314     write_cmd[2] = btPara2;
 315     write_cmd[3] = btPara3;
 316     return i2c_write_interface(write_cmd, num);
 317 }
 318
 319 /***********************************************************************
 320     [function]:
 321                            callback:              read data from ctpm by i2c interface;
 322     [parameters]:
 323                             buffer[in]:            data buffer;
 324                             length[in]:           the length of the data buffer;
 325     [return]:
 326                             FTS_TRUE:            success;
 327                             FTS_FALSE:           fail;
 328 ************************************************************************/
 329 static bool i2c_read_interface(u8* pbt_buf, int dw_lenth)
 330 {
 331     int ret;
 332
 333     ret=i2c_master_recv(this_client, pbt_buf, dw_lenth);
 334
 335     if(ret<=0)
 336     {
 337         printk("[TSP]i2c_read_interface error\n");
 338         return false;
 339     }
 340
 341     return true;
 342 }
 343
 344
 345 /***********************************************************************
 346 [function]:
 347                       callback:         read a byte data  from ctpm;
 348 [parameters]:
 349                           buffer[in]:       read buffer;
 350                           length[in]:      the size of read data;
 351 [return]:
 352                           FTS_TRUE:      success;
 353                           FTS_FALSE:     io fail;
 354 ************************************************************************/
 355 static bool byte_read(u8* buffer, int length)
 356 {
 357     return i2c_read_interface(buffer, length);
 358 }
 359
 360 /***********************************************************************
 361 [function]:
 362                       callback:         write a byte data  to ctpm;
 363 [parameters]:
 364                           buffer[in]:       write buffer;
 365                           length[in]:      the size of write data;
 366 [return]:
 367                           FTS_TRUE:      success;
 368                           FTS_FALSE:     io fail;
 369 ************************************************************************/
 370 static bool byte_write(u8* buffer, int length)
 371 {
 372
 373     return i2c_write_interface(buffer, length);
 374 }
 375
 376 /***********************************************************************
 377     [function]:
 378                            callback:                 read register value ftom ctpm by i2c interface;
 379     [parameters]:
 380                         reg_name[in]:         the register which you want to read;
 381                             rx_buf[in]:              data buffer which is used to store register value;
 382                             rx_length[in]:          the length of the data buffer;
 383     [return]:
 384                             FTS_TRUE:              success;
 385                             FTS_FALSE:             fail;
 386 ************************************************************************/
 387 static bool fts_register_read(u8 reg_name, u8* rx_buf, int rx_length)
 388 {
 389         u8 read_cmd[2]= {0};
 390         u8 cmd_len      = 0;
 391
 392         read_cmd[0] = reg_name;
 393         cmd_len = 1;
 394
 395         /*send register addr*/
 396         if(!i2c_write_interface(&read_cmd[0], cmd_len))
 397         {
 398                 return false;
 399         }
 400
 401         /*call the read callback function to get the register value*/
 402         if(!i2c_read_interface(rx_buf, rx_length))
 403         {
 404                 return false;
 405         }
 406         return true;
 407 }
 408
 409
 410
 411 /***********************************************************************
 412 [function]:
 413                         callback:          burn the FW to ctpm.
 414 [parameters]:
 415                             pbt_buf[in]:     point to Head+FW ;
 416                             dw_lenth[in]:   the length of the FW + 6(the Head length);
 417 [return]:
 418                             ERR_OK:          no error;
 419                             ERR_MODE:      fail to switch to UPDATE mode;
 420                             ERR_READID:   read id fail;
 421                             ERR_ERASE:     erase chip fail;
 422                             ERR_STATUS:   status error;
 423                             ERR_ECC:        ecc error.
 424 ************************************************************************/
 425 E_UPGRADE_ERR_TYPE  fts_ctpm_fw_upgrade(u8* pbt_buf, int dw_lenth)
 426 {
 427     u8  cmd,reg_val[2] = {0};
 428         u8  buffer[2] = {0};
 429     u8  packet_buf[FTS_PACKET_LENGTH + 6];
 430     u8  auc_i2c_write_buf[10];
 431     u8  bt_ecc;
 432
 433     int  j,temp,lenght,i_ret,packet_number, i = 0;
 434     int  i_is_new_protocol = 0;
 435
 436
 437     /******write 0xaa to register 0xfc******/
 438     cmd=0xaa;
 439     fts_register_write(0xfc,&cmd);
 440     mdelay(50);
 441
 442      /******write 0x55 to register 0xfc******/
 443     cmd=0x55;
 444     fts_register_write(0xfc,&cmd);
 445     printk("[TSP] Step 1: Reset CTPM test\n");
 446
 447     mdelay(10);
 448
 449
 450     /*******Step 2:Enter upgrade mode ****/
 451     printk("\n[TSP] Step 2:enter new update mode\n");
 452     auc_i2c_write_buf[0] = 0x55;
 453     auc_i2c_write_buf[1] = 0xaa;
 454     do
 455     {
 456         i ++;
 457         i_ret = fts_i2c_txdata(auc_i2c_write_buf, 2);
 458         mdelay(5);
 459     }while(i_ret <= 0 && i < 10 );
 460
 461     if (i > 1)
 462     {
 463         i_is_new_protocol = 1;
 464     }
 465
 466     /********Step 3:check READ-ID********/
 467     cmd_write(0x90,0x00,0x00,0x00,4);
 468     byte_read(reg_val,2);
 469     if (reg_val[0] == 0x79 && reg_val[1] == 0x3)
 470     {
 471         printk("[TSP] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
 472     }
 473     else
 474     {
 475         printk("[TSP] Step 3: error CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
 476         return ERR_READID;
 477         //i_is_new_protocol = 1;
 478     }
 479
 480
 481      /*********Step 4:erase app**********/
 482     if (i_is_new_protocol)
 483     {
 484         cmd_write(0x61,0x00,0x00,0x00,1);
 485     }
 486     else
 487     {
 488         cmd_write(0x60,0x00,0x00,0x00,1);
 489     }
 490     mdelay(1500);
 491     printk("[TSP] Step 4: erase. \n");
 492
 493
 494
 495     /*Step 5:write firmware(FW) to ctpm flash*/
 496     bt_ecc = 0;
 497     printk("[TSP] Step 5: start upgrade. \n");
 498     dw_lenth = dw_lenth - 8;
 499     packet_number = (dw_lenth) / FTS_PACKET_LENGTH;
 500     packet_buf[0] = 0xbf;
 501     packet_buf[1] = 0x00;
 502     for (j=0;j<packet_number;j++)
 503     {
 504         temp = j * FTS_PACKET_LENGTH;
 505         packet_buf[2] = (u8)(temp>>8);
 506         packet_buf[3] = (u8)temp;
 507         lenght = FTS_PACKET_LENGTH;
 508         packet_buf[4] = (u8)(lenght>>8);
 509         packet_buf[5] = (u8)lenght;
 510
 511         for (i=0;i<FTS_PACKET_LENGTH;i++)
 512         {
 513             packet_buf[6+i] = pbt_buf[j*FTS_PACKET_LENGTH + i];
 514             bt_ecc ^= packet_buf[6+i];
 515         }
 516
 517         byte_write(&packet_buf[0],FTS_PACKET_LENGTH + 6);
 518         mdelay(FTS_PACKET_LENGTH/6 + 1);
 519         if ((j * FTS_PACKET_LENGTH % 1024) == 0)
 520         {
 521               printk("[TSP] upgrade the 0x%x th byte.\n", ((unsigned int)j) * FTS_PACKET_LENGTH);
 522         }
 523     }
 524
 525     if ((dw_lenth) % FTS_PACKET_LENGTH > 0)
 526     {
 527         temp = packet_number * FTS_PACKET_LENGTH;
 528         packet_buf[2] = (u8)(temp>>8);
 529         packet_buf[3] = (u8)temp;
 530
 531         temp = (dw_lenth) % FTS_PACKET_LENGTH;
 532         packet_buf[4] = (u8)(temp>>8);
 533         packet_buf[5] = (u8)temp;
 534
 535         for (i=0;i<temp;i++)
 536         {
 537             packet_buf[6+i] = pbt_buf[ packet_number*FTS_PACKET_LENGTH + i];
 538             bt_ecc ^= packet_buf[6+i];
 539         }
 540
 541         byte_write(&packet_buf[0],temp+6);
 542         mdelay(20);
 543     }
 544
 545     /***********send the last six byte**********/
 546     for (i = 0; i<6; i++)
 547     {
 548         temp = 0x6ffa + i;
 549         packet_buf[2] = (u8)(temp>>8);
 550         packet_buf[3] = (u8)temp;
 551         temp =1;
 552         packet_buf[4] = (u8)(temp>>8);
 553         packet_buf[5] = (u8)temp;
 554         packet_buf[6] = pbt_buf[ dw_lenth + i];
 555         bt_ecc ^= packet_buf[6];
 556
 557         byte_write(&packet_buf[0],7);
 558         mdelay(20);
 559     }
 560
 561     /********send the opration head************/
 562     cmd_write(0xcc,0x00,0x00,0x00,1);
 563     byte_read(reg_val,1);
 564     printk("[TSP] Step 6:  ecc read 0x%x, new firmware 0x%x. \n", reg_val[0], bt_ecc);
 565     if(reg_val[0] != bt_ecc)
 566     {
 567         return ERR_ECC;
 568     }
 569
 570     /*******Step 7: reset the new FW**********/
 571     cmd_write(0x07,0x00,0x00,0x00,1);
 572         mdelay(100);//100ms
 573         fts_register_read(0xfc, buffer, 1);
 574         if (buffer[0] == 1)
 575         {
 576         cmd=4;
 577         fts_register_write(0xfc, &cmd);
 578         mdelay(2500);//2500ms
 579          do
 580          {
 581          fts_register_read(0xfc, buffer, 1);
 582          mdelay(100);//100ms
 583          }while (buffer[0] != 1);
 584         }
 585     return ERR_OK;
 586 }
 587
 588
 589 /***********************************************************************/
 590
 591 int fts_ctpm_fw_upgrade_with_i_file(void)
 592 {
 593    u8*     pbt_buf = 0;
 594    int i_ret;
 595
 596    pbt_buf = CTPM_FW;
 597    i_ret =  fts_ctpm_fw_upgrade(pbt_buf,sizeof(CTPM_FW));
 598
 599    return i_ret;
 600 }
 601
 602 /***********************************************************************/
 603
 604 unsigned char fts_ctpm_get_upg_ver(void)
 605 {
 606     unsigned int ui_sz;
 607
 608     ui_sz = sizeof(CTPM_FW);
 609     if (ui_sz > 2)
 610     {
 611         return CTPM_FW[ui_sz - 2];
 612     }
 613     else
 614         return 0xff;
 615
 616 }
 617
 618 static int ft5306_init_touchid(s16 touch_buf[], unsigned len,s16 init_val)
 619 {
 620         int i;
 621         for(i=0;i<len;i++){
 622                 touch_buf[i] = init_val;
 623         }
 624         return 0;
 625 }
 626
 627 /*read the it7260 register ,used i2c bus*/
 628 static int ft5306_read_regs(struct i2c_client *client, u8 reg, u8 buf[], unsigned len)
 629 {
 630         int ret;
 631         ret = i2c_master_reg8_recv(client, reg, buf, len, FT5306_IIC_SPEED);
 632         return ret;
 633 }
 634
 635
 636 /* set the it7260 registe,used i2c bus*/
 637 static int ft5306_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], unsigned short len)
 638 {
 639         int ret;
 640         ret = i2c_master_reg8_send(client, reg, buf, (int)len, FT5306_IIC_SPEED);
 641         return ret;
 642 }
 643
 644 static void ft5306_queue_work(struct work_struct *work)
 645 {
 646         struct ft5x0x_ts_data *data = container_of(work, struct ft5x0x_ts_data, pen_event_work);
 647         struct tp_event event;
 648         u8 start_reg=0x0;
 649         u8 buf[32] = {0};
 650         int ret,i,offset,points;
 651
 652 #if CONFIG_FT5X0X_MULTITOUCH
 653         ret = ft5306_read_regs(data->client,start_reg, buf, 6*MAX_POINT+1);
 654 #else
 655         ret = ft5306_read_regs(data->client,start_reg, buf, 7);
 656 #endif
 657         if (ret < 0) {
 658                 dev_err(&data->client->dev, "ft5306_read_regs fail:%d!\n",ret);
 659                 enable_irq(data->irq);
 660                 return;
 661         }
 662
 663         points = buf[2] & 0x07;
 664         memset(&event, 0, sizeof(struct tp_event));
 665 #if CONFIG_FT5X0X_MULTITOUCH
 666         ft5306_init_touchid(data->event.cur_touch_id,MAX_POINT,-1);
 667 //      dev_info(&data->client->dev,
 668 //              "ft5306 multiple report points = %d :\n",points);
 669         for(i=0;i<points;i++){
 670                 offset = i*6+3;
 671                 event.x = (((s16)(buf[offset+0] & 0x0F))<<8) | ((s16)buf[offset+1]);
 672                 event.y = (((s16)(buf[offset+2] & 0x0F))<<8) | ((s16)buf[offset+3]);
 673                 event.id = (s16)(buf[offset+2] & 0xF0)>>4;
 674                 event.flag = ((buf[offset+0] & 0xc0) >> 6);
 675                 event.pressure = 200;
 676                 if(event.x<=SCREEN_MAX_X && event.y<=SCREEN_MAX_Y && event.id < MAX_POINT){
 677 //                      dev_info(&data->client->dev,
 678 //                              "ft5306 multiple report event[%d]:x = %d,y = %d,last_id = %d,cur_id = %d,flag = %d,pressure = %d\n",
 679 //                              i,event.x,event.y,data->event.last_touch_id[event.id],event.id,event.flag,event.pressure);
 680                         input_mt_slot(data->input_dev, event.id);
 681                         data->event.cur_touch_id[event.id] = event.id;
 682                         if(data->event.last_touch_id[event.id] != event.id){
 683                                 input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event.id);
 684                                 data->event.last_touch_id[event.id] = event.id;
 685                         }
 686                         input_report_abs(data->input_dev, ABS_MT_POSITION_X,  event.x);
 687                         input_report_abs(data->input_dev, ABS_MT_POSITION_Y,  event.y);
 688 //                      dev_info(&data->client->dev,"new last_id=%d,cur_id = %d\n",data->event.last_touch_id[event.id],
 689 //                              data->event.cur_touch_id[event.id]);
 690                 }
 691         }
 692         for(i=0;i<MAX_POINT;i++){
 693                 if(data->event.last_touch_id[i] != data->event.cur_touch_id[i]){
 694 //                      dev_info(&data->client->dev,"release id=%d: last_id=%d,cur_id = %d\n",i,data->event.last_touch_id[i],
 695 //                              data->event.cur_touch_id[i]);
 696                         data->event.last_touch_id[i] = data->event.cur_touch_id[i];
 697                         input_mt_slot(data->input_dev, i);
 698                         input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, data->event.cur_touch_id[i]);
 699                 }
 700         }
 701 #else
 702         if (points == 0) {
 703                 input_report_abs(data->input_dev, ABS_PRESSURE, 0);
 704                 input_report_key(data->input_dev, BTN_TOUCH, 0);
 705                 input_sync(data->input_dev);
 706                 enable_irq(data->irq);
 707 //              dev_info(&data->client->dev, "ft5306 touch release\n");
 708                 return;
 709         }
 710         event.x = (s16)(buf[3] & 0x0F)<<8 | (s16)buf[4];
 711         event.y = (s16)(buf[5] & 0x0F)<<8 | (s16)buf[6];
 712         event.pressure =200;
 713         input_report_abs(data->input_dev, ABS_X, event.x);
 714         input_report_abs(data->input_dev, ABS_Y, event.y);
 715         input_report_abs(data->input_dev, ABS_PRESSURE, event.pressure);
 716         input_report_key(data->input_dev, BTN_TOUCH, 1);
 717         //dev_info(&data->client->dev, "ft5306 single report event:x = %d,y = %d\n",event.x,event.y);
 718 #endif
 719         input_sync(data->input_dev);
 720         enable_irq(data->irq);
 721         return;
 722 }
 723
 724 static irqreturn_t ft5306_interrupt(int irq, void *dev_id)
 725 {
 726         struct ft5x0x_ts_data *ft5x0x_ts = dev_id;
 727
 728         //printk("ft5306_interrupt\n");
 729         disable_irq_nosync(ft5x0x_ts->irq);
 730         if (!work_pending(&ft5x0x_ts->pen_event_work))
 731                 queue_work(ft5x0x_ts->ts_workqueue, &ft5x0x_ts->pen_event_work);
 732         return IRQ_HANDLED;
 733 }
 734
 735 static int ft5306_suspend(struct i2c_client *client, pm_message_t mesg)
 736 {
 737         struct ft5x0x_ts_data *ft5x0x_ts = i2c_get_clientdata(client);
 738         struct ft5306_platform_data *pdata = client->dev.platform_data;
 739
 740 #ifdef CONFIG_RK_CONFIG
 741         tp_hw_suspend();
 742 #else
 743         if (pdata->platform_sleep)
 744                 pdata->platform_sleep();
 745 #endif
 746         disable_irq(ft5x0x_ts->irq);
 747         return 0;
 748 }
 749
 750
 751 static int ft5306_resume(struct i2c_client *client)
 752 {
 753         struct ft5x0x_ts_data *ft5x0x_ts = i2c_get_clientdata(client);
 754         struct ft5306_platform_data *pdata = client->dev.platform_data;
 755
 756         enable_irq(ft5x0x_ts->irq);
 757 #ifdef CONFIG_RK_CONFIG
 758         tp_hw_resume();
 759 #else
 760         if (pdata->platform_wakeup)
 761                 pdata->platform_wakeup();
 762 #endif
 763         return 0;
 764 }
 765
 766 static void ft5306_suspend_early(struct early_suspend *h)
 767 {
 768         ft5306_suspend(this_client,PMSG_SUSPEND);
 769 }
 770
 771 static void ft5306_resume_early(struct early_suspend *h)
 772 {
 773         ft5306_resume(this_client);
 774 }
 775 static int __devexit ft5306_remove(struct i2c_client *client)
 776 {
 777         struct ft5x0x_ts_data *ft5x0x_ts = i2c_get_clientdata(client);
 778
 779         free_irq(ft5x0x_ts->irq, ft5x0x_ts);
 780         input_unregister_device(ft5x0x_ts->input_dev);
 781         kfree(ft5x0x_ts);
 782         cancel_work_sync(&ft5x0x_ts->pen_event_work);
 783         destroy_workqueue(ft5x0x_ts->ts_workqueue);
 784         i2c_set_clientdata(client, NULL);
 785     unregister_early_suspend(&ft5306_power);
 786     this_client = NULL;
 787         return 0;
 788 }
 789
 790 static int  ft5306_probe(struct i2c_client *client ,const struct i2c_device_id *id)
 791 {
 792         struct ft5x0x_ts_data *ft5x0x_ts;
 793         struct input_dev *input_dev;
 794         struct ft5306_platform_data *pdata = client->dev.platform_data;
 795         int err = 0;
 796         int ret = 0;
 797         int retry = 0;
 798         u8 buf_w[1];
 799         u8 buf_r[1];
 800         const u8 buf_test[1] = {0};
 801     unsigned char reg_value;
 802     unsigned char reg_version;
 803
 804 #ifdef CONFIG_RK_CONFIG
 805          struct port_config irq_cfg = get_port_config(irq);
 806         tp_hw_init();
 807 #else
 808         dev_info(&client->dev, "ft5x0x_ts_probe!\n");
 809         if (!pdata) {
 810                 dev_err(&client->dev, "platform data is required!\n");
 811                 return -EINVAL;
 812         }
 813         if (pdata->init_platform_hw)
 814                 pdata->init_platform_hw();
 815 #endif
 816         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)){
 817                 dev_err(&client->dev, "Must have I2C_FUNC_I2C.\n");
 818                 return -ENODEV;
 819         }
 820
 821         ft5x0x_ts = kzalloc(sizeof(*ft5x0x_ts), GFP_KERNEL);
 822         if (!ft5x0x_ts) {
 823                 return -ENOMEM;
 824         }
 825
 826         while(retry < 5)
 827         {
 828                 ret=ft5306_set_regs(client,FT5X0X_REG_PMODE, buf_test,1);
 829                 if(ret > 0)break;
 830                 retry++;
 831         }
 832         if(ret <= 0)
 833         {
 834                 printk("FT5306 I2C TEST ERROR!\n");
 835                 err = -ENODEV;
 836                 goto exit_i2c_test_fail;
 837         }
 838         buf_r[0] = 0xff;
 839         err = ft5306_read_regs(client,FT5X0X_REG_PMODE,buf_r,1);
 840         printk("read buf[FT5X0X_REG_PMODE] = %d\n", buf_r[0]);
 841
 842
 843         input_dev = input_allocate_device();
 844         if (!input_dev) {
 845                 err = -ENOMEM;
 846                 printk("failed to allocate input device\n");
 847                 goto exit_input_dev_alloc_failed;
 848         }
 849         ft5x0x_ts->client = this_client = client;
 850 #ifdef CONFIG_RK_CONFIG
 851         ft5x0x_ts->irq = get_port_config(irq).gpio;
 852 #else
 853         ft5x0x_ts->irq = pdata->irq_pin;
 854 #endif
 855         ft5x0x_ts->input_dev = input_dev;
 856
 857         set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
 858         set_bit(EV_ABS, input_dev->evbit);
 859
 860 #if CONFIG_FT5X0X_MULTITOUCH
 861         ft5306_init_touchid(ft5x0x_ts->event.cur_touch_id,MAX_POINT,-1);
 862         ft5306_init_touchid(ft5x0x_ts->event.last_touch_id,MAX_POINT,-1);
 863         input_mt_init_slots(input_dev, MAX_POINT);
 864 #ifdef CONFIG_RK_CONFIG
 865         input_set_abs_params(input_dev,ABS_MT_POSITION_X, 0, x_max, 0, 0);
 866         input_set_abs_params(input_dev,ABS_MT_POSITION_Y, 0, y_max, 0, 0);
 867 #else
 868         input_set_abs_params(input_dev,ABS_MT_POSITION_X, 0, SCREEN_MAX_X, 0, 0);
 869         input_set_abs_params(input_dev,ABS_MT_POSITION_Y, 0, SCREEN_MAX_Y, 0, 0);
 870 #endif
 871 #else
 872         set_bit(ABS_X, input_dev->absbit);
 873         set_bit(ABS_Y, input_dev->absbit);
 874         set_bit(ABS_PRESSURE, input_dev->absbit);
 875         set_bit(BTN_TOUCH, input_dev->keybit);
 876 #ifdef CONFIG_RK_CONFIG
 877         input_set_abs_params(input_dev, ABS_X, 0, x_max, 0, 0);
 878         input_set_abs_params(input_dev, ABS_Y, 0, y_max, 0, 0);
 879 #else
 880         input_set_abs_params(input_dev, ABS_X, 0, SCREEN_MAX_X, 0, 0);
 881         input_set_abs_params(input_dev, ABS_Y, 0, SCREEN_MAX_Y, 0, 0);
 882 #endif
 883         input_set_abs_params(input_dev, ABS_PRESSURE, 0, PRESS_MAX, 0 , 0);
 884 #endif
 885
 886         input_dev->name         = FT5X0X_NAME;
 887         input_dev->id.bustype = BUS_I2C;
 888
 889         err = input_register_device(input_dev);
 890         if (err) {
 891                 printk("ft5x0x_ts_probe: failed to register input device: \n");
 892                 goto exit_input_register_device_failed;
 893         }
 894
 895         if (!ft5x0x_ts->irq) {
 896                 err = -ENODEV;
 897                 dev_err(&ft5x0x_ts->client->dev, "no IRQ?\n");
 898                 goto exit_no_irq_fail;
 899         }else{
 900                 ft5x0x_ts->irq = gpio_to_irq(ft5x0x_ts->irq);
 901         }
 902
 903         //INIT_WORK(&ft5x0x_ts->pen_event_work, ft5306_ts_pen_irq_work);
 904         INIT_WORK(&ft5x0x_ts->pen_event_work, ft5306_queue_work);
 905         ft5x0x_ts->ts_workqueue = create_singlethread_workqueue("ft5x0x_ts");
 906         if (!ft5x0x_ts->ts_workqueue) {
 907                 err = -ESRCH;
 908                 goto exit_create_singlethread;
 909         }
 910
 911         /***wait CTP to bootup normally***/
 912          msleep(200);
 913
 914          fts_register_read(FT5X0X_REG_FIRMID, &reg_version,1);
 915          printk("[TSP] firmware version = 0x%2x\n", reg_version);
 916          fts_register_read(FT5X0X_REG_REPORT_RATE, &reg_value,1);
 917          printk("[TSP]firmware report rate = %dHz\n", reg_value*10);
 918          fts_register_read(FT5X0X_REG_THRES, &reg_value,1);
 919          printk("[TSP]firmware threshold = %d\n", reg_value * 4);
 920          fts_register_read(FT5X0X_REG_NOISE_MODE, &reg_value,1);
 921          printk("[TSP]nosie mode = 0x%2x\n", reg_value);
 922
 923 #if 0
 924           if (fts_ctpm_get_upg_ver() != reg_version)
 925           {
 926                   printk("[TSP] start upgrade new verison 0x%2x\n", fts_ctpm_get_upg_ver());
 927                   msleep(200);
 928                   err =  fts_ctpm_fw_upgrade_with_i_file();
 929                   if (err == 0)
 930                   {
 931                           printk("[TSP] ugrade successfuly.\n");
 932                           msleep(300);
 933                           fts_register_read(FT5X0X_REG_FIRMID, &reg_value,1);
 934                           printk("FTS_DBG from old version 0x%2x to new version = 0x%2x\n", reg_version, reg_value);
 935                   }
 936                   else
 937                   {
 938                           printk("[TSP]  ugrade fail err=%d, line = %d.\n",err, __LINE__);
 939                   }
 940                   msleep(4000);
 941           }
 942 #endif
 943
 944         //printk("client->dev.driver->name %s  ,%d \n",client->dev.driver->name,ft5x0x_ts->irq);
 945 #ifdef CONFIG_RK_CONFIG
 946         ret = request_irq(ft5x0x_ts->irq, ft5306_interrupt, irq_cfg.irq.irq_flags, client->dev.driver->name, ft5x0x_ts);
 947 #else
 948         ret = request_irq(ft5x0x_ts->irq, ft5306_interrupt, IRQF_TRIGGER_FALLING, client->dev.driver->name, ft5x0x_ts);
 949 #endif
 950         if (ret < 0) {
 951                 dev_err(&client->dev, "irq %d busy?\n", ft5x0x_ts->irq);
 952                 goto exit_irq_request_fail;
 953         }
 954
 955         i2c_set_clientdata(client, ft5x0x_ts);
 956         ft5306_power.suspend =ft5306_suspend_early;
 957         ft5306_power.resume =ft5306_resume_early;
 958         ft5306_power.level = 0x2;
 959         register_early_suspend(&ft5306_power);
 960
 961         buf_w[0] = 6;
 962         err = ft5306_set_regs(client,0x88,buf_w,1);
 963         buf_r[0] = 0;
 964         err = ft5306_read_regs(client,0x88,buf_r,1);
 965         printk("read buf[0x88] = %d\n", buf_r[0]);
 966     return 0;
 967
 968         i2c_set_clientdata(client, NULL);
 969         free_irq(ft5x0x_ts->irq,ft5x0x_ts);
 970 exit_irq_request_fail:
 971         cancel_work_sync(&ft5x0x_ts->pen_event_work);
 972         destroy_workqueue(ft5x0x_ts->ts_workqueue);
 973 exit_create_singlethread:
 974 exit_no_irq_fail:
 975         input_unregister_device(input_dev);
 976 exit_input_register_device_failed:
 977         input_free_device(input_dev);
 978 exit_input_dev_alloc_failed:
 979 exit_i2c_test_fail:
 980 #ifdef CONFIG_RK_CONFIG
 981         tp_hw_exit();
 982 #else
 983         if (pdata->exit_platform_hw)
 984                 pdata->exit_platform_hw();
 985 #endif
 986         kfree(ft5x0x_ts);
 987         return err;
 988 }
 989
 990
 991
 992 static struct i2c_device_id ft5306_idtable[] = {
 993         { FT5X0X_NAME, 0 },
 994         { }
 995 };
 996
 997 MODULE_DEVICE_TABLE(i2c, ft5306_idtable);
 998
 999 static struct i2c_driver ft5306_driver  = {
1000         .driver = {
1001                 .owner  = THIS_MODULE,
1002                 .name   = FT5X0X_NAME
1003         },
1004         .id_table       = ft5306_idtable,
1005         .probe      = ft5306_probe,
1006         .remove         = __devexit_p(ft5306_remove),
1007 };
1008
1009 static int __init ft5306_ts_init(void)
1010 {
1011
1012 #ifdef CONFIG_RK_CONFIG
1013         int ret = tp_board_init();
1014
1015         if(ret < 0)
1016                 return ret;
1017 #endif
1018         return i2c_add_driver(&ft5306_driver);
1019 }
1020
1021 static void __exit ft5306_ts_exit(void)
1022 {
1023         printk("Touchscreen driver of ft5306 exited.\n");
1024         i2c_del_driver(&ft5306_driver);
1025 }
1026
1027
1028 /***********************************************************************/
1029
1030 module_init(ft5306_ts_init);
1031 module_exit(ft5306_ts_exit);
1032
1033 MODULE_AUTHOR("<wenfs@Focaltech-systems.com>");
1034 MODULE_DESCRIPTION("FocalTech ft5x0x TouchScreen driver");
1035