drivers/input/touchscreen/atmel_maxtouch.c

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