drivers/input/touchscreen/ft5406_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/module.h>
  23 #include <linux/init.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/kernel.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/spi/spi.h>
  28 #include <linux/slab.h>
  29 #include <linux/fcntl.h>
  30 #include <linux/delay.h>
  31 #include <linux/device.h>
  32 #include <linux/timer.h>
  33 #include <linux/jiffies.h>
  34 #include <linux/miscdevice.h>
  35 #include <linux/types.h>
  36 #include <linux/io.h>
  37 #include <linux/delay.h>
  38 //#include <arch/api_intc.h>
  39 //#include <arch/typedef.h>
  40 //#include <arch/gpio.h>
  41 //#include <arch/api_intc.h>
  42 //#include <arch/hw_define.h>
  43 //#include <arch/hardware.h>
  44 //#include <arch/gpio.h>
  45 //#include <arch/iomux.h>
  46 //#include <asm-arm/uaccess.h>
  47 #include <linux/ioport.h>
  48 #include <linux/input-polldev.h>
  49 #include <linux/i2c.h>
  50 #include <linux/workqueue.h>
  51 #ifdef CONFIG_ANDROID_POWER
  52 #include <linux/android_power.h>
  53 #endif
  54
  55
  56 #include <mach/hardware.h>
  57 #include <asm/setup.h>
  58 #include <asm/mach-types.h>
  59 #include <asm/mach/arch.h>
  60 #include <asm/mach/map.h>
  61 #include <asm/mach/flash.h>
  62 #include <asm/hardware/gic.h>
  63
  64 #include <mach/iomux.h>
  65 #include <mach/gpio.h>
  66 #include <mach/irqs.h>
  67 #include <mach/rk29_iomap.h>
  68 #include <mach/board.h>
  69 #include <mach/rk29_nand.h>
  70 #include <mach/rk29_camera.h>                          /* ddl@rock-chips.com : camera support */
  71 #include <media/soc_camera.h>                               /* ddl@rock-chips.com : camera support */
  72 #include <mach/vpu_mem.h>
  73 #include <mach/sram.h>
  74
  75 #ifdef CONFIG_HAS_EARLYSUSPEND
  76 #include <linux/earlysuspend.h>
  77 #endif
  78
  79 //#include <asm/arch/api_i2c.h>
  80 #include "ft5406_ts.h"
  81
  82
  83 #ifdef CONFIG_HAS_EARLYSUSPEND
  84 static struct early_suspend ft5406_early_suspend;
  85 #endif
  86
  87 static struct i2c_client *this_client;
  88
  89
  90
  91 #define CONFIG_FT5X0X_MULTITOUCH  1
  92
  93 #define CONFIG_TOUCH_PANEL_KEY     1 //harry 2011.03.15
  94
  95 #define  M8_TP_KEY                0            // 1
  96
  97
  98 #if  0// M8_TP_KEY
  99 #define HOME_KEY_MIN    260
 100 #define HOME_KEY_MAX    330
 101
 102 #define MENU_KEY_MIN    380
 103 #define MENU_KEY_MAX    460
 104
 105 #define BACK_KEY_MIN    130
 106 #define BACK_KEY_MAX    210
 107
 108 #else
 109 #define HOME_KEY_MIN    115
 110 #define HOME_KEY_MAX    185
 111
 112 #define MENU_KEY_MIN    215
 113 #define MENU_KEY_MAX    295
 114
 115 #define BACK_KEY_MIN    10
 116 #define BACK_KEY_MAX    85
 117
 118
 119 #endif
 120 #define CONFIG_TOUCH_PANEL_LED     1
 121  #if CONFIG_TOUCH_PANEL_LED
 122 #define RK29SDK_PANEL_LED_GPIO_SITCH   RK29_PIN6_PB4
 123  #endif
 124
 125 #define TOUCH_RESET_PIN RK29_PIN6_PC3
 126
 127 struct ts_event {
 128         u16     x1;
 129         u16     y1;
 130         u16     x2;
 131         u16     y2;
 132         u16     x3;
 133         u16     y3;
 134         u16     x4;
 135         u16     y4;
 136         u16     x5;
 137         u16     y5;
 138         u16     pressure;
 139        s16  touch_ID1;
 140         s16  touch_ID2;
 141        s16  touch_ID3;
 142        s16  touch_ID4;
 143         s16  touch_ID5;
 144         u8   touch_point;
 145         u8   status;
 146 };
 147
 148 struct ft5x0x_ts_data {
 149         struct i2c_client *client;
 150         struct input_dev        *input_dev;
 151         int             irq;
 152         struct ts_event         event;
 153         struct work_struct      pen_event_work;
 154         struct workqueue_struct *ts_workqueue;
 155 };
 156
 157
 158 //#define FT5X0X_I2C_ADDR       0x70
 159 #define MAX_POINT 5
 160 /*
 161 static int ft5x0x_ts_probe(struct i2c_adapter *bus, int address, int kind);
 162 static unsigned short ft5x0x_normal_i2c[] = {FT5X0X_I2C_ADDR>>1, I2C_CLIENT_END};
 163 static unsigned short ft5x0x_ignore = I2C_CLIENT_END;
 164 static struct i2c_client_address_data ft5x0x_addr_data={
 165         .normal_i2c = ft5x0x_normal_i2c,
 166         .probe = &ft5x0x_ignore,
 167         .ignore =&ft5x0x_ignore,
 168 };
 169
 170 static int ft5x0x_attach_adapter(struct i2c_adapter *adap)
 171 {
 172         return i2c_probe(adap, &ft5x0x_addr_data, ft5x0x_ts_probe);
 173 }
 174
 175 static struct i2c_driver ft5x0x_ts_driver = {
 176         .driver = {
 177                 .name   = FT5X0X_NAME,
 178                 .owner  = THIS_MODULE,
 179         },
 180         .id = FT5X0X_I2C_ADDR,
 181         .attach_adapter = &ft5x0x_attach_adapter,
 182 };
 183
 184
 185
 186 static struct  i2c_client ft5x0x_client = {
 187         .driver = &ft5x0x_ts_driver,
 188         .name   = "ft5x0x",
 189 };
 190 */
 191 /*read the it7260 register ,used i2c bus*/
 192
 193 #define FT5406_IIC_SPEED   200*1000    //300*1000
 194 static int ft5406_read_regs(struct i2c_client *client, u8 reg, u8 buf[], unsigned len)
 195 {
 196         int ret;
 197         ret = i2c_master_reg8_recv(client, reg, buf, len, FT5406_IIC_SPEED);
 198         return ret;
 199 }
 200
 201
 202 /* set the it7260 registe,used i2c bus*/
 203 static int ft5406_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], unsigned short len)
 204 {
 205         int ret;
 206         ret = i2c_master_reg8_send(client, reg, buf, (int)len, FT5406_IIC_SPEED);
 207         return ret;
 208 }
 209
 210
 211
 212
 213 /*
 214 static int ft5x0x_i2c_rxdata(u8 reg, u8 rxdata[], int length)
 215 {
 216         int ret;
 217         struct i2c_msg msg[1];
 218
 219     msg->addr = ft5x0x_client.addr;
 220     msg->flags |= I2C_M_RD;
 221     msg->buf = rxdata;
 222     msg->len = length;
 223
 224         //printk("ft50x0_client.addr = 0x%x\n", ft5x0x_client.addr);
 225         rxdata[0] = reg;
 226
 227         ret = i2c_transfer(ft5x0x_client.adapter, msg, 1);
 228         if (ret< 0)
 229         {
 230                 printk("error at ft5x0x_read_regs !!! \n");
 231         }
 232         return ret;
 233
 234 }
 235
 236 static int ft5x0x_i2c_txdata(u8 reg, u8 txdata[], int length)
 237 {
 238         int ret;
 239         struct i2c_msg msg[1];
 240         static u8 i2c_buf[128];
 241
 242     msg->addr = ft5x0x_client.addr;
 243     msg->flags = 0;
 244     msg->buf = i2c_buf;
 245     msg->len = length + 1;
 246
 247
 248         i2c_buf[0] = reg;
 249         memcpy(&i2c_buf[1], &txdata[0], length);
 250         ret = i2c_transfer(ft5x0x_client.adapter, msg, 1);
 251         if (ret< 0)
 252         {
 253                 printk("error at gt800_write_regs !!! \n");
 254         }
 255         return ret;
 256
 257 }
 258
 259 */
 260 static void ft5x0x_ts_release(struct ft5x0x_ts_data *data)
 261 {
 262         //struct ft5x0x_ts_data *data = i2c_get_clientdata(&ft5x0x_client);
 263         //struct ts_event *event = &data->event;
 264
 265 #if   CONFIG_FT5X0X_MULTITOUCH         //  #ifdef
 266         input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, 0);
 267         input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 0);
 268 #else
 269         input_report_abs(data->input_dev, ABS_PRESSURE, 0);
 270         input_report_key(data->input_dev, BTN_TOUCH, 0);
 271 #endif
 272         input_sync(data->input_dev);
 273 }
 274
 275 static int ft5x0x_read_data(struct ft5x0x_ts_data *data )
 276 {
 277         //struct ft5x0x_ts_data *data = i2c_get_clientdata(&ft5x0x_client);
 278         struct ts_event *event = &data->event;
 279         u8 start_reg=0x0;
 280         u8 buf[32] = {0};
 281         int ret = -1;
 282         //int i = 0;
 283         int status = 0;
 284         int cnt = 0;
 285
 286 #if 0
 287         start_reg = 0xa6;
 288         ret = ft5x0x_i2c_rxdata(start_reg, buf, 2);
 289     if (ret < 0) {
 290                 printk("%s read_data i2c_rxdata failed: %d\n", __func__, ret);
 291                 return ret;
 292         }
 293         for (i=0; i<2; i++) {
 294                 printk("=========buf[%d] = 0x%x \n", i, buf[i]);
 295         }
 296 #endif
 297
 298
 299         start_reg = 0;
 300
 301
 302
 303 #if CONFIG_FT5X0X_MULTITOUCH              //   #ifdef
 304         if (MAX_POINT == 5) {
 305                 ret = ft5406_read_regs(data->client,start_reg, buf, 31);
 306         } else {
 307                 ret = ft5406_read_regs(data->client,start_reg, buf, 13);
 308         }
 309 #else
 310     ret = ft5406_read_regs(data->client,start_reg, buf, 7);
 311 #endif
 312     if (ret < 0) {
 313         //      printk("%s read_data i2c_rxdata failed: %d\n", __func__, ret);
 314                 return ret;
 315         }
 316 #if 0
 317         for (i=0; i<32; i++) {
 318                 printk("buf[%d] = 0x%x \n", i, buf[i]);
 319         }
 320 #endif
 321
 322         memset(event, 0, sizeof(struct ts_event));
 323
 324         if (MAX_POINT == 5) {
 325                 event->touch_point = buf[2] & 0x07;// 000 0111
 326         } else {
 327                 event->touch_point = buf[2] & 0x03;// 0000 0011
 328         }
 329
 330 //      printk("touch_point = %d\n", event->touch_point);
 331     if (event->touch_point == 0) {
 332         //      printk("release point !!!!!!!!!!!!!!!!!\n");
 333                 ft5x0x_ts_release(data);
 334                 return 1;
 335     }
 336         cnt =0;
 337 #if CONFIG_FT5X0X_MULTITOUCH               //  #ifdef
 338     switch (event->touch_point) {
 339                 if (MAX_POINT == 5)     {
 340                         case 5:
 341                                 event->x5 = (s16)(buf[0x1b] & 0x0F)<<8 | (s16)buf[0x1c];
 342                                 event->y5 = (s16)(buf[0x1d] & 0x0F)<<8 | (s16)buf[0x1e];
 343                                 status = (s16)((buf[0x1b] & 0xc0) >> 6);
 344                                 event->touch_ID5=(s16)(buf[0x1D] & 0xF0)>>4;
 345                                 if(event->x5 > 1024)
 346                                         cnt ++;
 347                                 //   printk("read ID5 = %d\n",event->touch_ID5,status);
 348                                 //      printk("read status5= %d\n",status);
 349                         #if 0
 350                                 if (status == 1) {
 351                                                 printk("point 5 release!\n");
 352                                         ft5x0x_ts_release(data);
 353                                 }
 354                         #endif
 355                         case 4:
 356                                 event->x4 = (s16)(buf[0x15] & 0x0F)<<8 | (s16)buf[0x16];
 357                                 event->y4 = (s16)(buf[0x17] & 0x0F)<<8 | (s16)buf[0x18];
 358                                 status = (s16)((buf[0x15] & 0xc0) >> 6);
 359                                 //event->touch_ID4=(s16)(buf[0x17] & 0xF0);
 360                                 event->touch_ID4=(s16)(buf[0x17] & 0xF0)>>4;
 361                         //      printk("read ID4 = %d,read status4 = %d\n",event->touch_ID4,status);
 362                         #if 0
 363                                 if (status == 1) {
 364                                                 printk("point 4 release!\n");
 365                                         ft5x0x_ts_release(data);
 366                                 }
 367                         #endif
 368                                 if(event->x4 >1024)
 369                                         cnt ++;
 370                         case 3:
 371                                 event->x3 = (s16)(buf[0x0f] & 0x0F)<<8 | (s16)buf[0x10];
 372                                 event->y3 = (s16)(buf[0x11] & 0x0F)<<8 | (s16)buf[0x12];
 373                                 status = (s16)((buf[0x0f] & 0xc0) >> 6);
 374                         //      event->touch_ID3=(s16)(buf[0x11] & 0xF0);
 375                                 event->touch_ID3=(s16)(buf[0x11] & 0xF0)>>4;
 376                         //              printk("read ID3 = %d,read status3 = %d\n",event->touch_ID3,status);
 377                         #if 0
 378                                 if (status == 1) {
 379                                                 printk("point 3 release!\n");
 380                                         ft5x0x_ts_release(data);
 381                                 }
 382                         #endif
 383                                 if(event->x3 > 1024)
 384                                         cnt ++;
 385                 }
 386                 case 2:
 387                         event->x2 = (s16)(buf[9] & 0x0F)<<8 | (s16)buf[10];
 388                         event->y2 = (s16)(buf[11] & 0x0F)<<8 | (s16)buf[12];
 389                         status = (s16)((buf[0x9] & 0xc0) >> 6);
 390                     //   event->touch_ID2=(s16)(buf[0x0b] & 0xF0);
 391                     event->touch_ID2=(s16)(buf[0x0b] & 0xF0)>>4;
 392                 //      printk("read ID2 = %d,read status2 = %d\n",event->touch_ID2,status);
 393                 #if 0
 394                         if (status == 1) {
 395                                         printk("point 2 release!\n");
 396                                 ft5x0x_ts_release(data);
 397                         }
 398                 #endif
 399                         if(event->x2 > 1024)
 400                                 cnt ++;
 401                 case 1:
 402                         event->x1 = (s16)(buf[3] & 0x0F)<<8 | (s16)buf[4];
 403                         event->y1 = (s16)(buf[5] & 0x0F)<<8 | (s16)buf[6];
 404                         status = ((buf[0x3] & 0xc0) >> 6);
 405                         event->status= status ;
 406                    //  event->touch_ID1=(s16)(buf[5] & 0xF0);
 407                         event->touch_ID1=(s16)(buf[0x05] & 0xF0)>>4;
 408                                 //printk("status1= %d\n",event->status);
 409                 #if 0
 410                         if (status == 1) {
 411                                 printk("point 1 release!\n");
 412                                 ft5x0x_ts_release(data);
 413                         }
 414                 #endif
 415                         if(event->x1 >1024)
 416                                 cnt ++;
 417
 418             break;
 419                 default:
 420                     return -1;
 421         }
 422
 423 /*
 424         if((event->touch_point ==1)
 425                 &&((event->y1<BACK_KEY_MIN) ||(event->y2>MENU_KEY_MAX)))
 426         {
 427                 ft5x0x_ts_release(data);
 428                 return 1;
 429         }
 430
 431         if(((event->touch_point - cnt) ==0)&&(event->touch_point >1))
 432         {
 433                 ft5x0x_ts_release(data);
 434                 return 1;
 435         }
 436 */
 437 #else
 438     if (event->touch_point == 1) {
 439         event->x1 = (s16)(buf[3] & 0x0F)<<8 | (s16)buf[4];
 440                 event->y1 = (s16)(buf[5] & 0x0F)<<8 | (s16)buf[6];
 441     }
 442 #endif
 443     event->pressure =200;         //200;
 444
 445  //   printk("status2= %d\n",event->status);
 446
 447     return 0;
 448 }
 449
 450 static void ft5x0x_report_value(struct ft5x0x_ts_data *data )
 451 {
 452         //struct ft5x0x_ts_data *data = i2c_get_clientdata(&ft5x0x_client);
 453         struct ts_event *event = &data->event;
 454
 455   #if CONFIG_TOUCH_PANEL_KEY
 456         u8  key_flag=0;
 457    //     static  u16 point_data=0;
 458   #endif
 459
 460
 461 #if  CONFIG_FT5X0X_MULTITOUCH           //#ifdef
 462         switch(event->touch_point) {
 463                 if (MAX_POINT == 5){
 464                         case 5:
 465
 466                                 if(event->x5 <= 1024)
 467                                 {
 468                                         input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID5);
 469                                         input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
 470                                         input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x5);
 471                                         input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y5);
 472                                         input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);
 473                                         input_mt_sync(data->input_dev);
 474                                 }
 475                         //      printk("===x5 = %d,y5 = %d ====\n",event->x5,event->y5);
 476                         case 4:
 477                                 if(event->x4 <= 1024)
 478                                 {
 479                                         input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID4);
 480                                         input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
 481                                         input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x4);
 482                                         input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y4);
 483                                         input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);
 484                                         input_mt_sync(data->input_dev);
 485                                 }
 486                         //      printk("===x4 = %d,y4 = %d ====\n",event->x4, event->y4);
 487                         case 3:
 488                                 if(event->x3 <= 1024)
 489                                 {
 490                                         input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID3);
 491                                         input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
 492                                         input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x3);
 493                                         input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y3);
 494                                         input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);
 495                                         input_mt_sync(data->input_dev);
 496                                 }
 497                         //      printk("===x3 = %d,y3 = %d ====\n",event->x3, event->y3);
 498                 }
 499                 case 2:
 500                         if(event->x2 <= 1024)
 501                         {
 502                                 input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID2);
 503                                 input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
 504                                 input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x2);
 505                                 input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y2);
 506                                 input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);
 507                                 input_mt_sync(data->input_dev);
 508                         }
 509                 //      printk("===x2 = %d,y2 = %d ====\n",event->x2,event->y2);
 510                 case 1:
 511 #if CONFIG_TOUCH_PANEL_KEY
 512                 if(event->status==0)
 513                 {
 514                               key_flag=1;
 515                 }
 516
 517             if(event->x1 >1024)
 518                 {
 519                 //  printk("point 1 key1\n");
 520                 //      printk("===x1 = %d,y1 = %d ====\n",event->x1,event->y1);
 521                         if(key_flag)
 522                         {
 523                                 if((event->y1>BACK_KEY_MIN)&&(event->y1<BACK_KEY_MAX))                             // M6 10  - 90
 524                                 {
 525                                         input_report_key(data->input_dev,KEY_BACK,1);     //158 //MENU
 526                                         input_sync(data->input_dev);
 527                                         input_report_key(data->input_dev,KEY_BACK,0);     //158 //MENU
 528                                         input_sync(data->input_dev);
 529 #if CONFIG_TOUCH_PANEL_LED                                                               //#ifdef
 530                                         // if(gpio_request(RK29SDK_PANEL_LED_GPIO_SITCH,NULL) != 0){
 531                                         // gpio_free(RK29SDK_PANEL_LED_GPIO_SITCH);
 532                                         //     printk("panel Key LED error\n");
 533                                         // return -EIO;
 534                                         //  }
 535                                         gpio_direction_output(RK29SDK_PANEL_LED_GPIO_SITCH, 0);
 536                                         gpio_set_value(RK29SDK_PANEL_LED_GPIO_SITCH,GPIO_HIGH);
 537 #endif
 538                                         //                printk("point 1 key2\n");
 539                                 }
 540                                 else if((event->y1>HOME_KEY_MIN)&&(event->y1<HOME_KEY_MAX))                 //M6 110 - 190
 541                                 {
 542                                         input_report_key(data->input_dev,KEY_HOME,1);     //102 //Home
 543                                         input_sync(data->input_dev);
 544                                         input_report_key(data->input_dev,KEY_HOME,0);     //102 //Home
 545                                         input_sync(data->input_dev);
 546 #if CONFIG_TOUCH_PANEL_LED                                                                     //  #ifdef
 547                                         //  if(gpio_request(RK29SDK_PANEL_LED_GPIO_SITCH,NULL) != 0){
 548                                         //  gpio_free(RK29SDK_PANEL_LED_GPIO_SITCH);
 549                                         //         printk("panel Key LED error\n");
 550                                         //   return -EIO;
 551                                         //  }
 552                                         gpio_direction_output(RK29SDK_PANEL_LED_GPIO_SITCH, 0);
 553                                         gpio_set_value(RK29SDK_PANEL_LED_GPIO_SITCH,GPIO_HIGH);
 554 #endif
 555                                         //                  printk("point 1 key3\n");
 556                                 }
 557                                 else  if((event->y1>MENU_KEY_MIN)&&(event->y1<MENU_KEY_MAX))                                 // M6 210 -290
 558                                 {
 559                                         input_report_key(data->input_dev,KEY_MENU,1);     //59  //esc
 560                                         input_sync(data->input_dev);
 561                                         input_report_key(data->input_dev,KEY_MENU,0);     //59  //esc
 562                                         input_sync(data->input_dev);
 563 #if CONFIG_TOUCH_PANEL_LED                                                                     //   #ifdef
 564                                         //   if(gpio_request(RK29SDK_PANEL_LED_GPIO_SITCH,NULL) != 0){
 565                                         //  gpio_free(RK29SDK_PANEL_LED_GPIO_SITCH);
 566                                         //      printk("panel Key LED error\n");
 567                                         //   return -EIO;
 568                                         //       }
 569                                         gpio_direction_output(RK29SDK_PANEL_LED_GPIO_SITCH, 0);
 570                                         gpio_set_value(RK29SDK_PANEL_LED_GPIO_SITCH,GPIO_HIGH);
 571 #endif
 572                                         //                  printk("point 1 key4\n");
 573                                 }
 574                                 else
 575                                 {
 576                                         ft5x0x_ts_release(data);
 577                                 }
 578
 579                         }
 580                         else
 581                         {
 582                                 ft5x0x_ts_release(data);
 583                         }
 584
 585                 }
 586                 else
 587                 {
 588                     input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID1);
 589                         input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
 590                         input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x1);
 591                         input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y1);
 592                         input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);
 593                         input_mt_sync(data->input_dev);
 594         //              printk("===x1 = %d,y1 = %d ====\n",event->x1,event->y1);
 595                 }
 596 #else
 597                 input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID1);
 598                 input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
 599                 input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x1);
 600                 input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y1);
 601                 input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);
 602                 input_mt_sync(data->input_dev);
 603         //      printk("===x1 = %d,y1 = %d ====\n",event->x1,event->y1);
 604 #endif
 605         default:
 606         //      printk("==touch_point default =\n");
 607         //      printk("read status0= %d\n",event->status);
 608         //      if (event->status== 1) {
 609         //              printk("point 0 release!\n");
 610         //              ft5x0x_ts_release(data);
 611         //      }
 612 #if CONFIG_TOUCH_PANEL_KEY
 613                 key_flag=0;
 614 #endif
 615         break;
 616         }
 617 #else   /* CONFIG_FT5X0X_MULTITOUCH*/
 618         if (event->touch_point == 1) {
 619                 input_report_abs(data->input_dev, ABS_X, event->x1);
 620                 input_report_abs(data->input_dev, ABS_Y, event->y1);
 621                 input_report_abs(data->input_dev, ABS_PRESSURE, event->pressure);
 622         }
 623         input_report_key(data->input_dev, BTN_TOUCH, 1);
 624 #endif  /* CONFIG_FT5X0X_MULTITOUCH*/
 625         input_sync(data->input_dev);
 626
 627  //   printk("status3= %d\n",event->status);
 628
 629
 630 }       /*end ft5x0x_report_value*/
 631
 632 static void ft5x0x_ts_pen_irq_work(struct work_struct *work)
 633 {
 634         int ret = -1;
 635 //      printk("==work 1=\n");
 636
 637         struct ft5x0x_ts_data *ft5x0x_ts =
 638                 container_of(work, struct ft5x0x_ts_data, pen_event_work);
 639
 640
 641         ret = ft5x0x_read_data(ft5x0x_ts);
 642         if (ret == 0) {
 643                 ft5x0x_report_value(ft5x0x_ts);
 644         //      printk("==work 2=\n");
 645         }
 646 //      else printk("data package read error\n");
 647 //      printk("==work 2=\n");
 648 //      msleep(1);
 649              enable_irq(ft5x0x_ts->irq);
 650         //enable_irq(7);
 651 //      gpio_irq_enable(TOUCH_INT_IOPIN);
 652 }
 653
 654 static irqreturn_t ft5x0x_ts_interrupt(int irq, void *dev_id)
 655 {
 656
 657         struct ft5x0x_ts_data *ft5x0x_ts = dev_id;
 658
 659         //printk("ft5x0x_ts irq  =%d",ft5x0x_ts->irq);
 660
 661               disable_irq_nosync(ft5x0x_ts->irq);
 662    //   disable_irq(ft5x0x_ts->irq);
 663 //      disable_irq(7);
 664         //gpio_irq_disable(ft5x0x_ts->irq);
 665
 666         if (!work_pending(&ft5x0x_ts->pen_event_work))
 667         {
 668                 queue_work(ft5x0x_ts->ts_workqueue, &ft5x0x_ts->pen_event_work);
 669     //   printk("ft5x0x_ts_work!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
 670         }
 671
 672         return IRQ_HANDLED;
 673 }
 674
 675
 676 static int __devexit ft5406_remove(struct i2c_client *client)
 677 {
 678         struct ft5x0x_ts_data *ft5x0x_ts = i2c_get_clientdata(client);
 679
 680     // printk("==ft5x0x_ts_remove=\n");
 681
 682 //      free_irq(client->irq, ft5x0x_ts);
 683 //      free_irq(7, ft5x0x_ts);
 684         free_irq(ft5x0x_ts->irq, ft5x0x_ts);
 685
 686         input_unregister_device(ft5x0x_ts->input_dev);
 687         kfree(ft5x0x_ts);
 688         cancel_work_sync(&ft5x0x_ts->pen_event_work);
 689         destroy_workqueue(ft5x0x_ts->ts_workqueue);
 690         i2c_set_clientdata(client, NULL);
 691 #ifdef CONFIG_HAS_EARLYSUSPEND
 692     unregister_early_suspend(&ft5406_early_suspend);
 693 #endif
 694     this_client = NULL;
 695
 696         return 0;
 697 }
 698
 699
 700 #ifdef CONFIG_HAS_EARLYSUSPEND
 701 static int ft5x0x_ts_suspend(struct early_suspend *h)
 702 {
 703
 704 u8 buf[1];
 705 //u8 buf_r[1];
 706 int read_data=5;
 707 int err = 0;
 708
 709 //      printk("==ft5x0x_ts_suspend=\n");
 710
 711
 712 //      struct ft5x0x_ts_data *ts;
 713 //      ts =  container_of(handler, struct ft5x0x_ts_data, early_suspend);
 714    #if 0
 715         struct ft5x0x_ts_data *ft5x0x_ts = i2c_get_clientdata(client);
 716         if (device_may_wakeup(&client->dev))
 717                 enable_irq_wake(ft5x0x_ts->irq);
 718    #endif
 719 //      disable_irq(ft5x0x_client->irq);
 720 //      cancel_work_sync(&ts->pen_event_work);
 721 //      flush_workqueue(ts->ts_workqueue);
 722 // ==set mode ==,
 723            disable_irq(102);
 724         #if 1
 725          buf[0]=PMODE_HIBERNATE;
 726         while(read_data)
 727              {
 728            err=ft5406_set_regs(this_client,FT5X0X_REG_PMODE, buf,1);
 729         //      printk("==ft5406 suspend write 111=%d\n",buf[0]);
 730            if(err==1)
 731                  {
 732                 read_data=0;
 733                  }
 734            else
 735                   {
 736                   read_data--;
 737         //      printk("==ft5406 suspend write222=%d\n",buf[0]);
 738            ft5406_set_regs(this_client,FT5X0X_REG_PMODE, buf,1);
 739                   }
 740              }
 741
 742         //      printk("==ft5406 suspend write=%d\n",buf[0]);
 743         //      printk("==ft5406 suspend write err=%d\n",err);
 744         //       msleep(50);                             //harry 2011.04.20
 745         //       err = ft5406_read_regs(this_client,FT5X0X_REG_PMODE,buf_r,1);
 746         //       printk("==ft5406 suspend read=%d\n",buf_r[0]);
 747         //      printk("==ft5406 suspend read err=%d\n",err);
 748
 749        #endif
 750
 751            #if CONFIG_TOUCH_PANEL_LED
 752             //  if(gpio_request(RK29SDK_PANEL_LED_GPIO_SITCH,NULL) != 0){
 753              //        gpio_free(RK29SDK_PANEL_LED_GPIO_SITCH);
 754             //          printk("panel Key LED error\n");
 755            //          return -EIO;
 756            //               }
 757                      gpio_direction_output(RK29SDK_PANEL_LED_GPIO_SITCH, 0);
 758                      gpio_set_value(RK29SDK_PANEL_LED_GPIO_SITCH,GPIO_LOW);
 759           //      printk("suspend led 2\n");
 760           #endif
 761
 762         return 0;
 763
 764 }
 765
 766 static int ft5x0x_ts_resume(struct early_suspend *h)
 767 {
 768         //printk("==ft5x0x_ts_resume=\n");
 769           #if 0
 770                 struct ft5x0x_ts_data *ft5x0x_ts = i2c_get_clientdata(client);
 771         if (device_may_wakeup(&client->dev))
 772                 disable_irq_wake(ft5x0x_ts->irq);
 773           #endif
 774         // wake the mode
 775 //      __gpio_as_output(GPIO_FT5X0X_WAKE);
 776 //      __gpio_clear_pin(GPIO_FT5X0X_WAKE);             //set wake = 0,base on system
 777 //       msleep(100);
 778 //      __gpio_set_pin(GPIO_FT5X0X_WAKE);                       //set wake = 1,base on system
 779 //      msleep(100);
 780 //      enable_irq(IRQ_EINT(6));
 781        enable_irq(102);
 782          #if 1
 783        gpio_direction_output(TOUCH_RESET_PIN, 0);
 784         gpio_set_value(TOUCH_RESET_PIN,GPIO_LOW);
 785         msleep(20);                             //harry 2011.04.20
 786         gpio_set_value(TOUCH_RESET_PIN,GPIO_HIGH);
 787          #endif
 788
 789         return 0;
 790 }
 791 #endif
 792
 793 static int  ft5406_probe(struct i2c_client *client ,const struct i2c_device_id *id)
 794 {
 795         struct ft5x0x_ts_data *ft5x0x_ts;
 796         struct input_dev *input_dev;
 797         struct ft5406_platform_data *pdata = pdata = client->dev.platform_data;
 798
 799         int err = 0;
 800         int ret = 0;
 801         u8 buf_w[1];
 802         u8 buf_r[1];
 803
 804         //printk("==ft5x0x_ts_probe=\n");
 805
 806         if (!pdata) {
 807                 dev_err(&client->dev, "platform data is required!\n");
 808                 return -EINVAL;
 809         }
 810
 811         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 812                 return -EIO;
 813
 814
 815         ft5x0x_ts = kzalloc(sizeof(*ft5x0x_ts), GFP_KERNEL);
 816         if (!ft5x0x_ts) {
 817                 err = -ENOMEM;
 818                 goto exit_alloc_data_failed;
 819         }
 820 /*
 821         ft5x0x_client.adapter = bus;
 822         ft5x0x_client.addr= address;
 823         ft5x0x_client.mode = NORMALMODE; //NORMALNOSTOPMODE;// DIRECTMODE;
 824         ft5x0x_client.Channel = I2C_CH0;
 825         ft5x0x_client.speed = 300;
 826         ft5x0x_client.addressBit=I2C_7BIT_ADDRESS_8BIT_REG;
 827         ft5x0x_ts->client=&ft5x0x_client;
 828
 829         i2c_set_clientdata(&ft5x0x_client, ft5x0x_ts);
 830
 831         err = i2c_attach_client(&ft5x0x_client);
 832         if (err < 0)
 833         {
 834                 printk("ft5x0x attach client failed!!!!\n");
 835                 goto exit_alloc_data_failed;
 836         }
 837
 838         INIT_WORK(&ft5x0x_ts->pen_event_work, ft5x0x_ts_pen_irq_work);
 839         ft5x0x_ts->ts_workqueue = create_singlethread_workqueue("ft5x0x_ts");
 840         if (!ft5x0x_ts->ts_workqueue) {
 841                 err = -ESRCH;
 842                 goto exit_create_singlethread;
 843         }
 844
 845         rockchip_mux_api_set(TOUCH_INT_IOMUX_PINNAME,TOUCH_INT_IOMUX_PINDIR);
 846         GPIOSetPinDirection(TOUCH_INT_IOPIN, GPIO_IN);
 847         GPIOPullUpDown(TOUCH_INT_IOPIN, GPIOPullUp);
 848         err = request_gpio_irq(TOUCH_INT_IOPIN, ft5x0x_ts_interrupt, GPIOEdgelFalling, ft5x0x_ts);
 849         if(err < 0)
 850         {
 851                 printk("ft5x0x_probe: request irq failed\n");
 852                 goto exit_irq_request_failed;
 853         }
 854 */
 855         input_dev = input_allocate_device();
 856         if (!input_dev) {
 857                 err = -ENOMEM;
 858                 printk("failed to allocate input device\n");
 859                 goto exit_input_dev_alloc_failed;
 860         }
 861
 862        this_client = client;
 863         ft5x0x_ts->client = client;
 864         ft5x0x_ts->irq = client->irq;
 865         ft5x0x_ts->input_dev = input_dev;
 866
 867   #if   CONFIG_FT5X0X_MULTITOUCH                //#ifdef
 868         set_bit(ABS_MT_TOUCH_MAJOR, input_dev->absbit);
 869         set_bit(ABS_MT_POSITION_X, input_dev->absbit);
 870         set_bit(ABS_MT_POSITION_Y, input_dev->absbit);
 871         set_bit(ABS_MT_WIDTH_MAJOR, input_dev->absbit);
 872
 873         //input_dev->evbit[0] = BIT_MASK(EV_ABS)|BIT_MASK(EV_KEY)|BIT_MASK(EV_SYN);                  //harry 03.21
 874              #if  CONFIG_TOUCH_PANEL_KEY
 875              set_bit(KEY_HOME, input_dev->keybit);
 876             set_bit(KEY_MENU, input_dev->keybit);
 877             set_bit(KEY_BACK, input_dev->keybit);
 878             #endif
 879
 880         input_set_abs_params(input_dev,
 881                              ABS_MT_POSITION_X, 0, SCREEN_MAX_X, 0, 0);
 882         input_set_abs_params(input_dev,
 883                              ABS_MT_POSITION_Y, 0, SCREEN_MAX_Y, 0, 0);
 884         input_set_abs_params(input_dev,
 885                              ABS_MT_TOUCH_MAJOR, 0, PRESS_MAX, 0, 0);
 886         input_set_abs_params(input_dev,
 887                              ABS_MT_WIDTH_MAJOR, 0, 200, 0, 0);
 888         input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, 10, 0, 0);
 889 #else
 890         set_bit(ABS_X, input_dev->absbit);
 891         set_bit(ABS_Y, input_dev->absbit);
 892         set_bit(ABS_PRESSURE, input_dev->absbit);
 893         set_bit(BTN_TOUCH, input_dev->keybit);
 894
 895         input_set_abs_params(input_dev, ABS_X, 0, SCREEN_MAX_X, 0, 0);
 896         input_set_abs_params(input_dev, ABS_Y, 0, SCREEN_MAX_Y, 0, 0);
 897         input_set_abs_params(input_dev,
 898          ABS_PRESSURE, 0, PRESS_MAX, 0 , 0);
 899 #endif
 900
 901
 902         set_bit(EV_ABS, input_dev->evbit);
 903         set_bit(EV_KEY, input_dev->evbit);
 904
 905      #if  CONFIG_TOUCH_PANEL_KEY
 906         set_bit(EV_SYN, input_dev->evbit);              //harry 03.21
 907     #endif
 908
 909         input_dev->name         = FT5X0X_NAME;          //dev_name(&client->dev)
 910         err = input_register_device(input_dev);
 911         if (err) {
 912         //      printk("ft5x0x_ts_probe: failed to register input device: \n");
 913                 goto exit_input_register_device_failed;
 914         }
 915
 916 //      printk("==probe over =\n");
 917         if (pdata->init_platform_hw)
 918                 pdata->init_platform_hw();
 919
 920         if (!ft5x0x_ts->irq) {
 921                 dev_dbg(&ft5x0x_ts->client->dev, "no IRQ?\n");
 922                 return -ENODEV;
 923         }else{
 924                 ft5x0x_ts->irq = gpio_to_irq(ft5x0x_ts->irq);
 925         }
 926
 927 //printk("ft5x0x_ts irq  =%d", ft5x0x_ts->irq);
 928
 929
 930         INIT_WORK(&ft5x0x_ts->pen_event_work, ft5x0x_ts_pen_irq_work);
 931         ft5x0x_ts->ts_workqueue = create_singlethread_workqueue("ft5x0x_ts");
 932         if (!ft5x0x_ts->ts_workqueue) {
 933                 err = -ESRCH;
 934                 goto exit_create_singlethread;
 935         }
 936
 937
 938
 939         //printk("client->dev.driver->name %s  ,%d \n",client->dev.driver->name,ft5x0x_ts->irq);
 940
 941
 942         ret = request_irq(ft5x0x_ts->irq, ft5x0x_ts_interrupt, /*IRQF_TRIGGER_LOW*/IRQF_TRIGGER_FALLING,     //IRQF_DISABLED|IRQF_TRIGGER_FALLING,
 943                         client->dev.driver->name, ft5x0x_ts);
 944
 945         if (ret < 0) {
 946                 dev_err(&client->dev, "irq %d busy?\n", ft5x0x_ts->irq);
 947                 goto fail3;
 948         }
 949                                                                                      //harry 03.23
 950         #if 0
 951         ret = input_register_device(input_dev);
 952         if(ret<0)
 953         {
 954         //      printk("ft5406 register input device failed!!!!\n");
 955                 goto exit_irq_request_failed;
 956         }
 957         #endif
 958
 959 #ifdef CONFIG_HAS_EARLYSUSPEND
 960     ft5406_early_suspend.suspend =ft5x0x_ts_suspend;
 961    ft5406_early_suspend.resume =ft5x0x_ts_resume;
 962    ft5406_early_suspend.level = 0x2;
 963     register_early_suspend(&ft5406_early_suspend);
 964 #endif
 965
 966         //buf_w[0] = 6;                                   //harry 04.07
 967         buf_w[0] = 6;
 968
 969         err = ft5406_set_regs(client,0x88,buf_w,1);
 970                 //ft5x0x_i2c_txdata(0x88, buf_w, 1);    /* adjust frequency 60Hz */
 971
 972         buf_r[0] = 0;
 973         err = ft5406_read_regs(client,0x88,buf_r,1);
 974                 //ft5x0x_i2c_rxdata(0x88, buf_r, 1);
 975 //      printk("read buf[0x88] = %d\n", buf_r[0]);
 976
 977     return 0;
 978 fail3:
 979         free_irq(ft5x0x_ts->irq,ft5x0x_ts);
 980         i2c_set_clientdata(client, NULL);             //harry
 981         destroy_workqueue(ft5x0x_ts->ts_workqueue);   //harry
 982 exit_input_register_device_failed:
 983         input_free_device(input_dev);
 984 //      i2c_set_clientdata(client, NULL);
 985 //      kfree(ft5x0x_ts);
 986
 987 exit_input_dev_alloc_failed:
 988 //      free_irq(7, ft5x0x_ts);
 989         free_irq(ft5x0x_ts->irq, ft5x0x_ts);
 990 exit_irq_request_failed:
 991 exit_platform_data_null:
 992         cancel_work_sync(&ft5x0x_ts->pen_event_work);
 993         destroy_workqueue(ft5x0x_ts->ts_workqueue);
 994 exit_create_singlethread:
 995         printk("==singlethread error =\n");
 996         kfree(ft5x0x_ts);
 997 exit_alloc_data_failed:
 998         return err;
 999 }
