drivers/input/touchscreen/atmel_mxt1386.c

   1 /*\r
   2  *  Atmel maXTouch Touchscreen Controller Driver\r
   3  *\r
   4  *  \r
   5  *  Copyright (C) 2010 Atmel Corporation\r
   6  *  Copyright (C) 2009 Raphael Derosso Pereira <raphaelpereira@gmail.com>\r
   7  *\r
   8  *  This program is free software; you can redistribute it and/or modify\r
   9  *  it under the terms of the GNU General Public License as published by\r
  10  *  the Free Software Foundation; either version 2 of the License, or\r
  11  *  (at your option) any later version.\r
  12  *\r
  13  *  This program is distributed in the hope that it will be useful,\r
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  16  *  GNU General Public License for more details.\r
  17  *\r
  18  *  You should have received a copy of the GNU General Public License\r
  19  *  along with this program; if not, write to the Free Software\r
  20  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\r
  21  */\r
  22 \r
  23 /*\r
  24  * \r
  25  * Driver for Atmel maXTouch family of touch controllers.\r
  26  *\r
  27  */\r
  28 \r
  29 #include <linux/i2c.h>\r
  30 #include <linux/interrupt.h>\r
  31 #include <linux/input.h>\r
  32 #include <linux/debugfs.h>\r
  33 #include <linux/cdev.h>\r
  34 #include <linux/mutex.h>\r
  35 \r
  36 #include <asm/uaccess.h>\r
  37 \r
  38 #include <linux/workqueue.h>\r
  39 #include <linux/kernel.h>\r
  40 #include <linux/module.h>\r
  41 #include <linux/gpio.h>\r
  42 #include <linux/slab.h>\r
  43 #include <linux/sched.h>\r
  44 #include <linux/init.h>\r
  45 #include <linux/platform_device.h>\r
  46 #include <linux/irq.h>\r
  47 #include <asm/io.h>\r
  48 #include <linux/kthread.h>\r
  49 #include <linux/delay.h>\r
  50 #include <mach/board.h>\r
  51 #include "atmel_mxt1386.h"\r
  52 \r
  53 //#define YANSEN_DEBUG  //yansen 20101230 regulator is under control in kernel (sbl too)\r
  54 #ifdef YANSEN_DEBUG\r
  55 #include <linux/regulator/consumer.h>\r
  56 #endif\r
  57 \r
  58 #define DRIVER_VERSION "0.9a"\r
  59 #define CONFIG_ABS_MT_TRACKING_ID\r
  60 \r
  61 static int debug = 0;\r
  62 static int comms = 1;\r
  63 static int ts_irq = 0;\r
  64 static u32 last_key=0;\r
  65 \r
  66 module_param(debug, int, 0644);\r
  67 module_param(comms, int, 0644);\r
  68 \r
  69 MODULE_PARM_DESC(debug, "Activate debugging output");\r
  70 MODULE_PARM_DESC(comms, "Select communications mode");\r
  71 \r
  72 static int mxt_read_block(struct i2c_client *client, u16 addr, u16 length,\r
  73                           u8 *value);\r
  74 static int mxt_write_byte(struct i2c_client *client, u16 addr, u8 value);\r
  75 static int mxt_write_block(struct i2c_client *client, u16 addr, u16 length,\r
  76                            u8 *value);\r
  77 \r
  78 /* Device Info descriptor */\r
  79 /* Parsed from maXTouch "Id information" inside device */\r
  80 struct mxt_device_info {\r
  81         u8   family_id;\r
  82         u8   variant_id;\r
  83         u8   major;\r
  84         u8   minor;\r
  85         u8   build;\r
  86         u8   num_objs;\r
  87         u8   x_size;\r
  88         u8   y_size;\r
  89         char family_name[16];    /* Family name */\r
  90         char variant_name[16];    /* Variant name */\r
  91         u16  num_nodes;           /* Number of sensor nodes */\r
  92 };\r
  93 \r
  94 /* object descriptor table, parsed from maXTouch "object table" */\r
  95 struct mxt_object {\r
  96         u16 chip_addr;\r
  97         u8  type;\r
  98         u8  size;\r
  99         u8  instances;\r
 100         u8  num_report_ids;\r
 101 };\r
 102 \r
 103 \r
 104 /* Mapping from report id to object type and instance */\r
 105 struct report_id_map {\r
 106         u8  object;\r
 107         u8  instance;\r
 108 /*\r
 109  * This is the first report ID belonging to object. It enables us to\r
 110  * find out easily the touch number: each touch has different report\r
 111  * ID (which are assigned to touches in increasing order). By\r
 112  * subtracting the first report ID from current, we get the touch\r
 113  * number.\r
 114  */\r
 115         u8  first_rid;\r
 116 };\r
 117 \r
 118 /* Driver datastructure */\r
 119 struct mxt_data {\r
 120         struct i2c_client    *client;\r
 121         struct input_dev     *input;\r
 122         char                 phys_name[32];\r
 123         int                  irq;\r
 124 \r
 125         u16                  last_read_addr;\r
 126         bool                 new_msgs;\r
 127         u8                   *last_message;\r
 128 \r
 129         int                  valid_irq_counter;\r
 130         int                  invalid_irq_counter;\r
 131         int                  irq_counter;\r
 132         int                  message_counter;\r
 133         int                  read_fail_counter;\r
 134 \r
 135         int                  bytes_to_read;\r
 136 \r
 137         struct delayed_work  dwork;\r
 138         struct work_struct   work;\r
 139         struct workqueue_struct *queue;\r
 140         \r
 141         u8                   xpos_format;\r
 142         u8                   ypos_format;\r
 143 \r
 144         u8                   numtouch;\r
 145 \r
 146         struct mxt_device_info  device_info;\r
 147 \r
 148         u32                  info_block_crc;\r
 149         u32                  configuration_crc;\r
 150         u16                  report_id_count;\r
 151         struct report_id_map *rid_map;\r
 152         struct mxt_object    *object_table;\r
 153 \r
 154         u16                  msg_proc_addr;\r
 155         u8                   message_size;\r
 156 \r
 157         u16                  max_x_val;\r
 158         u16                  max_y_val;\r
 159 \r
 160         int                 (*init_hw)(struct device *dev);\r
 161         void                 (*exit_hw)(struct device *dev);\r
 162         u8                   (*valid_interrupt)(void);\r
 163         u8                   (*read_chg)(void);\r
 164 \r
 165         /* debugfs variables */\r
 166         struct dentry        *debug_dir;\r
 167         int                  current_debug_datap;\r
 168 \r
 169         struct mutex         debug_mutex;\r
 170         u16                  *debug_data;\r
 171 \r
 172         /* Character device variables */\r
 173         struct cdev          cdev;\r
 174         struct cdev          cdev_messages;  /* 2nd Char dev for messages */\r
 175         dev_t                dev_num;\r
 176         struct class         *mxt_class;\r
 177 \r
 178         u16                  address_pointer;\r
 179         bool                 valid_ap;\r
 180 \r
 181         /* Message buffer & pointers */\r
 182         char                 *messages;\r
 183         int                  msg_buffer_startp, msg_buffer_endp;\r
 184         /* Put only non-touch messages to buffer if this is set */\r
 185         char                 nontouch_msg_only; \r
 186         struct mutex         msg_mutex;\r
 187 };\r
 188 \r
 189 static struct mxt_data          *atmel_mxt;\r
 190 \r
 191 \r
 192 #define I2C_RETRY_COUNT 5\r
 193 #define I2C_PAYLOAD_SIZE 254\r
 194 \r
 195 /* Returns the start address of object in mXT memory. */\r
 196 #define MXT_BASE_ADDR(object_type, mxt)                                 \\r
 197         get_object_address(object_type, 0, mxt->object_table,           \\r
 198                            mxt->device_info.num_objs)\r
 199 \r
 200 /* Maps a report ID to an object type (object type number). */\r
 201 #define REPORT_ID_TO_OBJECT(rid, mxt)                   \\r
 202         (((rid) == 0xff) ? 0 : mxt->rid_map[rid].object)\r
 203 \r
 204 /* Maps a report ID to an object type (string). */\r
 205 #define REPORT_ID_TO_OBJECT_NAME(rid, mxt)                      \\r
 206         object_type_name[REPORT_ID_TO_OBJECT(rid, mxt)]\r
 207 \r
 208 /* Returns non-zero if given object is a touch object */\r
 209 #define IS_TOUCH_OBJECT(object) \\r
 210         ((object == MXT_TOUCH_MULTITOUCHSCREEN_T9) || \\r
 211          (object == MXT_TOUCH_KEYARRAY_T15) ||  \\r
 212          (object == MXT_TOUCH_PROXIMITY_T23) || \\r
 213          (object == MXT_TOUCH_SINGLETOUCHSCREEN_T10) || \\r
 214          (object == MXT_TOUCH_XSLIDER_T11) || \\r
 215          (object == MXT_TOUCH_YSLIDER_T12) || \\r
 216          (object == MXT_TOUCH_XWHEEL_T13) || \\r
 217          (object == MXT_TOUCH_YWHEEL_T14) || \\r
 218          (object == MXT_TOUCH_KEYSET_T31) || \\r
 219          (object == MXT_TOUCH_XSLIDERSET_T32) ? 1 : 0)\r
 220 \r
 221 #define print_ts(level, ...) \\r
 222         do { \\r
 223                 if (debug >= (level)) \\r
 224                         printk(__VA_ARGS__); \\r
 225         } while (0) \r
 226 \r
 227 /* following are debug infomation switch, add by acgzx */\r
 228 #define TOUCH_RESET_PIN                         RK29_PIN6_PC3\r
 229 #define TOUCH_INT_PIN                           RK29_PIN0_PA2\r
 230 #define LCDC_STANDBY_PIN                        RK29_PIN6_PD1\r
 231 //#define TS_PEN_IRQ_GPIO RK29_PIN0_PA2//61\r
 232                 \r
 233 #define WORKQ_RIGHTNOW          1\r
 234 #define TOUCH_KEY_EN    1\r
 235 \r
 236 /* macro switch for debug log */                 \r
 237 #define MXT1386_DEBUG_LOG_EN    0// 1           \r
 238 #if     MXT1386_DEBUG_LOG_EN\r
 239 #define MXT1386_LOG     printk\r
 240 #else\r
 241 #define MXT1386_LOG\r
 242 #endif\r
 243 \r
 244 #define WRITE_MT_CONFIG         1//0\r
 245 \r
 246 struct mxt_key_info{\r
 247     u32  start;\r
 248     u32  end;\r
 249     u32 virtual_x;\r
 250     u32 virtual_y;\r
 251     u32  code;\r
 252 };\r
 253 \r
 254 const struct mxt_key_info key_info[] = {\r
 255         {980, 1280, 3100, 4200, KEY_SEARCH},\r
 256     {1600, 1900, 3000, 4200, KEY_HOME},\r
 257     {2200, 2500, 1100, 4200, KEY_MENU},\r
 258     {2750, 3100, 1000, 4200, KEY_BACK},\r
 259 };\r
 260 \r
 261 /* \r
 262  * Check whether we have multi-touch enabled kernel; if not, report just the\r
 263  * first touch (on mXT224, the maximum is 10 simultaneous touches).\r
 264  * Because just the 1st one is reported, it might seem that the screen is not\r
 265  * responding to touch if the first touch is removed while the screen is being\r
 266  * touched by another finger, so beware. \r
 267  *\r
 268  * TODO: investigate if there is any standard set of input events that uppper\r
 269  * layers are expecting from a touchscreen? These can however be different for\r
 270  * different platforms, and customers may have different opinions too about\r
 271  * what should be interpreted as right-click, for example. \r
 272  *\r
 273  */\r
 274 #ifdef EFFICIENT_REPORT\r
 275 static void report_sync(struct mxt_data *mxt)\r
 276 {\r
 277         input_sync(mxt->input);\r
 278 }\r
 279 \r
 280 static inline void report_mt(int touch_number, int size, int x, int y, struct\r
 281                         mxt_data *mxt) {\r
 282         input_report_abs(mxt->input, ABS_MT_TRACKING_ID, touch_number);\r
 283 \r
 284         if(size != 0)\r
 285         {\r
 286                 input_report_abs(mxt->input, ABS_MT_POSITION_X, x);\r
 287                 input_report_abs(mxt->input, ABS_MT_POSITION_Y, y);\r
 288                 input_report_abs(mxt->input, ABS_MT_TOUCH_MAJOR, 10);\r
 289                 input_report_abs(mxt->input, ABS_MT_WIDTH_MAJOR, 20);\r
 290         }\r
 291         else\r
 292         {\r
 293                 input_report_abs(mxt->input, ABS_MT_TOUCH_MAJOR, 0);\r
 294                 input_report_abs(mxt->input, ABS_MT_WIDTH_MAJOR, 0);\r
 295         }\r
 296         input_mt_sync(mxt->input);\r
 297 }\r
 298 #else\r
 299 #define MAX_FINGERS             5\r
 300 struct finger {\r
 301         int x;\r
 302         int y;\r
 303         int size;\r
 304 };\r
 305 \r
 306 static struct finger fingers[MAX_FINGERS] = {};\r
 307 \r
 308 static void report_mt(int touch_number, int size, int x, int y, struct\r
 309                 mxt_data *mxt) \r
 310 {\r
 311         MXT1386_LOG(KERN_INFO "report_mt touch_number=%d, size=%d, x=%d, t=%d\n", __func__, \r
 312                         touch_number, size, x, y);\r
 313         if (touch_number > MAX_FINGERS ||  touch_number < 0) {\r
 314                 return;\r
 315         }\r
 316         fingers[touch_number].x = x;\r
 317         fingers[touch_number].y = y;\r
 318         fingers[touch_number].size = size;\r
 319         MXT1386_LOG(KERN_INFO "report_mt() OUT\n", __func__);\r
 320 }\r
 321 \r
 322 static void report_sync(struct mxt_data *mxt)\r
 323 {\r
 324         int i;\r
 325         int fin = 0;\r
 326 \r
 327         MXT1386_LOG(KERN_INFO "report_sync() IN\n", __func__);\r
 328 \r
 329         for (i = 0; i < MAX_FINGERS; i++) {\r
 330                 if (fingers[i].size != 0) {\r
 331                         fin++;\r
 332                         MXT1386_LOG(KERN_INFO "report_sync touch_number=%d, x=%d, y=%d, width=%d\n",\r
 333                                         i, fingers[i].x, fingers[i].y, fingers[i].size);\r
 334                         input_report_abs(mxt->input, ABS_MT_POSITION_X, fingers[i].x);\r
 335                         input_report_abs(mxt->input, ABS_MT_POSITION_Y, fingers[i].y);\r
 336                         input_report_abs(mxt->input, ABS_MT_TOUCH_MAJOR, 10);\r
 337                         input_report_abs(mxt->input, ABS_MT_WIDTH_MAJOR, 20);\r
 338                         input_mt_sync(mxt->input);\r
 339                 }\r
 340         }\r
 341 \r
 342         if (fin == 0) {\r
 343                 MXT1386_LOG(KERN_INFO "report_sync no fingler\n", __func__);\r
 344                 input_report_abs(mxt->input, ABS_MT_TOUCH_MAJOR, 0);\r
 345                 input_report_abs(mxt->input, ABS_MT_WIDTH_MAJOR, 0);\r
 346                 input_mt_sync(mxt->input);\r
 347         }\r
 348 \r
 349         input_sync(mxt->input);\r
 350         MXT1386_LOG(KERN_INFO "report_sync() OUT\n", __func__);\r
 351 }\r
 352 #endif\r
 353 \r
 354 static inline void report_gesture(int data, struct mxt_data *mxt)\r
 355 {\r
 356         //input_event(mxt->input, EV_MSC, MSC_GESTURE, data); \r
 357 }\r
 358 \r
 359 static const u8 *object_type_name[] = {\r
 360         [0]  = "Reserved",\r
 361         [5]  = "GEN_MESSAGEPROCESSOR_T5",\r
 362         [6]  = "GEN_COMMANDPROCESSOR_T6",\r
 363         [7]  = "GEN_POWERCONFIG_T7",\r
 364         [8]  = "GEN_ACQUIRECONFIG_T8",\r
 365         [9]  = "TOUCH_MULTITOUCHSCREEN_T9",\r
 366         [15] = "TOUCH_KEYARRAY_T15",\r
 367         [17] = "SPT_COMMSCONFIG_T18",\r
 368         [19] = "SPT_GPIOPWM_T19",\r
 369         [20] = "PROCI_GRIPFACESUPPRESSION_T20",\r
 370         [22] = "PROCG_NOISESUPPRESSION_T22",\r
 371         [23] = "TOUCH_PROXIMITY_T23",\r
 372         [24] = "PROCI_ONETOUCHGESTUREPROCESSOR_T24",\r
 373         [25] = "SPT_SELFTEST_T25",\r
 374         [27] = "PROCI_TWOTOUCHGESTUREPROCESSOR_T27",\r
 375         [28] = "SPT_CTECONFIG_T28",\r
 376         [37] = "DEBUG_DIAGNOSTICS_T37",\r
 377         [38] = "SPT_USER_DATA_T38",\r
 378         [40] = "PROCI_GRIPSUPPRESSION_T40",\r
 379         [41] = "PROCI_PALMSUPPRESSION_T41",\r
 380         [42] = "PROCI_FACESUPPRESSION_T42",\r
 381         [43] = "SPT_DIGITIZER_T43",\r
 382         [44] = "SPT_MESSAGECOUNT_T44",\r
 383 };\r
 384 \r
 385 static u16 get_object_address(uint8_t object_type,\r
 386                               uint8_t instance,\r
 387                               struct mxt_object *object_table,\r
 388                               int max_objs);\r
 389 \r
 390 int mxt_write_ap(struct mxt_data *mxt, u16 ap);\r
 391 \r
 392 static int mxt_read_block_wo_addr(struct i2c_client *client,\r
 393                            u16 length,\r
 394                                 u8 *value);\r
 395 \r
 396 #if WRITE_MT_CONFIG\r
 397 static const u8 atmel_1386_T7_config[] = {\r
 398 140,  //IDLEACQINT\r
 399 25, //ACTVACQINT\r
 400 60, //ACTV2IDLETO\r
 401 };\r
 402 \r
 403 static const u8 atmel_1386_T9_config[] = {\r
 404 0x03,  //CTRL 03\r
 405 0,  //XORIGIN\r
 406 0,  //YORIGIN\r
 407 28,  //XSIZE\r
 408 42,  //YSIZE\r
 409 0,  //AKSCFG\r
 410 32,  //BLEN\r
 411 60,  //TCHTHR\r
 412 3,  //TCHDI\r
 413 7, //1,//7,  //ORIENT//xhh\r
 414 0,  //MRGTIMEOUT\r
 415 5,  //MOVHYSTI\r
 416 5, //MOVHYSTN\r
 417 18,  //MOVFILTER\r
 418 10,  //NUMTOUCH\r
 419 10,  //MRGHYST\r
 420 10,  //MRGTHR\r
 421 10,  //AMPHYST\r
 422 0xff, //XRANGE low\r
 423 0x0f, //XRANGE high\r
 424 0xff, //YRANGE low\r
 425 0x0f, //YRANGE high\r
 426 0, //XLOCLIP\r
 427 0, //XHICLIP\r
 428 0, //YLOCLIP\r
 429 0, //YHICLIP\r
 430 0, //XEDGECTRL\r
 431 0, //XEDGEDIST\r
 432 0, //YEDGECTRL\r
 433 0, //YEDGEDIST\r
 434 0, //JUMPLIMIT\r
 435 0, //TCHHYST\r
 436 45, //XPITCH\r
 437 46, //YPITCH\r
 438 };\r
 439 \r
 440 static int atmel_1386_write_T7(struct mxt_data *mxt)\r
 441 {\r
 442         int ret, i;\r
 443         int size  = sizeof(atmel_1386_T7_config);\r
 444         for(i = 0; i<size; i++)\r
 445         {\r
 446                 ret = mxt_write_byte(mxt->client,\r
 447                               MXT_BASE_ADDR(MXT_GEN_POWERCONFIG_T7, mxt) +\r
 448                               i,\r
 449                               atmel_1386_T7_config[i]);\r
 450                 \r
 451                 if (ret < 0) {\r
 452                                 MXT1386_LOG(KERN_INFO "%s, Error writing to atmel T7!\n", __func__);\r
 453                 }\r
 454         }\r
 455         return ret;\r
 456 }\r
 457 \r
 458 static int atmel_1386_write_T9(struct mxt_data *mxt)\r
 459 {\r
 460         int ret, i;\r
 461         int size  = sizeof(atmel_1386_T9_config);\r
 462         \r
 463         for(i = 0; i<size; i++)\r
 464         {\r
 465                 ret = mxt_write_byte(mxt->client,\r
 466                               MXT_BASE_ADDR(MXT_TOUCH_MULTITOUCHSCREEN_T9, mxt) +\r
 467                               i,\r
 468                               atmel_1386_T9_config[i]);\r
 469                 \r
 470                 if (ret < 0) {\r
 471                                 MXT1386_LOG(KERN_INFO "%s, Error writing to atmel T9!\n", __func__);                            \r
 472                 }\r
 473         }\r
 474         return ret;\r
 475 }\r
 476 \r
 477 static int atmel_1386_write_config(struct mxt_data *mxt)\r
 478 {\r
 479         atmel_1386_write_T7(mxt);\r
 480         //atmel_1386_write_T9(mxt);\r
 481 \r
 482         mxt_write_byte(mxt->client,\r
 483                               MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +\r
 484                               MXT_ADR_T6_BACKUPNV,\r
 485                               MXT_CMD_T6_BACKUP);\r
 486         /*                    \r
 487         mxt_write_byte(mxt->client,\r
 488                               MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +\r
 489                               MXT_ADR_T6_RESET,\r
 490                               1);\r
 491         */\r
 492         return 0;\r
 493 }\r
 494 #endif\r
 495 \r
 496 static u8 mxt_valid_interrupt_dummy(void)\r
 497 {\r
 498         return 0;\r
 499 }\r
 500 \r
 501 static int mxt_buf_test(const u8 *src, u8 length)\r
 502 {\r
 503         u8 i;\r
 504         u8 *pbuf = (u8*)src;\r
 505 \r
 506         MXT1386_LOG(KERN_INFO "%s, buf test start..., length = %d\n", __func__, length);\r
 507         for(i=0; i<length; i++) {\r
 508                 MXT1386_LOG("0x%02x  ", pbuf[i]);\r
 509                 if(0==(i+1)%10)\r
 510                         MXT1386_LOG("\n");\r
 511         }\r
 512         MXT1386_LOG(KERN_INFO "%s, buf test end...\n", __func__);\r
 513 \r
 514         return 0;\r
 515 }\r
 516 \r
 517 ssize_t debug_data_read(struct mxt_data *mxt, char *buf, size_t count, \r
 518                         loff_t *ppos, u8 debug_command){\r
 519         int i;\r
 520         u16 *data;\r
 521         u16 diagnostics_reg;\r
 522         int offset = 0;\r
 523         int size;\r
 524         int read_size;\r
 525         int error;\r
 526         char *buf_start;\r
 527         u16 debug_data_addr;\r
 528         u16 page_address;\r
 529         u8 page;\r
 530         u8 debug_command_reg;\r
 531 \r
 532         data = mxt->debug_data;\r
 533         if (data == NULL)\r
 534                 return -EIO;\r
 535 \r
 536         /* If first read after open, read all data to buffer. */\r
 537         if (mxt->current_debug_datap == 0){\r
 538 \r
 539                 diagnostics_reg = MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, \r
 540                                                 mxt) + \r
 541                                   MXT_ADR_T6_DIAGNOSTIC;\r
 542                 if (count > (mxt->device_info.num_nodes * 2))\r
 543                         count = mxt->device_info.num_nodes;\r
 544         \r
 545                 debug_data_addr = MXT_BASE_ADDR(MXT_DEBUG_DIAGNOSTIC_T37, mxt)+ \r
 546                                   MXT_ADR_T37_DATA;\r
 547                 page_address = MXT_BASE_ADDR(MXT_DEBUG_DIAGNOSTIC_T37, mxt) +\r
 548                                MXT_ADR_T37_PAGE;\r
 549                 error = mxt_read_block(mxt->client, page_address, 1, &page);\r
 550                 if (error < 0)\r
 551                         return error;\r
 552                 MXT1386_LOG(KERN_INFO "debug data page = %d\n", __func__, page);                \r
 553                 while (page != 0) {\r
 554                         error = mxt_write_byte(mxt->client, \r
 555                                         diagnostics_reg, \r
 556                                         MXT_CMD_T6_PAGE_DOWN);\r
 557                         if (error < 0)\r
 558                                 return error;\r
 559                         /* Wait for command to be handled; when it has, the\r
 560                            register will be cleared. */\r
 561                         debug_command_reg = 1;\r
 562                         while (debug_command_reg != 0) {\r
 563                                 error = mxt_read_block(mxt->client, \r
 564                                                 diagnostics_reg, 1,\r
 565                                                 &debug_command_reg);\r
 566                                 if (error < 0)\r
 567                                         return error;\r
 568                                 MXT1386_LOG(KERN_INFO "Waiting for debug diag command "\r
 569                                         "to propagate...\n", __func__);\r
 570 \r
 571                         }\r
 572                         error = mxt_read_block(mxt->client, page_address, 1, \r
 573                                         &page);\r
 574                         if (error < 0)\r
 575                                 return error;\r
 576                         MXT1386_LOG(KERN_INFO "debug data page = %d\n", __func__, page);        \r
 577                 }\r
 578 \r
 579                 /*\r
 580                  * Lock mutex to prevent writing some unwanted data to debug\r
 581                  * command register. User can still write through the char \r
 582                  * device interface though. TODO: fix?\r
 583                  */\r
 584 \r
 585                 mutex_lock(&mxt->debug_mutex);\r
 586                 /* Configure Debug Diagnostics object to show deltas/refs */\r
 587                 error = mxt_write_byte(mxt->client, diagnostics_reg,\r
 588                                 debug_command);\r
 589 \r
 590                 /* Wait for command to be handled; when it has, the\r
 591                  * register will be cleared. */\r
 592                 debug_command_reg = 1;\r
 593                 while (debug_command_reg != 0) {\r
 594                         error = mxt_read_block(mxt->client, \r
 595                                         diagnostics_reg, 1,\r
 596                                         &debug_command_reg);\r
 597                         if (error < 0)\r
 598                                 return error;\r
 599                         MXT1386_LOG(KERN_INFO "Waiting for debug diag command "\r
 600                                 "to propagate...\n", __func__);\r
 601 \r
 602                 }       \r
 603 \r
 604                 if (error < 0) {\r
 605                         MXT1386_LOG(KERN_INFO "Error writing to maXTouch device!\n", __func__);\r
 606                         return error;\r
 607                 }\r
 608         \r
 609                 size = mxt->device_info.num_nodes * sizeof(u16);\r
 610 \r
 611                 while (size > 0) {\r
 612                         read_size = size > 128 ? 128 : size;\r
 613                         MXT1386_LOG(KERN_INFO "Debug data read loop, reading %d bytes...\n", __func__,\r
 614                                 read_size);\r
 615                         error = mxt_read_block(mxt->client, \r
 616                                                debug_data_addr, \r
 617                                                read_size, \r
 618                                                (u8 *) &data[offset]);\r
 619                         if (error < 0) {\r
 620                                 MXT1386_LOG(KERN_INFO "Error reading debug data\n", __func__);\r
 621                                 goto error;\r
 622                         }\r
 623                         offset += read_size/2;\r
 624                         size -= read_size;\r
 625 \r
 626                         /* Select next page */\r
 627                         error = mxt_write_byte(mxt->client, diagnostics_reg, \r
 628                                         MXT_CMD_T6_PAGE_UP);\r
 629                         if (error < 0) {\r
 630                                 MXT1386_LOG(KERN_INFO "Error writing to maXTouch device!\n", __func__);\r
 631                                 goto error;\r
 632                         }\r
 633                 }\r
 634                 mutex_unlock(&mxt->debug_mutex);\r
 635         }\r
 636 \r
 637         buf_start = buf;\r
 638         i = mxt->current_debug_datap;\r
 639 \r
 640         while (((buf- buf_start) < (count - 6)) && \r
 641                 (i < mxt->device_info.num_nodes)){\r
 642 \r
 643                 mxt->current_debug_datap++;\r
 644                 if (debug_command == MXT_CMD_T6_REFERENCES_MODE)\r
 645                         buf += sprintf(buf, "%d: %5d\n", i,\r
 646                                        (u16) le16_to_cpu(data[i]));\r
 647                 else if (debug_command == MXT_CMD_T6_DELTAS_MODE)\r
 648                         buf += sprintf(buf, "%d: %5d\n", i,\r
 649                                        (s16) le16_to_cpu(data[i]));\r
 650                 i++;\r
 651         }\r
 652 \r
 653         return (buf - buf_start);\r
 654 error:\r
 655         mutex_unlock(&mxt->debug_mutex);\r
 656         return error;\r
 657 }\r
 658 \r
 659 ssize_t deltas_read(struct file *file, char *buf, size_t count, loff_t *ppos)\r
 660 {\r
 661         return debug_data_read(file->private_data, buf, count, ppos, \r
 662                                MXT_CMD_T6_DELTAS_MODE);\r
 663 }\r
 664 \r
 665 ssize_t refs_read(struct file *file, char *buf, size_t count, \r
 666                         loff_t *ppos)\r
 667 {\r
 668         return debug_data_read(file->private_data, buf, count, ppos, \r
 669                                MXT_CMD_T6_REFERENCES_MODE);\r
 670 }\r
 671 \r
 672 int debug_data_open(struct inode *inode, struct file *file)\r
 673 {\r
 674         struct mxt_data *mxt;\r
 675         int i;\r
 676         mxt = inode->i_private;\r
 677         if (mxt == NULL)\r
 678                 return -EIO;\r
 679         mxt->current_debug_datap = 0;\r
 680         mxt->debug_data = kmalloc(mxt->device_info.num_nodes * sizeof(u16),\r
 681                                   GFP_KERNEL);\r
 682         if (mxt->debug_data == NULL)\r
 683                 return -ENOMEM;\r
 684 \r
 685         \r
 686         for (i = 0; i < mxt->device_info.num_nodes; i++)\r
 687                 mxt->debug_data[i] = 7777;\r
 688         \r
 689 \r
 690         file->private_data = mxt;\r
 691         return 0;\r
 692 }\r
 693 \r
 694 int debug_data_release(struct inode *inode, struct file *file)\r
 695 {\r
 696         struct mxt_data *mxt;\r
 697         mxt = file->private_data;\r
 698         kfree(mxt->debug_data);\r
 699         return 0;\r
 700 }\r
 701 \r
 702 static struct file_operations delta_fops = {\r
 703         .owner = THIS_MODULE,\r
 704         .open = debug_data_open,\r
 705         .release = debug_data_release,\r
 706         .read = deltas_read,\r
 707 };\r
 708 \r
 709 static struct file_operations refs_fops = {\r
 710         .owner = THIS_MODULE,\r
 711         .open = debug_data_open,\r
 712         .release = debug_data_release,\r
 713         .read = refs_read,\r
 714 };\r
 715 \r
 716 \r
 717 int mxt_memory_open(struct inode *inode, struct file *file)\r
 718 {\r
 719         struct mxt_data *mxt;\r
 720         mxt = container_of(inode->i_cdev, struct mxt_data, cdev);\r
 721         if (mxt == NULL)\r
 722                 return -EIO;\r
 723         file->private_data = mxt;\r
 724         return 0;\r
 725 }\r
 726 \r
 727 int mxt_message_open(struct inode *inode, struct file *file)\r
 728 {\r
 729         struct mxt_data *mxt;\r
 730         mxt = container_of(inode->i_cdev, struct mxt_data, cdev_messages);\r
 731         if (mxt == NULL)\r
 732                 return -EIO;\r
 733         file->private_data = mxt;\r
 734         return 0;\r
 735 }\r
 736 \r
 737 \r
 738 ssize_t mxt_memory_read(struct file *file, char *buf, size_t count, \r
 739                         loff_t *ppos)\r
 740 {\r
 741         int i;\r
 742         struct mxt_data *mxt;\r
 743 \r
 744         mxt = file->private_data;\r
 745         if (mxt->valid_ap){\r
 746                 MXT1386_LOG(KERN_INFO "Reading %d bytes from current ap\n", __func__,\r
 747                           (int) count);\r
 748                 i = mxt_read_block_wo_addr(mxt->client, count, (u8 *) buf);\r
 749         } else {\r
 750                 MXT1386_LOG(KERN_INFO "Address pointer changed since set;"\r
 751                           "writing AP (%d) before reading %d bytes", __func__, \r
 752                           mxt->address_pointer, (int) count);\r
 753                 i = mxt_read_block(mxt->client, mxt->address_pointer, count,\r
 754                                    buf);\r
 755         }\r
 756                         \r
 757         return i;\r
 758 }\r
 759 \r
 760 ssize_t mxt_memory_write(struct file *file, const char *buf, size_t count,\r
 761                          loff_t *ppos)\r
 762 {\r
 763         int i;\r
 764         int whole_blocks;\r
 765         int last_block_size;\r
 766         struct mxt_data *mxt;\r
 767         u16 address;\r
 768         \r
 769         mxt = file->private_data;\r
 770         address = mxt->address_pointer;\r
 771 \r
 772         MXT1386_LOG(KERN_INFO "mxt_memory_write entered\n", __func__);\r
 773         whole_blocks = count / I2C_PAYLOAD_SIZE;\r
 774         last_block_size = count % I2C_PAYLOAD_SIZE;\r
 775 \r
 776         for (i = 0; i < whole_blocks; i++) {\r
 777                 MXT1386_LOG(KERN_INFO "About to write to %d...\n", __func__, \r
 778                         address);\r
 779                 mxt_write_block(mxt->client, address, I2C_PAYLOAD_SIZE, \r
 780                                 (u8 *) buf);\r
 781                 address += I2C_PAYLOAD_SIZE;\r
 782                 buf += I2C_PAYLOAD_SIZE;\r
 783         }\r
 784 \r
 785         mxt_write_block(mxt->client, address, last_block_size, (u8 *) buf);\r
 786 \r
 787         return count;\r
 788 }\r
 789 \r
 790 \r
 791 #define MXT_SET_ADDRESS  0\r
 792 #define MXT_RESET  1\r
 793 #define MXT_CALIBRATE  2\r
 794 #define MXT_BACKUP  3\r
 795 #define MXT_NONTOUCH_MSG  4\r
 796 #define MXT_ALL_MSG  5\r
 797 \r
 798 static int mxt_ioctl(struct inode *inode, struct file *file,\r
 799                      unsigned int cmd, unsigned long arg)\r
 800 {\r
 801         int retval;\r
 802         struct mxt_data *mxt;\r
 803 \r
 804         retval = 0;\r
 805         mxt = file->private_data;\r
 806 \r
 807         switch (cmd) {\r
 808         case MXT_SET_ADDRESS:\r
 809                 retval = mxt_write_ap(mxt, (u16) arg);\r
 810                 if (retval >= 0) {\r
 811                         mxt->address_pointer = (u16) arg;\r
 812                         mxt->valid_ap = 1;\r
 813                 }\r
 814                 break;\r
 815         case MXT_RESET:\r
 816                 retval = mxt_write_byte(mxt->client,\r
 817                               MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +\r
 818                               MXT_ADR_T6_RESET,\r
 819                               1);\r
 820                 break;\r
 821         case MXT_CALIBRATE:\r
 822                 retval = mxt_write_byte(mxt->client,\r
 823                               MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +\r
 824                               MXT_ADR_T6_CALIBRATE,\r
 825                               1);\r
 826 \r
 827                 break;\r
 828         case MXT_BACKUP:\r
 829                 retval = mxt_write_byte(mxt->client,\r
 830                               MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +\r
 831                               MXT_ADR_T6_BACKUPNV,\r
 832                               MXT_CMD_T6_BACKUP);\r
 833                 break;\r
 834         case MXT_NONTOUCH_MSG:\r
 835                 mxt->nontouch_msg_only = 1;\r
 836                 break;\r
 837         case MXT_ALL_MSG:\r
 838                 mxt->nontouch_msg_only = 0;\r
 839                 break;\r
 840         default:\r
 841                 return -EIO;\r
 842         }\r
 843 \r
 844         return retval;\r
 845 } \r
 846 \r
 847 /*\r
 848  * Copies messages from buffer to user space.\r
 849  *\r
 850  * NOTE: if less than (mxt->message_size * 5 + 1) bytes requested,\r
 851  * this will return 0!\r
 852  * \r
 853  */\r
 854 ssize_t mxt_message_read(struct file *file, char *buf, size_t count, \r
 855                          loff_t *ppos)\r
 856 {\r
 857         int i;\r
 858         struct mxt_data *mxt;\r
 859         char *buf_start;\r
 860         \r
 861         mxt = file->private_data;\r
 862         if (mxt == NULL)\r
 863                 return -EIO;\r
 864         buf_start = buf;\r
 865 \r
 866         mutex_lock(&mxt->msg_mutex);\r
 867         /* Copy messages until buffer empty, or 'count' bytes written */\r
 868         while ((mxt->msg_buffer_startp != mxt->msg_buffer_endp) &&\r
 869                ((buf - buf_start) < (count - 5 * mxt->message_size - 1))){\r
 870 \r
 871                 for (i = 0; i < mxt->message_size; i++){\r
 872                         buf += sprintf(buf, "[%2X] ",\r
 873                                 *(mxt->messages + mxt->msg_buffer_endp *\r
 874                                         mxt->message_size + i));\r
 875                 }\r
 876                 buf += sprintf(buf, "\n");\r
 877                 if (mxt->msg_buffer_endp < MXT_MESSAGE_BUFFER_SIZE)\r
 878                         mxt->msg_buffer_endp++;\r
 879                 else\r
 880                         mxt->msg_buffer_endp = 0;\r
 881         }\r
 882         mutex_unlock(&mxt->msg_mutex);\r
 883         return (buf - buf_start);\r
 884 }\r
 885 \r
 886 static struct file_operations mxt_message_fops = {\r
 887         .owner = THIS_MODULE,\r
 888         .open = mxt_message_open,\r
 889         .read = mxt_message_read,\r
 890 };\r
 891 \r
 892 static struct file_operations mxt_memory_fops = {\r
 893         .owner = THIS_MODULE,\r
 894         .open = mxt_memory_open,\r
 895         .read = mxt_memory_read,\r
 896         .write = mxt_memory_write,\r
 897         .ioctl = mxt_ioctl,\r
 898 };\r
 899 \r
 900 \r
 901 /* Writes the address pointer (to set up following reads). */\r
 902 \r
 903 int mxt_write_ap(struct mxt_data *mxt, u16 ap)\r
 904 {\r
 905         struct i2c_client *client;\r
 906         __le16  le_ap = cpu_to_le16(ap);\r
 907         client = mxt->client;\r
 908         if (mxt != NULL)\r
 909                 mxt->last_read_addr = -1;\r
 910         if (i2c_master_send(client, (u8 *) &le_ap, 2) == 2) {\r
 911                 MXT1386_LOG(KERN_INFO "Address pointer set to %d\n", __func__, ap);\r
 912                 return 0;\r
 913         } else {\r
 914                 MXT1386_LOG(KERN_INFO "Error writing address pointer!\n", __func__);\r
 915                 return -EIO;\r
 916         }\r
 917 }\r
 918 \r
 919 /* Calculates the 24-bit CRC sum. */\r
 920 static u32 CRC_24(u32 crc, u8 byte1, u8 byte2)\r
 921 {\r
 922         static const u32 crcpoly = 0x80001B;\r
 923         u32 result;\r
 924         u32 data_word;\r
 925 \r
 926         data_word = ((((u16) byte2) << 8u) | byte1);\r
 927         result = ((crc << 1u) ^ data_word);\r
 928         if (result & 0x1000000)\r
 929                 result ^= crcpoly;\r
 930         return result;\r
 931 }\r
 932 \r
 933 /* Returns object address in mXT chip, or zero if object is not found */\r
 934 static u16 get_object_address(uint8_t object_type,\r
 935                               uint8_t instance,\r
 936                               struct mxt_object *object_table,\r
 937                               int max_objs)\r
 938 {\r
 939         uint8_t object_table_index = 0;\r
 940         uint8_t address_found = 0;\r
 941         uint16_t address = 0;\r
 942         struct mxt_object *obj;\r
 943 \r
 944         while ((object_table_index < max_objs) && !address_found) {\r
 945                 obj = &object_table[object_table_index];\r
 946                 if (obj->type == object_type) {\r
 947                         address_found = 1;\r
 948                         /* Are there enough instances defined in the FW? */\r
 949                         if (obj->instances >= instance) {\r
 950                                 address = obj->chip_addr +\r
 951                                           (obj->size + 1) * instance;\r
 952                         } else {\r
 953                                 return 0;\r
 954                         }\r
 955                 }\r
 956                 object_table_index++;\r
 957         }\r
 958         return address;\r
 959 }\r
 960 \r
 961 \r
 962 /*\r
 963  * Reads a block of bytes from given address from mXT chip. If we are\r
 964  * reading from message window, and previous read was from message window,\r
 965  * there's no need to write the address pointer: the mXT chip will\r
 966  * automatically set the address pointer back to message window start.\r
 967  */\r
 968 \r
 969 static int mxt_read_block(struct i2c_client *client,\r
 970                    u16 addr,\r
 971                    u16 length,\r
 972                    u8 *value)\r
 973 {\r
 974         struct i2c_adapter *adapter = client->adapter;\r
 975         struct i2c_msg msg[2];\r
 976         __le16  le_addr;\r
 977         struct mxt_data *mxt;\r
 978 \r
 979         mxt = i2c_get_clientdata(client);       \r
 980         \r
 981         if (mxt != NULL) {\r
 982                 MXT1386_LOG(KERN_INFO "%s: msg addr test, mxt->msg_proc_addr = 0x%x, mxt->last_read_addr = 0x%x, current addr = 0x%x\n", \r
 983                 __func__, mxt->msg_proc_addr, mxt->last_read_addr, addr);\r
 984                 \r
 985                 if ((mxt->last_read_addr == addr) &&\r
 986                         (addr == mxt->msg_proc_addr)) {\r
 987                         if (i2c_master_recv(client, value, length) == length) {\r
 988                                 MXT1386_LOG(KERN_INFO "%s: Host is reading from chip, addr = 0x%x, length = %d, *value = %d\n", \r
 989                                         __func__, addr, length, *value);\r
 990                                 return length;\r
 991                         }                               \r
 992                         else {\r
 993                                 MXT1386_LOG(KERN_INFO "%s: Host read failed!\n", __func__);\r
 994                                 return -EIO;\r
 995                         }                               \r
 996                 } else {\r
 997                         mxt->last_read_addr = addr;\r
 998                 }\r
 999         }\r
1000 \r
1001         le_addr = cpu_to_le16(addr);\r
1002         MXT1386_LOG(KERN_INFO "%s: Writing address pointer & reading, addr = 0x%02x, , le_addr = 0x%02x, length = %d, *value = %d\n", \r
1003                         __func__, addr, le_addr, length, *value);\r
1004         \r
1005         msg[0].addr  = client->addr;\r
1006         msg[0].flags = 0x00;\r
1007         msg[0].len   = 2;\r
1008         msg[0].buf   = (u8 *) &le_addr;\r
1009 \r
1010         msg[1].addr  = client->addr;\r
1011         msg[1].flags = I2C_M_RD;\r
1012         msg[1].len   = length;\r
1013         msg[1].buf   = (u8 *) value;\r
1014         if  (i2c_transfer(adapter, msg, 2) == 2)\r
1015                 return length;\r
1016         else\r
1017                 return -EIO;\r
1018 }\r
1019 \r
1020 /* Reads a block of bytes from current address from mXT chip. */\r
1021 static int mxt_read_block_wo_addr(struct i2c_client *client,\r
1022                            u16 length,\r
1023                            u8 *value)\r
1024 {\r
1025         if  (i2c_master_recv(client, value, length) == length) {\r
1026                 MXT1386_LOG(KERN_INFO "%s: I2C block read ok\n", __func__);\r
1027                 return length;\r
1028         } else {\r
1029                 MXT1386_LOG(KERN_INFO "%s: I2C block read failed\n", __func__);\r
1030                 return -EIO;\r
1031         }\r
1032 }\r
1033 \r
1034 /* Writes one byte to given address in mXT chip. */\r
1035 static int mxt_write_byte(struct i2c_client *client, u16 addr, u8 value)\r
1036 {\r
1037         struct {\r
1038                 __le16 le_addr;\r
1039                 u8 data;\r
1040 \r
1041         } i2c_byte_transfer;\r
1042 \r
1043         struct mxt_data *mxt;\r
1044 \r
1045         mxt = i2c_get_clientdata(client);\r
1046         if (mxt != NULL)\r
1047                 mxt->last_read_addr = -1;\r
1048         i2c_byte_transfer.le_addr = cpu_to_le16(addr);\r
1049         i2c_byte_transfer.data = value;\r
1050         if  (i2c_master_send(client, (u8 *) &i2c_byte_transfer, 3) == 3)\r
1051                 return 0;\r
1052         else\r
1053                 return -EIO;\r
1054 }\r
1055 \r
1056 /* Writes a block of bytes (max 256) to given address in mXT chip. */\r
1057 static int mxt_write_block(struct i2c_client *client,\r
1058                     u16 addr,\r
1059                     u16 length,\r
1060                     u8 *value)\r
1061 {\r
1062         int i;\r
1063         struct {\r
1064                 __le16  le_addr;\r
1065                 u8      data[256];\r
1066 \r
1067         } i2c_block_transfer;\r
1068 \r
1069         struct mxt_data *mxt;\r
1070 \r
1071         MXT1386_LOG("Writing %d bytes to %d...\n", length, addr);\r
1072         if (length > 256)\r
1073                 return -EINVAL;\r
1074         mxt = i2c_get_clientdata(client);\r
1075         if (mxt != NULL)\r
1076                 mxt->last_read_addr = -1;\r
1077         for (i = 0; i < length; i++)\r
1078                 i2c_block_transfer.data[i] = *value++;\r
1079         i2c_block_transfer.le_addr = cpu_to_le16(addr);\r
1080         i = i2c_master_send(client, (u8 *) &i2c_block_transfer, length + 2);\r
1081         if (i == (length + 2))\r
1082                 return length;\r
1083         else\r
1084                 return -EIO;\r
1085 }\r
1086 \r
1087 /* Calculates the CRC value for mXT infoblock. */\r
1088 int calculate_infoblock_crc(u32 *crc_result, u8 *data, int crc_area_size)\r
1089 {\r
1090         u32 crc = 0;\r
1091         int i;\r
1092 \r
1093         for (i = 0; i < (crc_area_size - 1); i = i + 2)\r
1094                 crc = CRC_24(crc, *(data + i), *(data + i + 1));\r
1095         /* If uneven size, pad with zero */\r
1096         if (crc_area_size & 0x0001)\r
1097                 crc = CRC_24(crc, *(data + i), 0);\r
1098         /* Return only 24 bits of CRC. */\r
1099         *crc_result = (crc & 0x00FFFFFF);\r
1100 \r
1101         return 0;\r
1102 }\r
1103 \r
1104 int find_touch_key_value( struct mxt_data *mxt, int status, u16 ypos)\r
1105 {\r
1106     int i = 0;\r
1107     for(i=0; i<ARRAY_SIZE(key_info); i++)\r
1108     {\r
1109         if((ypos > key_info[i].start) && (ypos < key_info[i].end))\r
1110         {          \r
1111            printk("%s key_code = %d \n",__func__,key_info[i].code);\r
1112             if(status & MXT_MSGB_T9_DETECT)\r
1113             {\r
1114                 input_report_key(mxt->input, key_info[i].code, 1);\r
1115                 input_sync(mxt->input);\r
1116                 last_key = key_info[i].code;\r
1117             }\r
1118             else\r
1119             {\r
1120                 printk("%s key_code = %d relase\n",__func__,key_info[i].code);\r
1121                 input_report_key(mxt->input, key_info[i].code, 0);\r
1122                 input_sync(mxt->input);\r
1123                 last_key = 0;\r
1124 \r
1125             }           \r
1126             break;\r
1127         }\r
1128     }\r
1129    \r
1130 \r
1131     return 0;    \r
1132 }\r
1133 \r
1134 \r
1135 void process_T9_message(u8 *message, struct mxt_data *mxt)\r
1136 {\r
1137         struct  input_dev *input;\r
1138         u8  status;\r
1139         u16 xpos = 0xFFFF;\r
1140         u16 ypos = 0xFFFF;\r
1141         u8  touch_size = 255;\r
1142         u8  touch_number;\r
1143         u8  amplitude;\r
1144         u8  report_id;\r
1145     u32 key_code = 0;\r
1146     \r
1147         input = mxt->input;\r
1148         status = message[MXT_MSG_T9_STATUS];\r
1149         report_id = message[0];\r
1150 \r
1151         if (status & MXT_MSGB_T9_SUPPRESS) {\r
1152                 /* Touch has been suppressed by grip/face */\r
1153                 /* detection                              */\r
1154                 MXT1386_LOG(KERN_INFO "SUPRESS\n", __func__);\r
1155         } else {\r
1156                 MXT1386_LOG("XPOSMSB = 0x%02x, YPOSMSB = 0x%02x, XYPOSLSB = 0x%02x\n",\r
1157                         message[MXT_MSG_T9_XPOSMSB], message[MXT_MSG_T9_YPOSMSB], message[MXT_MSG_T9_XYPOSLSB]);\r
1158                 \r
1159                 xpos = message[MXT_MSG_T9_XPOSMSB] * 16 +\r
1160                         ((message[MXT_MSG_T9_XYPOSLSB] >> 4) & 0xF);\r
1161                 ypos = message[MXT_MSG_T9_YPOSMSB] * 16 +\r
1162                         ((message[MXT_MSG_T9_XYPOSLSB] >> 0) & 0xF);\r
1163 \r
1164                 MXT1386_LOG("Before Reverse: xpos = %d, ypos = %d\n", xpos, ypos);\r
1165                 #if 0 //xhh\r
1166                 //µßµ¹X×ø±ê\r
1167                 if( xpos < CONFIG_ATMEL_MXT1386_MAX_X)\r
1168                         xpos = CONFIG_ATMEL_MXT1386_MAX_X - xpos;\r
1169                 else\r
1170                         xpos = 0;\r
1171 \r
1172                 //µßµ¹Y×ø±ê\r
1173                 if( ypos < CONFIG_ATMEL_MXT1386_MAX_Y)\r
1174                         ypos = CONFIG_ATMEL_MXT1386_MAX_Y - ypos;\r
1175                 else\r
1176                         ypos = 0;\r
1177                 #endif\r
1178         \r
1179         #if TOUCH_KEY_EN\r
1180                 if( xpos < 8 && xpos >= 0)\r
1181                 {\r
1182             find_touch_key_value(mxt, status, ypos); \r
1183             return;\r
1184         } \r
1185         else if(last_key)\r
1186         {\r
1187             \r
1188             printk("%s key_code = %d relase\n",__func__,last_key);\r
1189             input_report_key(mxt->input, last_key, 0);\r
1190             input_sync(mxt->input);\r
1191             last_key = 0;  \r
1192         }\r
1193                 #endif  \r
1194         \r
1195                 MXT1386_LOG("After Reverse: xpos = %d, ypos = %d\n", xpos, ypos);\r
1196 \r
1197                 touch_number = message[MXT_MSG_REPORTID] -\r
1198                         mxt->rid_map[report_id].first_rid;\r
1199 \r
1200                 if (status & MXT_MSGB_T9_DETECT) {\r
1201                         /*\r
1202                          * TODO: more precise touch size calculation?\r
1203                          * mXT224 reports the number of touched nodes,\r
1204                          * so the exact value for touch ellipse major\r
1205                          * axis length would be 2*sqrt(touch_size/pi)\r
1206                          * (assuming round touch shape).\r
1207                          */\r
1208                         MXT1386_LOG(KERN_INFO " ----process_T9_message --MXT_MSGB_T9_DETECT--- \n", __func__);\r
1209                         touch_size = message[MXT_MSG_T9_TCHAREA];\r
1210                         touch_size = touch_size >> 2;\r
1211                         if (!touch_size)\r
1212                                 touch_size = 1;\r
1213                         report_mt(touch_number, touch_size, xpos, ypos, mxt);\r
1214                         if (status & MXT_MSGB_T9_AMP)\r
1215                                 /* Amplitude of touch has changed */\r
1216                                 amplitude = message[MXT_MSG_T9_TCHAMPLITUDE];\r
1217                 } else if (status & MXT_MSGB_T9_RELEASE) {\r
1218                         /* The previously reported touch has been removed.*/\r
1219                         MXT1386_LOG(KERN_INFO " ----process_T9_message --MXT_MSGB_T9_RELEASE--- \n", __func__);\r
1220                         report_mt(touch_number, 0, xpos, ypos, mxt);\r
1221                 }\r
1222                 #ifdef EFFICIENT_REPORT\r
1223                 #else\r
1224                 report_sync(mxt);\r
1225                 #endif\r
1226         }\r
1227         \r
1228         if (status & MXT_MSGB_T9_SUPPRESS) {\r
1229                 MXT1386_LOG(KERN_INFO "SUPRESS", __func__);\r
1230         } else {\r
1231                 if (status & MXT_MSGB_T9_DETECT) {\r
1232                         MXT1386_LOG(KERN_INFO "DETECT:%s%s%s%s", __func__, \r
1233                                 ((status & MXT_MSGB_T9_PRESS) ? " PRESS" : ""), \r
1234                                 ((status & MXT_MSGB_T9_MOVE) ? " MOVE" : ""), \r
1235                                 ((status & MXT_MSGB_T9_AMP) ? " AMP" : ""), \r
1236                                 ((status & MXT_MSGB_T9_VECTOR) ? " VECT" : ""));\r
1237 \r
1238                 } else if (status & MXT_MSGB_T9_RELEASE) {\r
1239                         MXT1386_LOG(KERN_INFO "RELEASE");\r
1240                 }\r
1241         }\r
1242         MXT1386_LOG(KERN_INFO "X=%d, Y=%d, TOUCHSIZE=%d", __func__,\r
1243                 xpos, ypos, touch_size);\r
1244 \r
1245         return;\r
1246 }\r
1247 \r
1248 int process_message(u8 *message, u8 object, struct mxt_data *mxt)\r
1249 {\r
1250         struct i2c_client *client;\r
1251         u8  status;\r
1252         u16 xpos = 0xFFFF;\r
1253         u16 ypos = 0xFFFF;\r
1254         u8  event;\r
1255         u8  direction;\r
1256         u16 distance;\r
1257         u8  length;\r
1258         u8  report_id;\r
1259     int  keyIndex;\r
1260 \r
1261         client = mxt->client;\r
1262         length = mxt->message_size;\r
1263         report_id = message[0];\r
1264 \r
1265         if ((mxt->nontouch_msg_only == 0) ||\r
1266             (!IS_TOUCH_OBJECT(object))){\r
1267                 mutex_lock(&mxt->msg_mutex);\r
1268                 /* Copy the message to buffer */\r
1269                 if (mxt->msg_buffer_startp < MXT_MESSAGE_BUFFER_SIZE) {\r
1270                         mxt->msg_buffer_startp++;\r
1271                 } else {\r
1272                         mxt->msg_buffer_startp = 0;\r
1273                 }\r
1274                 \r
1275                 if (mxt->msg_buffer_startp == mxt->msg_buffer_endp) {\r
1276                         MXT1386_LOG(KERN_INFO "Message buf full, discarding last entry.\n", __func__);\r
1277                         if (mxt->msg_buffer_endp < MXT_MESSAGE_BUFFER_SIZE) {\r
1278                                 mxt->msg_buffer_endp++;\r
1279                         } else {\r
1280                                 mxt->msg_buffer_endp = 0;\r
1281                         }\r
1282                 }\r
1283                 memcpy((mxt->messages + mxt->msg_buffer_startp * length), \r
1284                        message,\r
1285                        length);\r
1286                 mutex_unlock(&mxt->msg_mutex);\r
1287         }\r
1288 \r
1289         switch (object) {\r
1290         case MXT_GEN_COMMANDPROCESSOR_T6:\r
1291                 status = message[1];\r
1292                 if (status & MXT_MSGB_T6_COMSERR) {\r
1293                         dev_err(&client->dev,\r
1294                                 "maXTouch checksum error\n");\r
1295                 }\r
1296                 if (status & MXT_MSGB_T6_CFGERR) {\r
1297                         /* \r
1298                          * Configuration error. A proper configuration\r
1299                          * needs to be written to chip and backed up. Refer\r
1300                          * to protocol document for further info.\r
1301                          */\r
1302                         dev_err(&client->dev,\r
1303                                 "maXTouch configuration error\n");\r
1304                 }\r
1305                 if (status & MXT_MSGB_T6_CAL) {\r
1306                         /* Calibration in action, no need to react */\r
1307                         dev_info(&client->dev,\r
1308                                 "maXTouch calibration in progress\n");\r
1309                 }\r
1310                 if (status & MXT_MSGB_T6_SIGERR) {\r
1311                         /* \r
1312                          * Signal acquisition error, something is seriously\r
1313                          * wrong, not much we can in the driver to correct\r
1314                          * this\r
1315                          */\r
1316                         dev_err(&client->dev,\r
1317                                 "maXTouch acquisition error\n");\r
1318                 }\r
1319                 if (status & MXT_MSGB_T6_OFL) {\r
1320                         /*\r
1321                          * Cycle overflow, the acquisition is too short.\r
1322                          * Can happen temporarily when there's a complex\r
1323                          * touch shape on the screen requiring lots of\r
1324                          * processing.\r
1325                          */\r
1326                         dev_err(&client->dev,\r
1327                                 "maXTouch cycle overflow\n");\r
1328                 }\r
1329                 if (status & MXT_MSGB_T6_RESET) {\r
1330                         /* Chip has reseted, no need to react. */\r
1331                         dev_info(&client->dev,\r
1332                                 "maXTouch chip reset\n");\r
1333                 }\r
1334                 if (status == 0) {\r
1335                         /* Chip status back to normal. */\r
1336                         dev_info(&client->dev,\r
1337                                 "maXTouch status normal\n");\r
1338                 }\r
1339                 break;\r
1340 \r
1341         case MXT_TOUCH_MULTITOUCHSCREEN_T9:\r
1342                 process_T9_message(message, mxt);\r
1343                 break;\r
1344 \r
1345         case MXT_SPT_GPIOPWM_T19:\r
1346                 if (debug >= DEBUG_TRACE)\r
1347                         dev_info(&client->dev,\r
1348                                 "Receiving GPIO message\n");\r
1349                 break;\r
1350 \r
1351         case MXT_PROCI_GRIPFACESUPPRESSION_T20:\r
1352                 if (debug >= DEBUG_TRACE)\r
1353                         dev_info(&client->dev,\r
1354                                 "Receiving face suppression msg\n");\r
1355                 break;\r
1356 \r
1357         case MXT_PROCG_NOISESUPPRESSION_T22:\r
1358                 printk("--------- MXT_PROCG_NOISESUPPRESSION_T22 enter! ---------\n");\r
1359                 //if (debug >= DEBUG_TRACE)\r
1360                         dev_info(&client->dev,\r
1361                                 "Receiving noise suppression msg\n");\r
1362                 status = message[MXT_MSG_T22_STATUS];\r
1363                 if (status & MXT_MSGB_T22_FHCHG) {\r
1364                         //if (debug >= DEBUG_TRACE)\r
1365                                 dev_info(&client->dev,\r
1366                                         "maXTouch: Freq changed\n");\r
1367                 }\r
1368                 if (status & MXT_MSGB_T22_GCAFERR) {\r
1369                         //if (debug >= DEBUG_TRACE)\r
1370                                 dev_info(&client->dev,\r
1371                                         "maXTouch: High noise "\r
1372                                         "level\n");\r
1373                 }\r
1374                 if (status & MXT_MSGB_T22_FHERR) {\r
1375                         //if (debug >= DEBUG_TRACE)\r
1376                                 dev_info(&client->dev,\r
1377                                         "maXTouch: Freq changed - "\r
1378                                         "Noise level too high\n");\r
1379                 }\r
1380                 break;\r
1381 \r
1382         case MXT_PROCI_ONETOUCHGESTUREPROCESSOR_T24:\r
1383                 if (debug >= DEBUG_TRACE)\r
1384                         dev_info(&client->dev,\r
1385                                 "Receiving one-touch gesture msg\n");\r
1386 \r
1387                 event = message[MXT_MSG_T24_STATUS] & 0x0F;\r
1388                 xpos = message[MXT_MSG_T24_XPOSMSB] * 16 +\r
1389                         ((message[MXT_MSG_T24_XYPOSLSB] >> 4) & 0x0F);\r
1390                 ypos = message[MXT_MSG_T24_YPOSMSB] * 16 +\r
1391                         ((message[MXT_MSG_T24_XYPOSLSB] >> 0) & 0x0F);\r
1392                 xpos >>= 2;\r
1393                 ypos >>= 2;\r
1394                 direction = message[MXT_MSG_T24_DIR];\r
1395                 distance = message[MXT_MSG_T24_DIST] +\r
1396                            (message[MXT_MSG_T24_DIST + 1] << 16);\r
1397 \r
1398                 report_gesture((event << 24) | (direction << 16) | distance,\r
1399                         mxt);\r
1400                 report_gesture((xpos << 16) | ypos, mxt);\r
1401 \r
1402                 break;\r
1403 \r
1404         case MXT_SPT_SELFTEST_T25:\r
1405                 if (debug >= DEBUG_TRACE)\r
1406                         dev_info(&client->dev,\r
1407                                 "Receiving Self-Test msg\n");\r
1408 \r
1409                 if (message[MXT_MSG_T25_STATUS] == MXT_MSGR_T25_OK) {\r
1410                         if (debug >= DEBUG_TRACE)\r
1411                                 dev_info(&client->dev,\r
1412                                         "maXTouch: Self-Test OK\n");\r
1413 \r
1414                 } else  {\r
1415                         dev_err(&client->dev,\r
1416                                 "maXTouch: Self-Test Failed [%02x]:"\r
1417                                 "{%02x,%02x,%02x,%02x,%02x}\n",\r
1418                                 message[MXT_MSG_T25_STATUS],\r
1419                                 message[MXT_MSG_T25_STATUS + 0],\r
1420                                 message[MXT_MSG_T25_STATUS + 1],\r
1421                                 message[MXT_MSG_T25_STATUS + 2],\r
1422                                 message[MXT_MSG_T25_STATUS + 3],\r
1423                                 message[MXT_MSG_T25_STATUS + 4]\r
1424                                 );\r
1425                 }\r
1426                 break;\r
1427 \r
1428         case MXT_PROCI_TWOTOUCHGESTUREPROCESSOR_T27:\r
1429                 if (debug >= DEBUG_TRACE)\r
1430                         dev_info(&client->dev,\r
1431                                 "Receiving 2-touch gesture message\n");\r
1432 \r
1433                 event = message[MXT_MSG_T27_STATUS] & 0xF0;\r
1434                 xpos = message[MXT_MSG_T27_XPOSMSB] * 16 +\r
1435                         ((message[MXT_MSG_T27_XYPOSLSB] >> 4) & 0x0F);\r
1436                 ypos = message[MXT_MSG_T27_YPOSMSB] * 16 +\r
1437                         ((message[MXT_MSG_T27_XYPOSLSB] >> 0) & 0x0F);\r
1438                 xpos >>= 2;\r
1439                 ypos >>= 2;\r
1440                 direction = message[MXT_MSG_T27_ANGLE];\r
1441                 distance = message[MXT_MSG_T27_SEPARATION] +\r
1442                            (message[MXT_MSG_T27_SEPARATION + 1] << 16);\r
1443 \r
1444                 report_gesture((event << 24) | (direction << 16) | distance,\r
1445                         mxt);\r
1446                 report_gesture((xpos << 16) | ypos, mxt);\r
1447 \r
1448 \r
1449                 break;\r
1450 \r
1451         case MXT_SPT_CTECONFIG_T28:\r
1452                 if (debug >= DEBUG_TRACE)\r
1453                         dev_info(&client->dev,\r
1454                                 "Receiving CTE message...\n");\r
1455                 status = message[MXT_MSG_T28_STATUS];\r
1456                 if (status & MXT_MSGB_T28_CHKERR)\r
1457                         dev_err(&client->dev,\r
1458                                 "maXTouch: Power-Up CRC failure\n");\r
1459 \r
1460                 break;\r
1461         \r
1462         default:\r
1463                 if (debug >= DEBUG_TRACE)\r
1464                         dev_info(&client->dev,\r
1465                                 "maXTouch: Unknown message!\n");\r
1466 \r
1467                 break;\r
1468         }\r
1469 \r
1470         return 0;\r
1471 }\r
1472 \r
1473 \r
1474 /*\r
1475  * Processes messages when the interrupt line (CHG) is asserted. Keeps\r
1476  * reading messages until a message with report ID 0xFF is received,\r
1477  * which indicates that there is no more new messages.\r
1478  *\r
1479  */\r
1480 \r
1481 static void ts_thread_1386(struct work_struct *work)\r
1482 {\r
1483         struct  mxt_data *mxt;\r
1484         struct  i2c_client *client;\r
1485 \r
1486         u8      *message;\r
1487         u16     message_length;\r
1488         u16     message_addr;\r
1489         u8      report_id = 0;\r
1490         u8      object = 0;\r
1491         #ifdef EFFICIENT_REPORT\r
1492         u8      has_multitouch_msg = 0;\r
1493         #endif\r
1494         int     error;\r
1495         int     i;\r
1496         char    *message_string;\r
1497         char    *message_start;\r
1498         static u32 count;\r
1499 \r
1500         message = NULL;\r
1501         //mxt = container_of(work, struct mxt_data, dwork.work);\r
1502         mxt = atmel_mxt;\r
1503         //disable_irq(mxt->irq);\r
1504         client = mxt->client;\r
1505         message_addr =  mxt->msg_proc_addr;\r
1506         message_length = mxt->message_size;\r
1507 \r
1508         MXT1386_LOG(KERN_INFO "%s: ts_thread_1386 entry %d times!\n", __func__, ++count);\r
1509 \r
1510         if (message_length < 256) {\r
1511                 message = kmalloc(message_length, GFP_KERNEL);\r
1512                 if (message == NULL) {\r
1513                         dev_err(&client->dev, "Error allocating memory\n");\r
1514                         return;\r
1515                 }\r
1516         } else {\r
1517                 dev_err(&client->dev,\r
1518                         "Message length larger than 256 bytes not supported\n");\r
1519                 return;\r
1520         }\r
1521 \r
1522         do {\r
1523                 /* Read next message, reread on failure. */\r
1524                 mxt->message_counter++;\r
1525                 for (i = 1; i < I2C_RETRY_COUNT; i++) {\r
1526                         error = mxt_read_block(client,\r
1527                                                message_addr,\r
1528                                                message_length,\r
1529                                                message);\r
1530                         if (error >= 0)\r
1531                                 break;\r
1532                         mxt->read_fail_counter++;\r
1533                         dev_err(&client->dev,\r
1534                                 "Failure reading maxTouch device\n");\r
1535                 }\r
1536                 if (error < 0) {\r
1537                         kfree(message);\r
1538                         return;\r
1539                 }\r
1540                 \r
1541                 if (mxt->address_pointer != message_addr)\r
1542                         mxt->valid_ap = 0;\r
1543                 report_id = message[0];\r
1544 \r
1545                 if (debug >= DEBUG_RAW) {\r
1546                         MXT1386_LOG(KERN_INFO "%s: %s message [msg count: %08x]:", __func__,\r
1547                                   REPORT_ID_TO_OBJECT_NAME(report_id, mxt),\r
1548                                   mxt->message_counter\r
1549                         );\r
1550                         /* 5 characters per one byte */\r
1551                         message_string = kmalloc(message_length * 5, \r
1552                                                  GFP_KERNEL);\r
1553                         if (message_string == NULL) {\r
1554                                 dev_err(&client->dev, \r
1555                                         "Error allocating memory\n");\r
1556                                 kfree(message);\r
1557                                 return;\r
1558                         }\r
1559                         message_start = message_string;\r
1560                         for (i = 0; i < message_length; i++) {\r
1561                                 message_string += \r
1562                                         sprintf(message_string, \r
1563                                                 "0x%02X ", message[i]);\r
1564                         }\r
1565                         MXT1386_LOG(KERN_INFO "%s", message_start, __func__);\r
1566                         kfree(message_start);\r
1567                 }\r
1568 \r
1569                 if ((report_id != MXT_END_OF_MESSAGES) && (report_id != 0)) {\r
1570                         memcpy(mxt->last_message, message, message_length);\r
1571                         mxt->new_msgs = 1;\r
1572                         smp_wmb();\r
1573                         /* Get type of object and process the message */\r
1574                         object = mxt->rid_map[report_id].object;\r
1575                         \r
1576                         MXT1386_LOG(KERN_INFO "current value: mxt->rid_map[%d].object = %d, object = %d\n",\r
1577                                 __func__, report_id, mxt->rid_map[report_id].object, object);\r
1578                         mxt_buf_test(message, message_length);\r
1579                         \r
1580                         process_message(message, object, mxt);\r
1581                         MXT1386_LOG(KERN_INFO "trace 0\n", __func__);\r
1582                 }\r
1583                 \r
1584                 #ifdef EFFICIENT_REPORT\r
1585                 if(object == MXT_TOUCH_MULTITOUCHSCREEN_T9)\r
1586                 {\r
1587                         has_multitouch_msg = 1;\r
1588                 }\r
1589                 else if( has_multitouch_msg == 1)\r
1590                 {\r
1591                         has_multitouch_msg = 0;\r
1592                         report_sync(mxt);\r
1593                 }\r
1594                 object = 0;\r
1595                 #endif          \r
1596 \r
1597         } while (comms ? (mxt->read_chg() == 0) : \r
1598                 ((report_id != MXT_END_OF_MESSAGES) && (report_id != 0)));\r
1599         //} while ((report_id != MXT_END_OF_MESSAGES) && (report_id != 0));\r
1600 \r
1601         /*\r
1602         #ifdef EFFICIENT_REPORT\r
1603         report_sync(mxt);\r
1604         #endif\r
1605         */\r
1606         \r
1607         kfree(message);\r
1608 \r
1609         MXT1386_LOG(KERN_INFO "%s: Now will enable the irq, ts_irq = %d\n", __func__, ts_irq);\r
1610         enable_irq(mxt->irq);\r
1611     //printk("%s, int_pin = %d \n",__func__,gpio_get_value(client->irq));\r
1612 }\r
1613 \r
1614 /*\r
1615  * The maXTouch device will signal the host about a new message by asserting\r
1616  * the CHG line. This ISR schedules a worker routine to read the message when\r
1617  * that happens.\r
1618  */\r
1619  \r
1620 //static struct workqueue_struct *queue = NULL;\r
1621 //static struct work_struct work;\r
1622 \r
1623 static irqreturn_t mxt_irq_handler(int irq, void *dev_id)\r
1624 {       \r
1625         struct mxt_data *mxt = (struct mxt_data *)dev_id;\r
1626     struct i2c_client *client = mxt->client;\r
1627         int int_value = client->irq;\r
1628         static u8 wakeup_flag;\r
1629         static u32 counter;\r
1630         /* Ä¿Ç°TPµÄÖÐ¶ÏÐÐÎªÈçÏÂ: µ±LCD½øÈëstandbyÄ£Ê½ºó£¬±³¹â¿ØÖÆ½ÅLCDC_CS½«ÀµÍ£¬´ËÊ±LCDC_CS¿ØÖÆµÄ±³¹âÉýÑ¹ÊäÈë¶Ë£¨DCtoDCÊäÈë¶Ë£©TPVCCÒ²½«±»ÀµÍ£¬\r
1631         Ê¹±³¹â¹Ø±Õ£»ÓÉÓÚTPVCCÍ¬Ê±Ò²×÷ÎªTPµÄµçÔ´ÊäÈë¶Ë£¬´ËÊ±ÏµÍ³ÈôÔÚTPVCCÎªµÍµçÆ½µÄÇé¿öÏÂ½øÈëTPµÄISRº¯Êý£¬TPÉè±¸½«²»Ó¦´ð£¬²¢ÇÒ½«²»±»»½ÐÑ¡£ Òò´Ë£¬\r
1632         ÔÚ´ËÔö¼ÓÒ»¸ö¾²Ì¬±êÖ¾£¬ÅÐ¶Ïµ±LCDS½ÅÎªµÍÊ±£¬²»Æô¶¯¹¤×÷¶ÓÁÐ£¬Í¬Ê±½«wakeup_flag±êÖ¾ÖÃ1£¬ÏÂ´Î½øÈëÖÐ¶ÏÊ±£¬²»ÔÙ½ûÖ¹ÖÐ¶Ï£¬Ö±½ÓÆô¶¯¹¤×÷¶ÓÁÐ*/\r
1633         \r
1634 #if 0\r
1635         MXT1386_LOG(KERN_INFO "mxt_irq_handler() IN\n");\r
1636 \r
1637         mxt->irq_counter++;\r
1638         if (mxt->valid_interrupt()) {\r
1639                 /* Send the signal only if falling edge generated the irq. */\r
1640                 cancel_delayed_work(&mxt->dwork);\r
1641                 schedule_delayed_work(&mxt->dwork, 0);\r
1642                 mxt->valid_irq_counter++;\r
1643         } else {\r
1644                 mxt->invalid_irq_counter++;\r
1645                 return IRQ_NONE;\r
1646         }\r
1647 \r
1648         MXT1386_LOG(KERN_INFO "-------------- Be carefull MXC_touchscreen interrupt comes! --------------\n", __func__);\r
1649         MXT1386_LOG(KERN_INFO "interrupt counter road\n");\r
1650         disable_irq_nosync(mxt->irq);\r
1651 \r
1652         queue_work(mxt->queue,&mxt->work);\r
1653         \r
1654 #else\r
1655 \r
1656         MXT1386_LOG(KERN_INFO "-------------- Be carefull MXC_touchscreen interrupt comes! --------------\n", __func__);\r
1657         MXT1386_LOG(KERN_INFO "ts_irq = %d, irq = %d, mxt->irq = %d, TOUCH_INT_PIN = %d\n", __func__, ts_irq, irq, mxt->irq, int_value);\r
1658 \r
1659         if(gpio_get_value(LCDC_STANDBY_PIN)) {\r
1660                 MXT1386_LOG(KERN_INFO "%s: LCDC_STANDBY_PIN test, value is high\n", __func__);\r
1661 \r
1662                 if (0==wakeup_flag) {\r
1663                         disable_irq_nosync(mxt->irq);\r
1664                 }\r
1665                 else {\r
1666                         wakeup_flag = 0;\r
1667                 }\r
1668                 \r
1669 #if WORKQ_RIGHTNOW\r
1670                 MXT1386_LOG(KERN_INFO "%s: queue_work start\n", __func__);\r
1671                 queue_work(mxt->queue,&mxt->work);\r
1672 #else\r
1673                 MXT1386_LOG(KERN_INFO "%s: queue_delayed_work start\n", __func__);\r
1674                 queue_delayed_work(mxt->queue, &mxt->dwork, 0);\r
1675 #endif\r
1676         }\r
1677         else {\r
1678                 MXT1386_LOG(KERN_INFO "%s: LCDC_STANDBY_PIN test, value is low\n", __func__);   \r
1679                 wakeup_flag = 1;\r
1680                 return IRQ_NONE;\r
1681         }\r
1682 #endif\r
1683         return IRQ_HANDLED;\r
1684 }\r
1685 \r
1686 /******************************************************************************/\r
1687 /* Initialization of driver                                                   */\r
1688 /******************************************************************************/\r
1689 \r
1690 static int __devinit mxt_identify(struct i2c_client *client,\r
1691                                   struct mxt_data *mxt,\r
1692                                   u8 *id_block_data)\r
1693 {\r
1694         u8 buf[7];\r
1695         int error;\r
1696         int identified;\r
1697 \r
1698         identified = 0;\r
1699 \r
1700         /* Read Device info to check if chip is valid */\r
1701         error = mxt_read_block(client, MXT_ADDR_INFO_BLOCK, MXT_ID_BLOCK_SIZE,\r
1702                                (u8 *) buf);\r
1703 \r
1704         if (error < 0) {\r
1705                 mxt->read_fail_counter++;\r
1706                 dev_err(&client->dev, "Failure accessing maXTouch device\n");\r
1707                 return -EIO;\r
1708         }\r
1709 \r
1710         memcpy(id_block_data, buf, MXT_ID_BLOCK_SIZE);\r
1711 \r
1712         mxt->device_info.family_id  = buf[0];\r
1713         mxt->device_info.variant_id = buf[1];\r
1714         mxt->device_info.major      = ((buf[2] >> 4) & 0x0F);\r
1715         mxt->device_info.minor      = (buf[2] & 0x0F);\r
1716         mxt->device_info.build      = buf[3];\r
1717         mxt->device_info.x_size     = buf[4];\r
1718         mxt->device_info.y_size     = buf[5];\r
1719         mxt->device_info.num_objs   = buf[6];\r
1720         mxt->device_info.num_nodes  = mxt->device_info.x_size *\r
1721                                       mxt->device_info.y_size;\r
1722 \r
1723         /*\r
1724          * Check Family & Variant Info; warn if not recognized but\r
1725          * still continue.\r
1726          */\r
1727 \r
1728         /* MXT224 */\r
1729         if (mxt->device_info.family_id == MXT224_FAMILYID) {\r
1730                 strcpy(mxt->device_info.family_name, "mXT224");\r
1731 \r
1732                 if (mxt->device_info.variant_id == MXT224_CAL_VARIANTID) {\r
1733                         strcpy(mxt->device_info.variant_name, "Calibrated");\r
1734                 } else if (mxt->device_info.variant_id == \r
1735                         MXT224_UNCAL_VARIANTID) {\r
1736                         strcpy(mxt->device_info.variant_name, "Uncalibrated");\r
1737                 } else {\r
1738                         dev_err(&client->dev,\r
1739                                 "Warning: maXTouch Variant ID [%d] not "\r
1740                                 "supported\n",\r
1741                                 mxt->device_info.variant_id);\r
1742                         strcpy(mxt->device_info.variant_name, "UNKNOWN");\r
1743                         /* identified = -ENXIO; */\r
1744                 }\r
1745 \r
1746         /* MXT1386 */\r
1747         } else if (mxt->device_info.family_id == MXT1386_FAMILYID) {\r
1748                 strcpy(mxt->device_info.family_name, "mXT1386");\r
1749 \r
1750                 if (mxt->device_info.variant_id == MXT1386_CAL_VARIANTID) {\r
1751                         strcpy(mxt->device_info.variant_name, "Calibrated");\r
1752                 } else {\r
1753                         dev_err(&client->dev,\r
1754                                 "Warning: maXTouch Variant ID [%d] not "\r
1755                                 "supported\n",\r
1756                                 mxt->device_info.variant_id);\r
1757                         strcpy(mxt->device_info.variant_name, "UNKNOWN");\r
1758                         /* identified = -ENXIO; */\r
1759                 }\r
1760         /* Unknown family ID! */\r
1761         } else {\r
1762                 dev_err(&client->dev,\r
1763                         "Warning: maXTouch Family ID [%d] not supported\n",\r
1764                         mxt->device_info.family_id);\r
1765                 strcpy(mxt->device_info.family_name, "UNKNOWN");\r
1766                 strcpy(mxt->device_info.variant_name, "UNKNOWN");\r
1767                 /* identified = -ENXIO; */\r
1768         }\r
1769 \r
1770         dev_info(\r
1771                 &client->dev,\r
1772                 "Atmel maXTouch (Family %s (%X), Variant %s (%X)) Firmware "\r
1773                 "version [%d.%d] Build %d, num_objs = %d\n",\r
1774                 mxt->device_info.family_name,\r
1775                 mxt->device_info.family_id,\r
1776                 mxt->device_info.variant_name,\r
1777                 mxt->device_info.variant_id,\r
1778                 mxt->device_info.major,\r
1779                 mxt->device_info.minor,\r
1780                 mxt->device_info.build,\r
1781                 mxt->device_info.num_objs\r
1782         );\r
1783         dev_info(\r
1784                 &client->dev,\r
1785                 "Atmel maXTouch Configuration "\r
1786                 "[X: %d] x [Y: %d]\n",\r
1787                 mxt->device_info.x_size,\r
1788                 mxt->device_info.y_size\r
1789         );\r
1790         return identified;\r
1791 }\r
1792 \r
1793 /*\r
1794  * Reads the object table from maXTouch chip to get object data like\r
1795  * address, size, report id. For Info Block CRC calculation, already read\r
1796  * id data is passed to this function too (Info Block consists of the ID\r
1797  * block and object table).\r
1798  *\r
1799  */\r
1800 static int __devinit mxt_read_object_table(struct i2c_client *client,\r
1801                                            struct mxt_data *mxt,\r
1802                                            u8 *raw_id_data)\r
1803 {\r
1804         u16     report_id_count;\r
1805         u8      buf[MXT_OBJECT_TABLE_ELEMENT_SIZE];\r
1806         u8      *raw_ib_data;\r
1807         u8      object_type;\r
1808         u16     object_address;\r
1809         u16     object_size;\r
1810         u8      object_instances;\r
1811         u8      object_report_ids;\r
1812         u16     object_info_address;\r
1813         u32     crc;\r
1814         u32     calculated_crc;\r
1815         int     i;\r
1816         int     error;\r
1817 \r
1818         u8      object_instance;\r
1819         u8      object_report_id;\r
1820         u8      report_id;\r
1821         int     first_report_id;\r
1822         int     ib_pointer;\r
1823         struct mxt_object *object_table;\r
1824 \r
1825         MXT1386_LOG(KERN_INFO "maXTouch driver reading configuration\n", __func__);\r
1826 \r
1827         object_table = kzalloc(sizeof(struct mxt_object) *\r
1828                                mxt->device_info.num_objs,\r
1829                                GFP_KERNEL);\r
1830         if (object_table == NULL) {\r
1831                 MXT1386_LOG(KERN_INFO "maXTouch: Memory allocation failed!\n", __func__);\r
1832                 error = -ENOMEM;\r
1833                 goto err_object_table_alloc;\r
1834         }\r
1835 \r
1836         raw_ib_data = kmalloc(MXT_OBJECT_TABLE_ELEMENT_SIZE *\r
1837                         mxt->device_info.num_objs + MXT_ID_BLOCK_SIZE,\r
1838                         GFP_KERNEL);\r
1839         if (raw_ib_data == NULL) {\r
1840                 MXT1386_LOG(KERN_INFO "maXTouch: Memory allocation failed!\n", __func__);\r
1841                 error = -ENOMEM;\r
1842                 goto err_ib_alloc;\r
1843         }\r
1844 \r
1845         /* Copy the ID data for CRC calculation. */\r
1846         memcpy(raw_ib_data, raw_id_data, MXT_ID_BLOCK_SIZE);\r
1847         ib_pointer = MXT_ID_BLOCK_SIZE;\r
1848 \r
1849         mxt->object_table = object_table;\r
1850 \r
1851         MXT1386_LOG(KERN_INFO "maXTouch driver Memory allocated\n", __func__);\r
1852 \r
1853         object_info_address = MXT_ADDR_OBJECT_TABLE;\r
1854 \r
1855         report_id_count = 0;\r
1856         for (i = 0; i < mxt->device_info.num_objs; i++) {\r
1857                 MXT1386_LOG(KERN_INFO "Reading maXTouch at [0x%04x]: ", __func__,\r
1858                           object_info_address);\r
1859 \r
1860                 error = mxt_read_block(client, object_info_address,\r
1861                                        MXT_OBJECT_TABLE_ELEMENT_SIZE, buf);\r
1862 \r
1863                 if (error < 0) {\r
1864                         mxt->read_fail_counter++;\r
1865                         dev_err(&client->dev,\r
1866                                 "maXTouch Object %d could not be read\n", __func__, i);\r
1867                         error = -EIO;\r
1868                         goto err_object_read;\r
1869                 }\r
1870 \r
1871                 memcpy(raw_ib_data + ib_pointer, buf, \r
1872                        MXT_OBJECT_TABLE_ELEMENT_SIZE);\r
1873                 ib_pointer += MXT_OBJECT_TABLE_ELEMENT_SIZE;\r
1874 \r
1875                 object_type       =  buf[0];\r
1876                 object_address    = (buf[2] << 8) + buf[1];\r
1877                 object_size       =  buf[3] + 1;\r
1878                 object_instances  =  buf[4] + 1;\r
1879                 object_report_ids =  buf[5];\r
1880                 MXT1386_LOG(KERN_INFO "Type=%03d, Address=0x%04x, "\r
1881                           "Size=0x%02x, %d instances, %d report id's\n", __func__,\r
1882                           object_type,\r
1883                           object_address,\r
1884                           object_size,\r
1885                           object_instances,\r
1886                           object_report_ids\r
1887                 );\r
1888 \r
1889                 /* TODO: check whether object is known and supported? */\r
1890                 \r
1891                 /* Save frequently needed info. */\r
1892                 if (object_type == MXT_GEN_MESSAGEPROCESSOR_T5) {\r
1893                         mxt->msg_proc_addr = object_address;\r
1894                         mxt->message_size = object_size;\r
1895                 }\r
1896 \r
1897                 object_table[i].type            = object_type;\r
1898                 object_table[i].chip_addr       = object_address;\r
1899                 object_table[i].size            = object_size;\r
1900                 object_table[i].instances       = object_instances;\r
1901                 object_table[i].num_report_ids  = object_report_ids;\r
1902                 report_id_count += object_instances * object_report_ids;\r
1903 \r
1904                 object_info_address += MXT_OBJECT_TABLE_ELEMENT_SIZE;\r
1905         }\r
1906 \r
1907         mxt->rid_map =\r
1908                 kzalloc(sizeof(struct report_id_map) * (report_id_count + 1),\r
1909                         /* allocate for report_id 0, even if not used */\r
1910                         GFP_KERNEL);\r
1911         if (mxt->rid_map == NULL) {\r
1912                 MXT1386_LOG(KERN_INFO "maXTouch: Can't allocate memory!\n", __func__);\r
1913                 error = -ENOMEM;\r
1914                 goto err_rid_map_alloc;\r
1915         }\r
1916 \r
1917         mxt->messages = kzalloc(mxt->message_size * MXT_MESSAGE_BUFFER_SIZE,\r
1918                                 GFP_KERNEL);\r
1919         if (mxt->messages == NULL) {\r
1920                 MXT1386_LOG(KERN_INFO "maXTouch: Can't allocate memory!\n", __func__);\r
1921                 error = -ENOMEM;\r
1922                 goto err_msg_alloc;\r
1923         }\r
1924 \r
1925         mxt->last_message = kzalloc(mxt->message_size, GFP_KERNEL);\r
1926         if (mxt->last_message == NULL) {\r
1927                 MXT1386_LOG(KERN_INFO "maXTouch: Can't allocate memory!\n", __func__);\r
1928                 error = -ENOMEM;\r
1929                 goto err_msg_alloc;\r
1930         }\r
1931 \r
1932         mxt->report_id_count = report_id_count;\r
1933         if (report_id_count > 254) {    /* 0 & 255 are reserved */\r
1934                         dev_err(&client->dev,\r
1935                                 "Too many maXTouch report id's [%d]\n",\r
1936                                 report_id_count);\r
1937                         error = -ENXIO;\r
1938                         goto err_max_rid;\r
1939         }\r
1940 \r
1941         /* Create a mapping from report id to object type */\r
1942         report_id = 1; /* Start from 1, 0 is reserved. */\r
1943 \r
1944         /* Create table associating report id's with objects & instances */\r
1945         for (i = 0; i < mxt->device_info.num_objs; i++) {\r
1946                 for (object_instance = 0;\r
1947                      object_instance < object_table[i].instances;\r
1948                      object_instance++){\r
1949                         first_report_id = report_id;\r
1950                         for (object_report_id = 0;\r
1951                              object_report_id < object_table[i].num_report_ids;\r
1952                              object_report_id++) {\r
1953                                 mxt->rid_map[report_id].object =\r
1954                                         object_table[i].type;\r
1955                                 mxt->rid_map[report_id].instance =\r
1956                                         object_instance;\r
1957                                 mxt->rid_map[report_id].first_rid =\r
1958                                         first_report_id;\r
1959                                 report_id++;\r
1960                         }\r
1961                 }\r
1962         }\r
1963 \r
1964         /* Read 3 byte CRC */\r
1965         error = mxt_read_block(client, object_info_address, 3, buf);\r
1966         if (error < 0) {\r
1967                 mxt->read_fail_counter++;\r
1968                 dev_err(&client->dev, "Error reading CRC\n");\r
1969         }\r
1970 \r
1971         crc = (buf[2] << 16) | (buf[1] << 8) | buf[0];\r
1972 \r
1973         if (calculate_infoblock_crc(&calculated_crc, raw_ib_data,\r
1974                                     ib_pointer)) {\r
1975                 MXT1386_LOG(KERN_INFO "Error while calculating CRC!\n");\r
1976                 calculated_crc = 0;\r
1977         }\r
1978         kfree(raw_ib_data);\r
1979 \r
1980         MXT1386_LOG(KERN_INFO "Reported info block CRC = 0x%6X\n", __func__, crc);\r
1981         MXT1386_LOG(KERN_INFO "Calculated info block CRC = 0x%6X\n\n", __func__, calculated_crc);\r
1982         \r
1983         if (crc == calculated_crc) {\r
1984                 mxt->info_block_crc = crc;\r
1985         } else {\r
1986                 mxt->info_block_crc = 0;\r
1987                 MXT1386_LOG(KERN_INFO "maXTouch: Info block CRC invalid!\n"), __func__;\r
1988         }\r
1989 \r
1990         if (debug >= DEBUG_VERBOSE) {\r
1991 \r
1992                 dev_info(&client->dev, "maXTouch: %d Objects\n",\r
1993                                 mxt->device_info.num_objs);\r
1994 \r
1995                 for (i = 0; i < mxt->device_info.num_objs; i++) {\r
1996                         dev_info(&client->dev, "Type:\t\t\t[%d]: %s\n",\r
1997                                  object_table[i].type,\r
1998                                  object_type_name[object_table[i].type]);\r
1999                         dev_info(&client->dev, "\tAddress:\t0x%04X\n",\r
2000                                 object_table[i].chip_addr);\r
2001                         dev_info(&client->dev, "\tSize:\t\t%d Bytes\n",\r
2002                                  object_table[i].size);\r
2003                         dev_info(&client->dev, "\tInstances:\t%d\n",\r
2004                                  object_table[i].instances);\r
2005                         dev_info(&client->dev, "\tReport Id's:\t%d\n",\r
2006                                  object_table[i].num_report_ids);\r
2007                 }\r
2008         }\r
2009 \r
2010         return 0;\r
2011 \r
2012 err_max_rid:\r
2013         kfree(mxt->last_message);\r
2014 err_msg_alloc:\r
2015         kfree(mxt->rid_map);\r
2016 err_rid_map_alloc:\r
2017 err_object_read:\r
2018         kfree(raw_ib_data);\r
2019 err_ib_alloc:\r
2020         kfree(object_table);\r
2021 err_object_table_alloc:\r
2022         return error;\r
2023 }\r
2024 \r
2025 //#define TS_PEN_IRQ_GPIO RK29_PIN0_PA2//61\r
2026 \r
2027 static int Gpio_TS_request_irq(struct mxt_data *mxt)\r
2028 {\r
2029         int rc;\r
2030     struct i2c_client *client = mxt->client;\r
2031 \r
2032         MXT1386_LOG(KERN_INFO "Gpio_TS_request_irq enter!\n", __func__);        \r
2033         MXT1386_LOG(KERN_INFO "%s: times 1 ts_irq value is %d\n", __func__, ts_irq);\r
2034 \r
2035         if (gpio_get_value(client->irq)) {\r
2036         MXT1386_LOG(KERN_INFO "%s: mxt1386 GPIO value is high\n", __func__);\r
2037     }\r
2038         else {\r
2039                 MXT1386_LOG(KERN_INFO "%s: mxt1386 GPIO value is low\n", __func__);\r
2040         }\r
2041 \r
2042         MXT1386_LOG(KERN_INFO "%s: times 2 ts_irq value is %d\n", __func__, ts_irq);\r
2043         rc = request_irq(mxt->irq, mxt_irq_handler,\r
2044                                 IRQF_TRIGGER_LOW,//IRQF_TRIGGER_FALLING,  //\r
2045                                 "mxc_ts_i2c", mxt);\r
2046         if (rc) {\r
2047                 pr_err("could not request irq\n");\r
2048                 goto error_req_irq_fail;\r
2049         }\r
2050 \r
2051         MXT1386_LOG(KERN_INFO "Gpio_TS_request_irq ok!\n", __func__);\r
2052         return 0;\r
2053 \r
2054 error_req_irq_fail:\r
2055 error_irq_gpio_dir:\r
2056         gpio_free(client->irq);\r
2057 error_irq_gpio_req:\r
2058         if (client->irq >= 0)\r
2059                 gpio_free(client->irq);\r
2060         return rc;\r
2061 }\r
2062 \r
2063 static int mxt1386_platform_data_init(struct atmel_1386_platform_data *pdata)\r
2064 {\r
2065         MXT1386_LOG(KERN_INFO "%s: mxt1386_platform_data_init enter!\n", __func__);\r
2066 \r
2067         pdata->max_x = CONFIG_ATMEL_MXT1386_MAX_X;\r
2068         pdata->max_y = CONFIG_ATMEL_MXT1386_MAX_Y;\r
2069 \r
2070         return 0;\r
2071 }\r
2072 \r
2073 static int __devinit mxt_probe(struct i2c_client *client,\r
2074                                const struct i2c_device_id *id)\r
2075 {\r
2076         struct atmel_1386_platform_data *pdata = (struct atmel_1386_platform_data *)client->dev.platform_data;\r
2077         struct mxt_data          *mxt;\r
2078         struct input_dev         *input;\r
2079         u8 *id_data;\r
2080         int error;\r
2081         u8 buf[MXT_ACK_BUFFER_SIZE] = {0};\r
2082         u8 buf_size = MXT_MAKE_HIGH_CHG_SIZE_MIN;\r
2083     int index;\r
2084     \r
2085         MXT1386_LOG(" ---------------- mxt_probe start ------------ \n");\r
2086         MXT1386_LOG(KERN_INFO "%s: mxt_probe enter, debug level is = %d\n", __func__, debug);\r
2087 \r
2088         if (client == NULL) {\r
2089                 MXT1386_LOG("maXTouch: client == NULL\n");\r
2090                 return  -EINVAL;\r
2091         } else if (client->adapter == NULL) {\r
2092                 MXT1386_LOG("maXTouch: client->adapter == NULL\n");\r
2093                 return  -EINVAL;\r
2094         } else if (&client->dev == NULL) {\r
2095                 MXT1386_LOG("maXTouch: client->dev == NULL\n");\r
2096                 return  -EINVAL;\r
2097         } else if (&client->adapter->dev == NULL) {\r
2098                 MXT1386_LOG("maXTouch: client->adapter->dev == NULL\n");\r
2099                 return  -EINVAL;\r
2100         } else if (id == NULL) {\r
2101                 MXT1386_LOG("maXTouch: id == NULL\n");\r
2102                 return  -EINVAL;\r
2103         }\r
2104 \r
2105         mxt1386_platform_data_init(pdata);\r
2106 \r
2107         MXT1386_LOG(KERN_INFO "%s: maXTouch driver v. %s\n", __func__, DRIVER_VERSION);\r
2108         MXT1386_LOG(KERN_INFO "%s: \t \"%s\"\n", __func__, client->name);\r
2109         MXT1386_LOG(KERN_INFO "%s: \taddr:\t0x%04x\n", __func__, client->addr);\r
2110         MXT1386_LOG(KERN_INFO "%s: \tirq:\t%d\n", __func__, client->irq);\r
2111         MXT1386_LOG(KERN_INFO "%s: \tflags:\t0x%04x\n", __func__, client->flags);\r
2112         MXT1386_LOG(KERN_INFO "%s: \tadapter:\"%s\"\n", __func__, client->adapter->name);\r
2113         MXT1386_LOG(KERN_INFO "%s: \tdevice:\t\"%s\"\n", __func__, client->dev.init_name);\r
2114 \r
2115         if (!pdata) {\r
2116                 MXT1386_LOG("TS i2c_probe no platform data\n");\r
2117         }\r
2118         else {\r
2119                 MXT1386_LOG("TS i2c_probe platform data OK\n");\r
2120         }\r
2121 \r
2122         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) {\r
2123                 MXT1386_LOG("TS i2c_probe I2C_FUNC_I2C Failed\n");\r
2124         }\r
2125         else {\r
2126                 MXT1386_LOG("TS i2c_probe I2C_FUNC_I2C OK\n");\r
2127         }\r
2128         \r
2129         if (pdata->init_platform_hw != NULL) {\r
2130                 error = pdata->init_platform_hw(&(client->dev));\r
2131                 if (error < 0) {\r
2132                         MXT1386_LOG("TS i2c_probe power on Failed\n");\r
2133                         return error;\r
2134                 }\r
2135                 else {\r
2136                         MXT1386_LOG("TS i2c_probe power on OK\n");\r
2137                 }\r
2138         }\r
2139         else {                  /* ---------------- add by acgzx test ---------------- */\r
2140                 MXT1386_LOG("TS init_platform_hw is NULL\n");\r
2141         }               \r
2142 \r
2143         /* Allocate structure - we need it to identify device */\r
2144         mxt = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);\r
2145         if (mxt == NULL) {\r
2146                 dev_err(&client->dev, "insufficient memory\n");\r
2147                 error = -ENOMEM;\r
2148                 goto err_mxt_alloc;\r
2149         }\r
2150 \r
2151         id_data = kmalloc(MXT_ID_BLOCK_SIZE, GFP_KERNEL);\r
2152         if (id_data == NULL) {\r
2153                 dev_err(&client->dev, "insufficient memory\n");\r
2154                 error = -ENOMEM;\r
2155                 goto err_id_alloc;\r
2156         }\r
2157 \r
2158         input = input_allocate_device();\r
2159         if (!input) {\r
2160                 dev_err(&client->dev, "error allocating input device\n");\r
2161                 error = -ENOMEM;\r
2162                 goto err_input_dev_alloc;\r
2163         }\r
2164 \r
2165         atmel_mxt = mxt;\r
2166 \r
2167         mxt->read_fail_counter = 0;\r
2168         mxt->message_counter   = 0;\r
2169         mxt->max_x_val         = pdata->max_x;\r
2170         mxt->max_y_val         = pdata->max_y;\r
2171 \r
2172         /* Get data that is defined in board specific code. */\r
2173         mxt->init_hw = pdata->init_platform_hw;\r
2174         mxt->exit_hw = pdata->exit_platform_hw;\r
2175         mxt->read_chg = pdata->read_chg;\r
2176 \r
2177         if (pdata->valid_interrupt != NULL)\r
2178                 mxt->valid_interrupt = pdata->valid_interrupt;\r
2179         else\r
2180         {\r
2181                 mxt->valid_interrupt = mxt_valid_interrupt_dummy;\r
2182                 MXT1386_LOG("TS valid_interrupt is dummy\n");           /* ---------------- add by acgzx test ---------------- */\r
2183         }               \r
2184 \r
2185         if (debug >= DEBUG_TRACE)\r
2186                 MXT1386_LOG("maXTouch driver identifying chip\n");\r
2187 \r
2188         if (mxt_identify(client, mxt, id_data) < 0) {\r
2189                 dev_err(&client->dev, "Chip could not be identified\n");\r
2190                 error = -ENODEV;\r
2191                 goto err_identify;\r
2192         }\r
2193         /* Chip is valid and active. */\r
2194         if (debug >= DEBUG_TRACE)\r
2195                 MXT1386_LOG("maXTouch driver allocating input device\n");\r
2196 \r
2197         mxt->client = client;\r
2198         mxt->input  = input;\r
2199 \r
2200         mutex_init(&mxt->debug_mutex);\r
2201         mutex_init(&mxt->msg_mutex);\r
2202         MXT1386_LOG("maXTouch driver creating device name\n");\r
2203 \r
2204         snprintf(\r
2205                 mxt->phys_name,\r
2206                 sizeof(mxt->phys_name),\r
2207                 "%s/input0",\r
2208                 dev_name(&client->dev)\r
2209         );\r
2210         input->name = "mxc_ts_i2c";     // "Atmel maXTouch Touchscreen controller";\r
2211         input->phys = mxt->phys_name;\r
2212         input->id.bustype = BUS_I2C;\r
2213         input->dev.parent = &client->dev;\r
2214 \r
2215         MXT1386_LOG("maXTouch name: \"%s\"\n", input->name);\r
2216         MXT1386_LOG("maXTouch phys: \"%s\"\n", input->phys);\r
2217         MXT1386_LOG("maXTouch driver setting abs parameters\n");\r
2218 \r
2219         MXT1386_LOG(KERN_INFO "%s: mxt->max_x_val = %d\n", __func__, mxt->max_x_val);\r
2220         MXT1386_LOG(KERN_INFO "%s: mxt->max_y_val = %d\n", __func__, mxt->max_y_val);\r
2221         \r
2222         /* Single touch */\r
2223         input_set_abs_params(input, ABS_X, 0, mxt->max_x_val, 0, 0);\r
2224         input_set_abs_params(input, ABS_Y, 0, mxt->max_y_val, 0, 0);\r
2225         input_set_abs_params(input, ABS_PRESSURE, 0, MXT_MAX_REPORTED_PRESSURE,\r
2226                              0, 0);\r
2227         input_set_abs_params(input, ABS_TOOL_WIDTH, 0, MXT_MAX_REPORTED_WIDTH,\r
2228                              0, 0);\r
2229 \r
2230         /* Multitouch */\r
2231         input_set_abs_params(input, ABS_MT_POSITION_X, 0, mxt->max_x_val, 0, 0);\r
2232         input_set_abs_params(input, ABS_MT_POSITION_Y, 0, mxt->max_y_val, 0, 0);\r
2233         input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, MXT_MAX_TOUCH_SIZE,\r
2234                              0, 0);\r
2235         input_set_abs_params(input, ABS_MT_TRACKING_ID, 0, MXT_MAX_NUM_TOUCHES,\r
2236                              0, 0);\r
2237         \r
2238         __set_bit(EV_ABS, input->evbit);\r
2239         __set_bit(EV_SYN, input->evbit);\r
2240         __set_bit(EV_KEY, input->evbit);\r
2241         __set_bit(EV_MSC, input->evbit);\r
2242 \r
2243 #if TOUCH_KEY_EN\r
2244         __set_bit(KEY_SEARCH, input->keybit);\r
2245         __set_bit(KEY_HOME, input->keybit);\r
2246         __set_bit(KEY_MENU, input->keybit);\r
2247         __set_bit(KEY_BACK, input->keybit);\r
2248 #endif\r
2249 \r
2250         input->mscbit[0] = BIT_MASK(MSC_GESTURE);\r
2251 \r
2252         MXT1386_LOG("maXTouch driver setting client data\n");\r
2253         i2c_set_clientdata(client, mxt);\r
2254         MXT1386_LOG("maXTouch driver setting drv data\n");\r
2255         input_set_drvdata(input, mxt);\r
2256         MXT1386_LOG("maXTouch driver input register device\n");\r
2257         error = input_register_device(mxt->input);\r
2258         if (error < 0) {\r
2259                 dev_err(&client->dev,\r
2260                         "Failed to register input device\n");\r
2261                 goto err_register_device;\r
2262         }\r
2263 \r
2264         error = mxt_read_object_table(client, mxt, id_data);\r
2265         if (error < 0)\r
2266                 goto err_read_ot;\r
2267 \r
2268         /* Create debugfs entries. */\r
2269         mxt->debug_dir = debugfs_create_dir("maXTouch", NULL);\r
2270         if (mxt->debug_dir == ERR_PTR(-ENODEV)){\r
2271                 /* debugfs is not enabled. */\r
2272                 MXT1386_LOG("debugfs not enabled in kernel\n");\r
2273         } else if (mxt->debug_dir == NULL) {\r
2274                 MXT1386_LOG("error creating debugfs dir\n");\r
2275         } else {\r
2276                 MXT1386_LOG("created \"maXTouch\" debugfs dir\n");\r
2277                 \r
2278                 debugfs_create_file("deltas", S_IRUSR, mxt->debug_dir, mxt, \r
2279                                     &delta_fops);\r
2280                 debugfs_create_file("refs", S_IRUSR, mxt->debug_dir, mxt,\r
2281                                     &refs_fops);\r
2282         }\r
2283 \r
2284     /* Create character device nodes for reading & writing registers */\r
2285         mxt->mxt_class = class_create(THIS_MODULE, "maXTouch_memory");\r
2286         /* 2 numbers; one for memory and one for messages */\r
2287         error = alloc_chrdev_region(&mxt->dev_num, 0, 2, \r
2288                                     "maXTouch_memory");\r
2289         MXT1386_LOG("device number %d allocated!\n", MAJOR(mxt->dev_num));\r
2290         if (error){\r
2291                 MXT1386_LOG("Error registering device\n");\r
2292         }\r
2293         cdev_init(&mxt->cdev, &mxt_memory_fops);\r
2294         cdev_init(&mxt->cdev_messages, &mxt_message_fops);\r
2295         \r
2296         MXT1386_LOG("cdev initialized\n");\r
2297         mxt->cdev.owner = THIS_MODULE;\r
2298         mxt->cdev_messages.owner = THIS_MODULE;\r
2299         \r
2300         error = cdev_add(&mxt->cdev, mxt->dev_num, 1);\r
2301         if (error){\r
2302                 MXT1386_LOG("Bad cdev\n");\r
2303         }\r
2304         \r
2305         error = cdev_add(&mxt->cdev_messages, mxt->dev_num + 1, 1);\r
2306         if (error){\r
2307                 MXT1386_LOG("Bad cdev\n");\r
2308         }\r
2309         \r
2310         MXT1386_LOG("cdev added\n");\r
2311         \r
2312         device_create(mxt->mxt_class, NULL, MKDEV(MAJOR(mxt->dev_num), 0), NULL,\r
2313                 "maXTouch");\r
2314 \r
2315         device_create(mxt->mxt_class, NULL, MKDEV(MAJOR(mxt->dev_num), 1), NULL,\r
2316                 "maXTouch_messages");\r
2317 \r
2318         mxt->msg_buffer_startp = 0;\r
2319         mxt->msg_buffer_endp = 0;\r
2320 \r
2321         /* Allocate the interrupt */\r
2322         MXT1386_LOG("maXTouch driver allocating interrupt...\n");\r
2323         mxt->irq = gpio_to_irq(client->irq);\r
2324     ts_irq = mxt->irq;\r
2325         mxt->valid_irq_counter = 0;\r
2326         mxt->invalid_irq_counter = 0;\r
2327         mxt->irq_counter = 0;\r
2328 \r
2329 //WRITE_MT_CONFIG\r
2330 \r
2331 #if WORKQ_RIGHTNOW\r
2332         MXT1386_LOG(KERN_INFO "%s: INIT_WORK set\n", __func__);\r
2333         mxt->queue = create_singlethread_workqueue("mxc_ts_handler"); /*´´½¨Ò»¸öµ¥Ïß³ÌµÄ¹¤×÷¶ÓÁÐ*/\r
2334         INIT_WORK(&mxt->work, ts_thread_1386);  \r
2335 #else\r
2336         MXT1386_LOG(KERN_INFO "%s: INIT_DELAYED_WORK set\n", __func__);\r
2337         mxt->queue = create_rt_workqueue("mxc_ts_handler");             /*´´½¨Ò»¸öÊµÊ±µÄ¹¤×÷¶ÓÁÐ*/\r
2338         INIT_DELAYED_WORK(&mxt->dwork, ts_thread_1386);\r
2339 #endif\r
2340 \r
2341 /*--------------------------------------------------------------------------------*/\r
2342         /* Now the chip pull the irq pin to down waiting the host ack */\r
2343         if(gpio_get_value(client->irq)) {\r
2344                 MXT1386_LOG(KERN_INFO "%s: TOUCH_INT_PIN test, value is high, error\n", __func__);\r
2345                 goto err_irq;\r
2346         }\r
2347         else {\r
2348                 MXT1386_LOG(KERN_INFO "%s: TOUCH_INT_PIN test, value is low, need host ack\n", __func__);\r
2349         }\r
2350 \r
2351         /* TP MCU Ó²¼þ¸´Î»ºó£¬´ËÊ±INTÒý½ÅÎªµÍµçÆ½£¬Ö÷¿ØÐè´ÓT5¼Ä´æÆ÷¶ÁÒ»¶ÎÖÁÉÙ10bytes´óÐ¡(²»ÄÜÐ¡ÓÚ´ËÖµ)µÄÊý¾Ý·´À¡¸øMCU£¬´ËÊ±INTÒý½Å²ÅÀ¸ß acgzx 2011.03.30 */\r
2352         /* Read dummy message to make high CHG pin (Make CHG line high after the interrupts are enabled) */\r
2353         error = mxt_read_block(client, mxt->msg_proc_addr, buf_size, (u8 *)buf);        /* ---!!!!!!!!!!!!!!!!!!!!!!!!!!!!!--- */\r
2354         if (error < 0) {\r
2355                 MXT1386_LOG(KERN_INFO "%s: host first ack msg err!\n", __func__);\r
2356         }\r
2357         else {\r
2358                 MXT1386_LOG(KERN_INFO "%s: host first ack msg ok!\n", __func__);\r
2359         }\r
2360         mxt_buf_test(buf, buf_size);\r
2361     msleep(20);\r
2362         \r
2363         if(gpio_get_value(client->irq)) {\r
2364         MXT1386_LOG(KERN_INFO "%s: TOUCH_INT_PIN test, value is high, host acked chip successively\n", __func__);\r
2365     }\r
2366         else {\r
2367                 MXT1386_LOG(KERN_INFO "%s: TOUCH_INT_PIN test, value is low, host acked chip fail\n", __func__);\r
2368                 goto err_irq;\r
2369         }\r
2370 /*--------------------------------------------------------------------------------*/\r
2371     atmel_1386_write_config(mxt);\r
2372 \r
2373         error = Gpio_TS_request_irq(mxt);\r
2374         if (error != 0) {\r
2375                 MXT1386_LOG("TS i2c_probe request irq failed\n");\r
2376                goto err_irq;\r
2377         }\r
2378         else {\r
2379                 MXT1386_LOG("TS i2c_probe request irq ok\n");\r
2380         }\r
2381 \r
2382 #ifdef CONFIG_PM\r
2383                 device_init_wakeup(&client->dev, 0);\r
2384 #endif\r
2385 \r
2386     if (debug > DEBUG_INFO)\r
2387                 dev_info(&client->dev, "touchscreen, irq %d\n", mxt->irq);\r
2388                 \r
2389         kfree(id_data);\r
2390         \r
2391         MXT1386_LOG(KERN_INFO "%s: mxt_probe init ok\n", __func__);\r
2392         MXT1386_LOG(" ---------------- mxt_probe end ------------ \n");\r
2393         return 0;\r
2394 \r
2395 err_irq:\r
2396         kfree(mxt->rid_map);\r
2397         kfree(mxt->object_table);\r
2398         kfree(mxt->last_message);\r
2399 err_read_ot:\r
2400 err_register_device:\r
2401 err_identify:\r
2402 err_input_dev_alloc:\r
2403         kfree(id_data);\r
2404 err_id_alloc:\r
2405         if (mxt->exit_hw != NULL)\r
2406                 mxt->exit_hw(&(client->dev));\r
2407         kfree(mxt);\r
2408 err_mxt_alloc:\r
2409         return error;\r
2410 }\r
2411 \r
2412 static int __devexit mxt_remove(struct i2c_client *client)\r
2413 {\r
2414         struct mxt_data *mxt;\r
2415 \r
2416         MXT1386_LOG(KERN_INFO "%s: ----------- mxt_remove enter now -----------\n", __func__);\r
2417 \r
2418         mxt = i2c_get_clientdata(client);\r
2419 \r
2420         /* Remove debug dir entries */\r
2421         debugfs_remove_recursive(mxt->debug_dir);\r
2422 \r
2423         if (mxt != NULL) {\r
2424                 \r
2425                 if (mxt->exit_hw != NULL)\r
2426                         mxt->exit_hw(&(client->dev));\r
2427 \r
2428                 if (mxt->irq) {\r
2429                         free_irq(mxt->irq, mxt);\r
2430                 }\r
2431 \r
2432 #if (!WORKQ_RIGHTNOW)\r
2433                 if (cancel_delayed_work_sync(&mxt->dwork)) {\r
2434                 /*
2435                  * Work was pending, therefore we need to enable
2436                  * IRQ here to balance the disable_irq() done in the
2437                  * interrupt handler.
2438                  */\r
2439                         MXT1386_LOG(KERN_INFO "%s: cancel_delayed_work_sync set\n", __func__);\r
2440                         enable_irq(mxt->irq);\r
2441                 }\r
2442 #endif\r
2443 \r
2444                 unregister_chrdev_region(mxt->dev_num, 2);\r
2445                 device_destroy(mxt->mxt_class, MKDEV(MAJOR(mxt->dev_num), 0));\r
2446                 device_destroy(mxt->mxt_class, MKDEV(MAJOR(mxt->dev_num), 1));\r
2447                 cdev_del(&mxt->cdev);\r
2448                 cdev_del(&mxt->cdev_messages);\r
2449                 cancel_delayed_work_sync(&mxt->dwork);\r
2450                 input_unregister_device(mxt->input);\r
2451                 class_destroy(mxt->mxt_class);\r
2452                 debugfs_remove(mxt->debug_dir);\r
2453 \r
2454                 kfree(mxt->rid_map);\r
2455                 kfree(mxt->object_table);\r
2456                 kfree(mxt->last_message);\r
2457         }\r
2458         kfree(mxt);\r
2459 \r
2460         i2c_set_clientdata(client, NULL);\r
2461         if (debug >= DEBUG_TRACE)\r
2462                 dev_info(&client->dev, "Touchscreen unregistered\n");\r
2463 \r
2464         return 0;\r
2465 }\r
2466 \r
2467 #if defined(CONFIG_PM)\r
2468 static int mxt_suspend(struct i2c_client *client, pm_message_t mesg)\r
2469 {\r
2470         struct mxt_data *mxt = i2c_get_clientdata(client);\r
2471 \r
2472         MXT1386_LOG(KERN_INFO "%s: ----------- mxt_suspend enter now -----------\n", __func__);\r
2473 \r
2474 #if 1\r
2475         if (device_may_wakeup(&client->dev)) {\r
2476                 MXT1386_LOG(KERN_INFO "%s: mxt_suspend ok\n", __func__);\r
2477                 enable_irq_wake(mxt->irq);\r
2478         } else {\r
2479                 MXT1386_LOG(KERN_INFO "%s: mxt_suspend failed\n", __func__);\r
2480         }\r
2481 #else\r
2482         disable_irq(mxt->irq);\r
2483         cancel_work_sync(&mxt->work);\r
2484         \r
2485         if (device_may_wakeup(&client->dev)) {\r
2486                 printk(KERN_INFO "%s: mxt_suspend ok\n", __func__);\r
2487                 enable_irq_wake(mxt->irq);\r
2488         } else {\r
2489                 printk(KERN_INFO "%s: mxt_suspend failed\n", __func__);\r
2490         }\r
2491 #endif\r
2492 \r
2493         return 0;\r
2494 }\r
2495 \r
2496 static int mxt_wakeup_controller(int gpio)\r
2497 {\r
2498         int ret=0, i;\r
2499 \r
2500         gpio_free(gpio);\r
2501 \r
2502         if((ret = gpio_request(gpio, "mxc_irq_gpio"))!=0) {\r
2503                 MXT1386_LOG(KERN_INFO "Failed to request GPIO for mxc_irq_gpio. Err:%d\n", ret);\r
2504                 ret = -EFAULT;\r
2505         } else  {\r
2506                 gpio_direction_output(gpio, 0);\r
2507                 \r
2508                 for(i=0; i<100; i++);\r
2509                         gpio_direction_input(gpio);\r
2510                 MXT1386_LOG(KERN_INFO "INT wakeup touch controller done\n");\r
2511         }\r
2512         \r
2513         return ret;\r
2514 }\r
2515 \r
2516 \r
2517 static int mxt_resume(struct i2c_client *client)\r
2518 {\r
2519         struct mxt_data *mxt = i2c_get_clientdata(client);\r
2520 \r
2521         MXT1386_LOG(KERN_INFO "%s: ----------- mxt_resume enter now ----------- \n", __func__);\r
2522 \r
2523 #if 1\r
2524         if (device_may_wakeup(&client->dev)) {\r
2525                 MXT1386_LOG(KERN_INFO "%s: mxt_resume ok\n", __func__);\r
2526                 disable_irq_wake(mxt->irq);\r
2527         } else {\r
2528                 MXT1386_LOG(KERN_INFO "%s: mxt_resume failed\n", __func__);\r
2529         }\r
2530 #else\r
2531         if (device_may_wakeup(&client->dev)) {\r
2532                 printk(KERN_INFO "%s: mxt_resume ok\n", __func__);\r
2533                 disable_irq_wake(mxt->irq);\r
2534         } else {\r
2535                 printk(KERN_INFO "%s: mxt_resume failed\n", __func__);\r
2536         }\r
2537         mxt_wakeup_controller(irq_to_gpio(mxt->irq));\r
2538         enable_irq(mxt->irq);\r
2539 #endif\r
2540 \r
2541         return 0;\r
2542 }\r
2543 #else\r
2544 #define mxt_suspend NULL\r
2545 #define mxt_resume NULL\r
2546 #endif\r
2547 \r
2548 static const struct i2c_device_id mxt_idtable[] = {\r
2549         {"mxc_ts_i2c", 0,},\r
2550         { }\r
2551 };\r
2552 \r
2553 MODULE_DEVICE_TABLE(i2c, mxt_idtable);\r
2554 \r
2555 static struct i2c_driver mxt_driver = {\r
2556         .driver = {\r
2557                 .name   = "mxc_ts_i2c",\r
2558                 .owner  = THIS_MODULE,\r
2559         },\r
2560 \r
2561         .id_table       = mxt_idtable,\r
2562         .probe          = mxt_probe,\r
2563         .remove         = __devexit_p(mxt_remove),\r
2564         .suspend        = mxt_suspend,\r
2565         .resume         = mxt_resume,\r
2566 \r
2567 };\r
2568 \r
2569 #if 0\r
2570 static void __init mxt_init_async(void *unused, async_cookie_t cookie)\r
2571 {\r
2572         int err;\r
2573         \r
2574         MXT1386_LOG(KERN_INFO "%s: ----------- mxt_init_async enter now ----------- \n", __func__);\r
2575 \r
2576         err = i2c_add_driver(&mxt_driver);\r
2577         if (err) {\r
2578                 MXT1386_LOG("Adding maXTouch driver failed "\r
2579                        "(errno = %d)\n", err);\r
2580         } else {\r
2581                 MXT1386_LOG(KERN_INFO "Successfully added driver %s\n", __func__,\r
2582                           mxt_driver.driver.name);\r
2583         }\r
2584 }\r
2585 static int __init mxt_init(void)\r
2586 {\r
2587         MXT1386_LOG(KERN_INFO "%s: ----------- mxt_init enter now ----------- \n", __func__);\r
2588         \r
2589         async_schedule(mxt_init_async, NULL);\r
2590         return 0;\r
2591 }\r
2592 #else\r
2593 static int __init mxt_init(void)\r
2594 {\r
2595         int err;\r
2596 \r
2597         MXT1386_LOG(KERN_INFO "%s: ----------- mxt_init enter now ----------- \n", __func__);\r
2598         \r
2599         err = i2c_add_driver(&mxt_driver);\r
2600         if (err) {\r
2601                 MXT1386_LOG("Adding maXTouch driver failed "\r
2602                        "(errno = %d)\n", err);\r
2603         } else {\r
2604                 MXT1386_LOG(KERN_INFO "Successfully added driver %s\n", __func__,\r
2605                           mxt_driver.driver.name);\r
2606         }\r
2607 \r
2608         MXT1386_LOG(KERN_INFO "Adding maXTouch driver  \n");\r
2609         \r
2610         return err;\r
2611 }\r
2612 #endif\r
2613 \r
2614 static void __exit mxt_cleanup(void)\r
2615 {\r
2616         MXT1386_LOG(KERN_INFO "%s: ----------- mxt_cleanup enter now ----------- \n", __func__);\r
2617         i2c_del_driver(&mxt_driver);\r
2618 }\r
2619 \r
2620 module_init(mxt_init);\r
2621 module_exit(mxt_cleanup);\r
2622 \r
2623 MODULE_AUTHOR("Iiro Valkonen");\r
2624 MODULE_DESCRIPTION("Driver for Atmel maXTouch Touchscreen Controller");\r
2625 MODULE_LICENSE("GPL");\r