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