1000
1001
1002
1003 static struct i2c_device_id ft5406_idtable[] = {
1004         { FT5X0X_NAME, 0 },
1005         { }
1006 };
1007
1008 MODULE_DEVICE_TABLE(i2c, ft5406_idtable);
1009
1010 static struct i2c_driver ft5406_driver  = {
1011         .driver = {
1012                 .owner  = THIS_MODULE,
1013                 .name   = FT5X0X_NAME
1014         },
1015         .id_table       = ft5406_idtable,
1016         .probe = ft5406_probe,
1017 #ifndef CONFIG_HAS_EARLYSUSPEND
1018        .suspend = ft5x0x_ts_suspend,
1019         .resume = ft5x0x_ts_resume,
1020 #endif
1021         .remove         = __devexit_p(ft5406_remove),
1022 };
1023
1024 static int __init ft5x0x_ts_init(void)
1025 {
1026         return i2c_add_driver(&ft5406_driver);
1027 }
1028
1029 static void __exit ft5x0x_ts_exit(void)
1030 {
1031         i2c_del_driver(&ft5406_driver);
1032 }
1033
1034 module_init(ft5x0x_ts_init);
1035 module_exit(ft5x0x_ts_exit);
1036
1037 MODULE_AUTHOR("<wenfs@Focaltech-systems.com>");
1038 MODULE_DESCRIPTION("FocalTech ft5x0x TouchScreen driver");
1039