Input: atmel_mxt_ts - Improve device configuration
[linux-2.6.git] / drivers / input / touchscreen / atmel_mxt_ts.c
1 /*
2  * Atmel maXTouch Touchscreen driver
3  *
4  * Copyright (C) 2010 Samsung Electronics Co.Ltd
5  * Copyright (C) 2011 Atmel Corporation
6  * Author: Joonyoung Shim <jy0922.shim@samsung.com>
7  *
8  * This program is free software; you can redistribute  it and/or modify it
9  * under  the terms of  the GNU General  Public License as published by the
10  * Free Software Foundation;  either version 2 of the  License, or (at your
11  * option) any later version.
12  *
13  */
14
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/delay.h>
18 #include <linux/firmware.h>
19 #include <linux/i2c.h>
20 #include <linux/i2c/atmel_mxt_ts.h>
21 #include <linux/input/mt.h>
22 #include <linux/interrupt.h>
23 #include <linux/slab.h>
24
25 /* Version */
26 #define MXT_VER_20              20
27 #define MXT_VER_21              21
28 #define MXT_VER_22              22
29
30 /* Firmware files */
31 #define MXT_FW_NAME             "maxtouch.fw"
32 #define MXT_CFG_NAME            "maxtouch.cfg"
33 #define MXT_CFG_MAGIC           "OBP_RAW V1"
34
35 /* Registers */
36 #define MXT_FAMILY_ID           0x00
37 #define MXT_VARIANT_ID          0x01
38 #define MXT_VERSION             0x02
39 #define MXT_BUILD               0x03
40 #define MXT_MATRIX_X_SIZE       0x04
41 #define MXT_MATRIX_Y_SIZE       0x05
42 #define MXT_OBJECT_NUM          0x06
43 #define MXT_OBJECT_START        0x07
44
45 #define MXT_OBJECT_SIZE         6
46
47 #define MXT_MAX_BLOCK_WRITE     256
48
49 /* Object types */
50 #define MXT_DEBUG_DIAGNOSTIC_T37        37
51 #define MXT_GEN_MESSAGE_T5              5
52 #define MXT_GEN_COMMAND_T6              6
53 #define MXT_GEN_POWER_T7                7
54 #define MXT_GEN_ACQUIRE_T8              8
55 #define MXT_GEN_DATASOURCE_T53          53
56 #define MXT_TOUCH_MULTI_T9              9
57 #define MXT_TOUCH_KEYARRAY_T15          15
58 #define MXT_TOUCH_PROXIMITY_T23         23
59 #define MXT_TOUCH_PROXKEY_T52           52
60 #define MXT_PROCI_GRIPFACE_T20          20
61 #define MXT_PROCG_NOISE_T22             22
62 #define MXT_PROCI_ONETOUCH_T24          24
63 #define MXT_PROCI_TWOTOUCH_T27          27
64 #define MXT_PROCI_GRIP_T40              40
65 #define MXT_PROCI_PALM_T41              41
66 #define MXT_PROCI_TOUCHSUPPRESSION_T42  42
67 #define MXT_PROCI_STYLUS_T47            47
68 #define MXT_PROCG_NOISESUPPRESSION_T48  48
69 #define MXT_SPT_COMMSCONFIG_T18         18
70 #define MXT_SPT_GPIOPWM_T19             19
71 #define MXT_SPT_SELFTEST_T25            25
72 #define MXT_SPT_CTECONFIG_T28           28
73 #define MXT_SPT_USERDATA_T38            38
74 #define MXT_SPT_DIGITIZER_T43           43
75 #define MXT_SPT_MESSAGECOUNT_T44        44
76 #define MXT_SPT_CTECONFIG_T46           46
77
78 /* MXT_GEN_MESSAGE_T5 object */
79 #define MXT_RPTID_NOMSG         0xff
80
81 /* MXT_GEN_COMMAND_T6 field */
82 #define MXT_COMMAND_RESET       0
83 #define MXT_COMMAND_BACKUPNV    1
84 #define MXT_COMMAND_CALIBRATE   2
85 #define MXT_COMMAND_REPORTALL   3
86 #define MXT_COMMAND_DIAGNOSTIC  5
87
88 /* MXT_GEN_POWER_T7 field */
89 #define MXT_POWER_IDLEACQINT    0
90 #define MXT_POWER_ACTVACQINT    1
91 #define MXT_POWER_ACTV2IDLETO   2
92
93 #define MXT_POWER_CFG_RUN               0
94 #define MXT_POWER_CFG_DEEPSLEEP         1
95
96 /* MXT_GEN_ACQUIRE_T8 field */
97 #define MXT_ACQUIRE_CHRGTIME    0
98 #define MXT_ACQUIRE_TCHDRIFT    2
99 #define MXT_ACQUIRE_DRIFTST     3
100 #define MXT_ACQUIRE_TCHAUTOCAL  4
101 #define MXT_ACQUIRE_SYNC        5
102 #define MXT_ACQUIRE_ATCHCALST   6
103 #define MXT_ACQUIRE_ATCHCALSTHR 7
104
105 /* MXT_TOUCH_MULTI_T9 field */
106 #define MXT_TOUCH_CTRL          0
107 #define MXT_TOUCH_XORIGIN       1
108 #define MXT_TOUCH_YORIGIN       2
109 #define MXT_TOUCH_XSIZE         3
110 #define MXT_TOUCH_YSIZE         4
111 #define MXT_TOUCH_BLEN          6
112 #define MXT_TOUCH_TCHTHR        7
113 #define MXT_TOUCH_TCHDI         8
114 #define MXT_TOUCH_ORIENT        9
115 #define MXT_TOUCH_MOVHYSTI      11
116 #define MXT_TOUCH_MOVHYSTN      12
117 #define MXT_TOUCH_NUMTOUCH      14
118 #define MXT_TOUCH_MRGHYST       15
119 #define MXT_TOUCH_MRGTHR        16
120 #define MXT_TOUCH_AMPHYST       17
121 #define MXT_TOUCH_XRANGE_LSB    18
122 #define MXT_TOUCH_XRANGE_MSB    19
123 #define MXT_TOUCH_YRANGE_LSB    20
124 #define MXT_TOUCH_YRANGE_MSB    21
125 #define MXT_TOUCH_XLOCLIP       22
126 #define MXT_TOUCH_XHICLIP       23
127 #define MXT_TOUCH_YLOCLIP       24
128 #define MXT_TOUCH_YHICLIP       25
129 #define MXT_TOUCH_XEDGECTRL     26
130 #define MXT_TOUCH_XEDGEDIST     27
131 #define MXT_TOUCH_YEDGECTRL     28
132 #define MXT_TOUCH_YEDGEDIST     29
133 #define MXT_TOUCH_JUMPLIMIT     30
134
135 /* MXT_PROCI_GRIPFACE_T20 field */
136 #define MXT_GRIPFACE_CTRL       0
137 #define MXT_GRIPFACE_XLOGRIP    1
138 #define MXT_GRIPFACE_XHIGRIP    2
139 #define MXT_GRIPFACE_YLOGRIP    3
140 #define MXT_GRIPFACE_YHIGRIP    4
141 #define MXT_GRIPFACE_MAXTCHS    5
142 #define MXT_GRIPFACE_SZTHR1     7
143 #define MXT_GRIPFACE_SZTHR2     8
144 #define MXT_GRIPFACE_SHPTHR1    9
145 #define MXT_GRIPFACE_SHPTHR2    10
146 #define MXT_GRIPFACE_SUPEXTTO   11
147
148 /* MXT_PROCI_NOISE field */
149 #define MXT_NOISE_CTRL          0
150 #define MXT_NOISE_OUTFLEN       1
151 #define MXT_NOISE_GCAFUL_LSB    3
152 #define MXT_NOISE_GCAFUL_MSB    4
153 #define MXT_NOISE_GCAFLL_LSB    5
154 #define MXT_NOISE_GCAFLL_MSB    6
155 #define MXT_NOISE_ACTVGCAFVALID 7
156 #define MXT_NOISE_NOISETHR      8
157 #define MXT_NOISE_FREQHOPSCALE  10
158 #define MXT_NOISE_FREQ0         11
159 #define MXT_NOISE_FREQ1         12
160 #define MXT_NOISE_FREQ2         13
161 #define MXT_NOISE_FREQ3         14
162 #define MXT_NOISE_FREQ4         15
163 #define MXT_NOISE_IDLEGCAFVALID 16
164
165 /* MXT_SPT_COMMSCONFIG_T18 */
166 #define MXT_COMMS_CTRL          0
167 #define MXT_COMMS_CMD           1
168
169 /* MXT_SPT_CTECONFIG_T28 field */
170 #define MXT_CTE_CTRL            0
171 #define MXT_CTE_CMD             1
172 #define MXT_CTE_MODE            2
173 #define MXT_CTE_IDLEGCAFDEPTH   3
174 #define MXT_CTE_ACTVGCAFDEPTH   4
175 #define MXT_CTE_VOLTAGE         5
176
177 #define MXT_VOLTAGE_DEFAULT     2700000
178 #define MXT_VOLTAGE_STEP        10000
179
180 /* Define for MXT_GEN_COMMAND_T6 */
181 #define MXT_BOOT_VALUE          0xa5
182 #define MXT_BACKUP_VALUE        0x55
183
184 /* Delay times */
185 #define MXT_BACKUP_TIME         25      /* msec */
186 #define MXT_RESET_TIME          200     /* msec */
187 #define MXT_RESET_NOCHGREAD     400     /* msec */
188 #define MXT_FWRESET_TIME        1000    /* msec */
189
190 /* Command to unlock bootloader */
191 #define MXT_UNLOCK_CMD_MSB      0xaa
192 #define MXT_UNLOCK_CMD_LSB      0xdc
193
194 /* Bootloader mode status */
195 #define MXT_WAITING_BOOTLOAD_CMD        0xc0    /* valid 7 6 bit only */
196 #define MXT_WAITING_FRAME_DATA  0x80    /* valid 7 6 bit only */
197 #define MXT_FRAME_CRC_CHECK     0x02
198 #define MXT_FRAME_CRC_FAIL      0x03
199 #define MXT_FRAME_CRC_PASS      0x04
200 #define MXT_APP_CRC_FAIL        0x40    /* valid 7 8 bit only */
201 #define MXT_BOOT_STATUS_MASK    0x3f
202 #define MXT_BOOT_EXTENDED_ID    (1 << 5)
203 #define MXT_BOOT_ID_MASK        0x1f
204
205 /* Touch status */
206 #define MXT_SUPPRESS            (1 << 1)
207 #define MXT_AMP                 (1 << 2)
208 #define MXT_VECTOR              (1 << 3)
209 #define MXT_MOVE                (1 << 4)
210 #define MXT_RELEASE             (1 << 5)
211 #define MXT_PRESS               (1 << 6)
212 #define MXT_DETECT              (1 << 7)
213
214 /* Touch orient bits */
215 #define MXT_XY_SWITCH           (1 << 0)
216 #define MXT_X_INVERT            (1 << 1)
217 #define MXT_Y_INVERT            (1 << 2)
218
219 /* Touchscreen absolute values */
220 #define MXT_MAX_AREA            0xff
221
222 #define MXT_MAX_FINGER          10
223
224 struct mxt_info {
225         u8 family_id;
226         u8 variant_id;
227         u8 version;
228         u8 build;
229         u8 matrix_xsize;
230         u8 matrix_ysize;
231         u8 object_num;
232 };
233
234 struct mxt_object {
235         u8 type;
236         u16 start_address;
237         u16 size;
238         u16 instances;
239         u8 num_report_ids;
240
241         /* to map object and message */
242         u8 min_reportid;
243         u8 max_reportid;
244 };
245
246 struct mxt_message {
247         u8 reportid;
248         u8 message[7];
249 };
250
251 struct mxt_finger {
252         int status;
253         int x;
254         int y;
255         int area;
256         int pressure;
257 };
258
259 enum mxt_device_state { INIT, APPMODE, BOOTLOADER, FAILED };
260
261 /* Each client has this additional data */
262 struct mxt_data {
263         struct i2c_client *client;
264         struct input_dev *input_dev;
265         const struct mxt_platform_data *pdata;
266         enum mxt_device_state state;
267         struct mxt_object *object_table;
268         u16 mem_size;
269         struct mxt_info info;
270         struct mxt_finger finger[MXT_MAX_FINGER];
271         unsigned int irq;
272         unsigned int max_x;
273         unsigned int max_y;
274         struct bin_attribute mem_access_attr;
275         bool debug_enabled;
276         bool driver_paused;
277         u8 bootloader_addr;
278         u8 actv_cycle_time;
279         u8 idle_cycle_time;
280         u8 is_stopped;
281         u8 max_reportid;
282 };
283
284 /* I2C slave address pairs */
285 struct mxt_i2c_address_pair {
286         u8 bootloader;
287         u8 application;
288 };
289
290 static const struct mxt_i2c_address_pair mxt_i2c_addresses[] = {
291         { 0x24, 0x4a },
292         { 0x25, 0x4b },
293         { 0x26, 0x4c },
294         { 0x27, 0x4d },
295         { 0x34, 0x5a },
296         { 0x35, 0x5b },
297 };
298
299 static int mxt_bootloader_read(struct mxt_data *data, u8 *val, unsigned int count)
300 {
301         int ret;
302         struct i2c_msg msg;
303
304         msg.addr = data->bootloader_addr;
305         msg.flags = data->client->flags & I2C_M_TEN;
306         msg.flags |= I2C_M_RD;
307         msg.len = count;
308         msg.buf = val;
309
310         ret = i2c_transfer(data->client->adapter, &msg, 1);
311
312         return (ret == 1) ? 0 : ret;
313 }
314
315 static int mxt_bootloader_write(struct mxt_data *data, const u8 * const val,
316         unsigned int count)
317 {
318         int ret;
319         struct i2c_msg msg;
320
321         msg.addr = data->bootloader_addr;
322         msg.flags = data->client->flags & I2C_M_TEN;
323         msg.len = count;
324         msg.buf = (u8 *)val;
325
326         ret = i2c_transfer(data->client->adapter, &msg, 1);
327
328         return (ret == 1) ? 0 : ret;
329 }
330
331 static int mxt_get_bootloader_address(struct mxt_data *data)
332 {
333         struct i2c_client *client = data->client;
334         int i;
335
336         for (i = 0; i < ARRAY_SIZE(mxt_i2c_addresses); i++) {
337                 if (mxt_i2c_addresses[i].application == client->addr) {
338                         data->bootloader_addr = mxt_i2c_addresses[i].bootloader;
339
340                         dev_info(&client->dev, "Bootloader i2c addr: 0x%02x\n",
341                                 data->bootloader_addr);
342
343                         return 0;
344                 }
345         }
346
347         dev_err(&client->dev, "Address 0x%02x not found in address table\n",
348                 client->addr);
349         return -EINVAL;
350 }
351
352 static int mxt_probe_bootloader(struct mxt_data *data)
353 {
354         struct device *dev = &data->client->dev;
355         int ret;
356         u8 val;
357         bool crc_failure;
358
359         ret = mxt_get_bootloader_address(data);
360         if (ret)
361                 return ret;
362
363         ret = mxt_bootloader_read(data, &val, 1);
364         if (ret) {
365                 dev_err(dev, "%s: i2c recv failed\n", __func__);
366                 return -EIO;
367         }
368
369         /* Check app crc fail mode */
370         crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL;
371
372         dev_err(dev, "Detected bootloader, status:%02X%s\n",
373                 val, crc_failure ? ", APP_CRC_FAIL" : "");
374
375         return 0;
376 }
377
378 static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
379 {
380         struct device *dev = &data->client->dev;
381         u8 buf[3];
382
383         if (val & MXT_BOOT_EXTENDED_ID) {
384                 if (mxt_bootloader_read(data, &buf[0], 3) != 0) {
385                         dev_err(dev, "%s: i2c failure\n", __func__);
386                         return -EIO;
387                 }
388
389                 dev_info(dev, "Bootloader ID:%d Version:%d\n", buf[1], buf[2]);
390
391                 return buf[0];
392         } else {
393                 dev_info(dev, "Bootloader ID:%d\n", val & MXT_BOOT_ID_MASK);
394
395                 return val;
396         }
397 }
398
399 static int mxt_check_bootloader(struct mxt_data *data,
400                                 unsigned int state)
401 {
402         struct device *dev = &data->client->dev;
403         int ret;
404         u8 val;
405
406 recheck:
407         ret = mxt_bootloader_read(data, &val, 1);
408         if (ret) {
409                 dev_err(dev, "%s: i2c recv failed, ret=%d\n",
410                         __func__, ret);
411                 return ret;
412         }
413
414         if (state == MXT_WAITING_BOOTLOAD_CMD) {
415                 val = mxt_get_bootloader_version(data, val);
416         }
417
418         switch (state) {
419         case MXT_WAITING_BOOTLOAD_CMD:
420                 val &= ~MXT_BOOT_STATUS_MASK;
421                 break;
422         case MXT_WAITING_FRAME_DATA:
423         case MXT_APP_CRC_FAIL:
424                 val &= ~MXT_BOOT_STATUS_MASK;
425                 break;
426         case MXT_FRAME_CRC_PASS:
427                 if (val == MXT_FRAME_CRC_CHECK)
428                         goto recheck;
429                 if (val == MXT_FRAME_CRC_FAIL) {
430                         dev_err(dev, "Bootloader CRC fail\n");
431                         return -EINVAL;
432                 }
433                 break;
434         default:
435                 return -EINVAL;
436         }
437
438         if (val != state) {
439                 dev_err(dev, "Invalid bootloader mode state 0x%02X\n", val);
440                 return -EINVAL;
441         }
442
443         return 0;
444 }
445
446 static int mxt_unlock_bootloader(struct mxt_data *data)
447 {
448         int ret;
449         u8 buf[2];
450
451         buf[0] = MXT_UNLOCK_CMD_LSB;
452         buf[1] = MXT_UNLOCK_CMD_MSB;
453
454         ret = mxt_bootloader_write(data, buf, 2);
455         if (ret) {
456                 dev_err(&data->client->dev, "%s: i2c send failed, ret=%d\n",
457                                 __func__, ret);
458                 return ret;
459         }
460
461         return 0;
462 }
463
464 static int __mxt_read_reg(struct i2c_client *client,
465                                u16 reg, u16 len, void *val)
466 {
467         struct i2c_msg xfer[2];
468         u8 buf[2];
469
470         buf[0] = reg & 0xff;
471         buf[1] = (reg >> 8) & 0xff;
472
473         /* Write register */
474         xfer[0].addr = client->addr;
475         xfer[0].flags = 0;
476         xfer[0].len = 2;
477         xfer[0].buf = buf;
478
479         /* Read data */
480         xfer[1].addr = client->addr;
481         xfer[1].flags = I2C_M_RD;
482         xfer[1].len = len;
483         xfer[1].buf = val;
484
485         if (i2c_transfer(client->adapter, xfer, 2) != 2) {
486                 dev_err(&client->dev, "%s: i2c transfer failed\n", __func__);
487                 return -EIO;
488         }
489
490         return 0;
491 }
492
493 static int mxt_read_reg(struct i2c_client *client, u16 reg, u8 *val)
494 {
495         return __mxt_read_reg(client, reg, 1, val);
496 }
497
498 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
499 {
500         u8 buf[3];
501
502         buf[0] = reg & 0xff;
503         buf[1] = (reg >> 8) & 0xff;
504         buf[2] = val;
505
506         if (i2c_master_send(client, buf, 3) != 3) {
507                 dev_err(&client->dev, "%s: i2c send failed\n", __func__);
508                 return -EIO;
509         }
510
511         return 0;
512 }
513
514 int mxt_write_block(struct i2c_client *client, u16 addr, u16 length, u8 *value)
515 {
516         int i;
517         struct {
518                 __le16 le_addr;
519                 u8  data[MXT_MAX_BLOCK_WRITE];
520         } i2c_block_transfer;
521
522         if (length > MXT_MAX_BLOCK_WRITE)
523                 return -EINVAL;
524
525         memcpy(i2c_block_transfer.data, value, length);
526
527         i2c_block_transfer.le_addr = cpu_to_le16(addr);
528
529         i = i2c_master_send(client, (u8 *) &i2c_block_transfer, length + 2);
530
531         if (i == (length + 2))
532                 return 0;
533         else
534                 return -EIO;
535 }
536
537 static int mxt_read_object_table(struct i2c_client *client,
538                                       u16 reg, u8 *object_buf)
539 {
540         return __mxt_read_reg(client, reg, MXT_OBJECT_SIZE,
541                                    object_buf);
542 }
543
544 static struct mxt_object *mxt_get_object(struct mxt_data *data, u8 type)
545 {
546         struct mxt_object *object;
547         int i;
548
549         for (i = 0; i < data->info.object_num; i++) {
550                 object = data->object_table + i;
551                 if (object->type == type)
552                         return object;
553         }
554
555         dev_err(&data->client->dev, "Invalid object type T%u\n", type);
556         return NULL;
557 }
558
559 static int mxt_read_message(struct mxt_data *data,
560                                  struct mxt_message *message)
561 {
562         struct mxt_object *object;
563         u16 reg;
564         int ret;
565
566         object = mxt_get_object(data, MXT_GEN_MESSAGE_T5);
567         if (!object)
568                 return -EINVAL;
569
570         reg = object->start_address;
571         ret = __mxt_read_reg(data->client, reg,
572                              sizeof(struct mxt_message), message);
573
574         if (ret == 0 && message->reportid != MXT_RPTID_NOMSG
575             && data->debug_enabled)
576                 print_hex_dump(KERN_DEBUG, "MXT MSG:", DUMP_PREFIX_NONE, 16, 1,
577                                message, sizeof(struct mxt_message), false);
578
579         return ret;
580 }
581
582 static int mxt_read_message_reportid(struct mxt_data *data,
583         struct mxt_message *message, u8 reportid)
584 {
585         int try = 0;
586         int error;
587         int fail_count;
588
589         fail_count = data->max_reportid * 2;
590
591         while (++try < fail_count) {
592                 error = mxt_read_message(data, message);
593                 if (error)
594                         return error;
595
596                 if (message->reportid == 0xff)
597                         return -EINVAL;
598
599                 if (message->reportid == reportid)
600                         return 0;
601         }
602
603         return -EINVAL;
604 }
605
606 static int mxt_read_object(struct mxt_data *data,
607                                 u8 type, u8 offset, u8 *val)
608 {
609         struct mxt_object *object;
610         u16 reg;
611
612         object = mxt_get_object(data, type);
613         if (!object)
614                 return -EINVAL;
615
616         reg = object->start_address;
617         return __mxt_read_reg(data->client, reg + offset, 1, val);
618 }
619
620 static int mxt_write_object(struct mxt_data *data,
621                                  u8 type, u8 offset, u8 val)
622 {
623         struct mxt_object *object;
624         u16 reg;
625
626         object = mxt_get_object(data, type);
627         if (!object || offset >= object->size)
628                 return -EINVAL;
629
630         if (offset >= object->size * object->instances) {
631                 dev_err(&data->client->dev, "Tried to write outside object T%d"
632                         " offset:%d, size:%d\n", type, offset, object->size);
633                 return -EINVAL;
634         }
635
636         reg = object->start_address;
637         return mxt_write_reg(data->client, reg + offset, val);
638 }
639
640 static void mxt_input_report(struct mxt_data *data, int single_id)
641 {
642         struct mxt_finger *finger = data->finger;
643         struct input_dev *input_dev = data->input_dev;
644         int status = finger[single_id].status;
645         int finger_num = 0;
646         int id;
647
648         for (id = 0; id < MXT_MAX_FINGER; id++) {
649                 if (!finger[id].status)
650                         continue;
651
652                 input_mt_slot(input_dev, id);
653                 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
654                                 finger[id].status != MXT_RELEASE);
655
656                 if (finger[id].status != MXT_RELEASE) {
657                         finger_num++;
658                         input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR,
659                                         finger[id].area);
660                         input_report_abs(input_dev, ABS_MT_POSITION_X,
661                                         finger[id].x);
662                         input_report_abs(input_dev, ABS_MT_POSITION_Y,
663                                         finger[id].y);
664                         input_report_abs(input_dev, ABS_MT_PRESSURE,
665                                         finger[id].pressure);
666                 } else {
667                         finger[id].status = 0;
668                 }
669         }
670
671         input_report_key(input_dev, BTN_TOUCH, finger_num > 0);
672
673         if (status != MXT_RELEASE) {
674                 input_report_abs(input_dev, ABS_X, finger[single_id].x);
675                 input_report_abs(input_dev, ABS_Y, finger[single_id].y);
676                 input_report_abs(input_dev,
677                                  ABS_PRESSURE, finger[single_id].pressure);
678         }
679
680         input_sync(input_dev);
681 }
682
683 static void mxt_input_touchevent(struct mxt_data *data,
684                                       struct mxt_message *message, int id)
685 {
686         struct mxt_finger *finger = data->finger;
687         struct device *dev = &data->client->dev;
688         u8 status = message->message[0];
689         int x;
690         int y;
691         int area;
692         int pressure;
693
694         if (data->driver_paused)
695                 return;
696
697         /* Check the touch is present on the screen */
698         if (!(status & MXT_DETECT)) {
699                 if (status & MXT_RELEASE) {
700                         dev_dbg(dev, "[%d] released\n", id);
701
702                         finger[id].status = MXT_RELEASE;
703                         mxt_input_report(data, id);
704                 }
705                 return;
706         }
707
708         /* Check only AMP detection */
709         if (!(status & (MXT_PRESS | MXT_MOVE)))
710                 return;
711
712         x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf);
713         y = (message->message[2] << 4) | ((message->message[3] & 0xf));
714         if (data->max_x < 1024)
715                 x = x >> 2;
716         if (data->max_y < 1024)
717                 y = y >> 2;
718
719         area = message->message[4];
720         pressure = message->message[5];
721
722         dev_dbg(dev, "[%d] %s x: %d, y: %d, area: %d\n", id,
723                 status & MXT_MOVE ? "moved" : "pressed",
724                 x, y, area);
725
726         finger[id].status = status & MXT_MOVE ?
727                                 MXT_MOVE : MXT_PRESS;
728         finger[id].x = x;
729         finger[id].y = y;
730         finger[id].area = area;
731         finger[id].pressure = pressure;
732
733         mxt_input_report(data, id);
734 }
735
736 static irqreturn_t mxt_interrupt(int irq, void *dev_id)
737 {
738         struct mxt_data *data = dev_id;
739         struct mxt_message message;
740         struct mxt_object *object;
741         struct device *dev = &data->client->dev;
742         int touchid;
743         u8 reportid;
744
745         do {
746                 if (mxt_read_message(data, &message)) {
747                         dev_err(dev, "Failed to read message\n");
748                         goto end;
749                 }
750
751                 reportid = message.reportid;
752
753                 object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
754                 if (!object)
755                         goto end;
756
757                 if (reportid >= object->min_reportid
758                     && reportid <= object->max_reportid) {
759                         touchid = reportid - object->min_reportid;
760                         mxt_input_touchevent(data, &message, touchid);
761                 }
762         } while (reportid != MXT_RPTID_NOMSG);
763
764 end:
765         return IRQ_HANDLED;
766 }
767
768 static int mxt_make_highchg(struct mxt_data *data)
769 {
770         struct device *dev = &data->client->dev;
771         struct mxt_message message;
772         int count = 10;
773         int error;
774
775         /* Read dummy message to make high CHG pin */
776         do {
777                 error = mxt_read_message(data, &message);
778                 if (error)
779                         return error;
780         } while (message.reportid != MXT_RPTID_NOMSG && --count);
781
782         if (!count) {
783                 dev_err(dev, "CHG pin isn't cleared\n");
784                 return -EBUSY;
785         }
786
787         return 0;
788 }
789
790 static int mxt_soft_reset(struct mxt_data *data, u8 value)
791 {
792         int timeout_counter = 0;
793         struct device *dev = &data->client->dev;
794
795         dev_info(dev, "Resetting chip\n");
796
797         mxt_write_object(data, MXT_GEN_COMMAND_T6,
798                         MXT_COMMAND_RESET, value);
799
800         if (data->pdata->read_chg == NULL) {
801                 msleep(MXT_RESET_NOCHGREAD);
802         } else {
803                 msleep(MXT_RESET_TIME);
804
805                 timeout_counter = 0;
806                 while ((timeout_counter++ <= 100) && data->pdata->read_chg())
807                         msleep(20);
808                 if (timeout_counter > 100) {
809                         dev_err(dev, "No response after reset!\n");
810                         return -EIO;
811                 }
812         }
813
814         return 0;
815 }
816
817 static int mxt_read_current_crc(struct mxt_data *data, u32 *crc)
818 {
819         struct device *dev = &data->client->dev;
820         int error;
821         struct mxt_message message;
822         struct mxt_object *object;
823
824         object = mxt_get_object(data, MXT_GEN_COMMAND_T6);
825         if (!object)
826                 return -EIO;
827
828         /* Try to read the config checksum of the existing cfg */
829         mxt_write_object(data, MXT_GEN_COMMAND_T6,
830                 MXT_COMMAND_REPORTALL, 1);
831
832         msleep(30);
833
834         /* Read message from command processor, which only has one report ID */
835         error = mxt_read_message_reportid(data, &message, object->max_reportid);
836         if (error) {
837                 dev_err(dev, "Failed to retrieve CRC\n");
838                 return error;
839         }
840
841         /* Bytes 1-3 are the checksum. */
842         *crc = message.message[1] | (message.message[2] << 8) |
843                 (message.message[3] << 16);
844
845         return 0;
846 }
847
848 int mxt_download_config(struct mxt_data *data, const char *fn)
849 {
850         struct device *dev = &data->client->dev;
851         struct mxt_info cfg_info;
852         struct mxt_object *object;
853         const struct firmware *cfg = NULL;
854         int ret;
855         int offset;
856         int pos;
857         int i;
858         u32 current_crc, info_crc, config_crc;
859         unsigned int type, instance, size;
860         u8 val;
861         u16 reg;
862
863         ret = request_firmware(&cfg, fn, dev);
864         if (ret < 0) {
865                 dev_err(dev, "Failure to request config file %s\n", fn);
866                 return 0;
867         }
868
869         ret = mxt_read_current_crc(data, &current_crc);
870         if (ret)
871                 return ret;
872
873         if (strncmp(cfg->data, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
874                 dev_err(dev, "Unrecognised config file\n");
875                 ret = -EINVAL;
876                 goto release;
877         }
878
879         pos = strlen(MXT_CFG_MAGIC);
880
881         /* Load information block and check */
882         for (i = 0; i < sizeof(struct mxt_info); i++) {
883                 ret = sscanf(cfg->data + pos, "%hhx%n",
884                              (unsigned char *)&cfg_info + i,
885                              &offset);
886                 if (ret != 1) {
887                         dev_err(dev, "Bad format\n");
888                         ret = -EINVAL;
889                         goto release;
890                 }
891
892                 pos += offset;
893         }
894
895         if (cfg_info.family_id != data->info.family_id) {
896                 dev_err(dev, "Family ID mismatch!\n");
897                 ret = -EINVAL;
898                 goto release;
899         }
900
901         if (cfg_info.variant_id != data->info.variant_id) {
902                 dev_err(dev, "Variant ID mismatch!\n");
903                 ret = -EINVAL;
904                 goto release;
905         }
906
907         if (cfg_info.version != data->info.version)
908                 dev_err(dev, "Warning: version mismatch!\n");
909
910         if (cfg_info.build != data->info.build)
911                 dev_err(dev, "Warning: build num mismatch!\n");
912
913         ret = sscanf(cfg->data + pos, "%x%n", &info_crc, &offset);
914         if (ret != 1) {
915                 dev_err(dev, "Bad format\n");
916                 ret = -EINVAL;
917                 goto release;
918         }
919         pos += offset;
920
921         /* Check config CRC */
922         ret = sscanf(cfg->data + pos, "%x%n", &config_crc, &offset);
923         if (ret != 1) {
924                 dev_err(dev, "Bad format\n");
925                 ret = -EINVAL;
926                 goto release;
927         }
928         pos += offset;
929
930         if (current_crc == config_crc) {
931                 dev_info(dev, "Config CRC 0x%06X: OK\n", current_crc);
932                 ret = 0;
933                 goto release;
934         } else {
935                 dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n",
936                          current_crc, config_crc);
937         }
938
939         while (pos < cfg->size) {
940                 /* Read type, instance, length */
941                 ret = sscanf(cfg->data + pos, "%x %x %x%n",
942                              &type, &instance, &size, &offset);
943                 if (ret == 0) {
944                         /* EOF */
945                         ret = 1;
946                         goto release;
947                 } else if (ret != 3) {
948                         dev_err(dev, "Bad format\n");
949                         ret = -EINVAL;
950                         goto release;
951                 }
952                 pos += offset;
953
954                 object = mxt_get_object(data, type);
955                 if (!object) {
956                         ret = -EINVAL;
957                         goto release;
958                 }
959
960                 if (size > object->size) {
961                         dev_err(dev, "Object length exceeded!\n");
962                         ret = -EINVAL;
963                         goto release;
964                 }
965
966                 if (instance >= object->instances) {
967                         dev_err(dev, "Object instances exceeded!\n");
968                         ret = -EINVAL;
969                         goto release;
970                 }
971
972                 reg = object->start_address + object->size * instance;
973
974                 for (i = 0; i < size; i++) {
975                         ret = sscanf(cfg->data + pos, "%hhx%n",
976                                      &val,
977                                      &offset);
978                         if (ret != 1) {
979                                 dev_err(dev, "Bad format\n");
980                                 ret = -EINVAL;
981                                 goto release;
982                         }
983
984                         ret = mxt_write_reg(data->client, reg + i, val);
985                         if (ret)
986                                 goto release;
987
988                         pos += offset;
989                 }
990
991                 /* If firmware is upgraded, new bytes may be added to end of
992                  * objects. It is generally forward compatible to zero these
993                  * bytes - previous behaviour will be retained. However
994                  * this does invalidate the CRC and will force a config
995                  * download every time until the configuration is updated */
996                 if (size < object->size) {
997                         dev_info(dev, "Warning: zeroing %d byte(s) in T%d\n",
998                                  object->size - size, type);
999
1000                         for (i = size + 1; i < object->size; i++) {
1001                                 ret = mxt_write_reg(data->client, reg + i, 0);
1002                                 if (ret)
1003                                         goto release;
1004                         }
1005                 }
1006         }
1007
1008 release:
1009         release_firmware(cfg);
1010         return ret;
1011 }
1012
1013 static int mxt_set_power_cfg(struct mxt_data *data, u8 mode)
1014 {
1015         struct device *dev = &data->client->dev;
1016         int error;
1017         u8 actv_cycle_time;
1018         u8 idle_cycle_time;
1019
1020         if (data->state != APPMODE) {
1021                 dev_err(dev, "Not in APPMODE\n");
1022                 return -EINVAL;
1023         }
1024
1025         switch (mode) {
1026         case MXT_POWER_CFG_DEEPSLEEP:
1027                 actv_cycle_time = 0;
1028                 idle_cycle_time = 0;
1029                 break;
1030         case MXT_POWER_CFG_RUN:
1031         default:
1032                 actv_cycle_time = data->actv_cycle_time;
1033                 idle_cycle_time = data->idle_cycle_time;
1034                 break;
1035         }
1036
1037         error = mxt_write_object(data, MXT_GEN_POWER_T7, MXT_POWER_ACTVACQINT,
1038                                  actv_cycle_time);
1039         if (error)
1040                 goto i2c_error;
1041
1042         error = mxt_write_object(data, MXT_GEN_POWER_T7, MXT_POWER_IDLEACQINT,
1043                                  idle_cycle_time);
1044         if (error)
1045                 goto i2c_error;
1046
1047         dev_dbg(dev, "Set ACTV %d, IDLE %d\n", actv_cycle_time, idle_cycle_time);
1048
1049         data->is_stopped = (mode == MXT_POWER_CFG_DEEPSLEEP) ? 1 : 0;
1050
1051         return 0;
1052
1053 i2c_error:
1054         dev_err(dev, "Failed to set power cfg\n");
1055         return error;
1056 }
1057
1058 static int mxt_read_power_cfg(struct mxt_data *data, u8 *actv_cycle_time,
1059                                 u8 *idle_cycle_time)
1060 {
1061         int error;
1062
1063         error = mxt_read_object(data, MXT_GEN_POWER_T7,
1064                                 MXT_POWER_ACTVACQINT,
1065                                 actv_cycle_time);
1066         if (error)
1067                 return error;
1068
1069         error = mxt_read_object(data, MXT_GEN_POWER_T7,
1070                                 MXT_POWER_IDLEACQINT,
1071                                 idle_cycle_time);
1072         if (error)
1073                 return error;
1074
1075         return 0;
1076 }
1077
1078 static int mxt_check_power_cfg_post_reset(struct mxt_data *data)
1079 {
1080         struct device *dev = &data->client->dev;
1081         int error;
1082
1083         error = mxt_read_power_cfg(data, &data->actv_cycle_time,
1084                                    &data->idle_cycle_time);
1085         if (error)
1086                 return error;
1087
1088         /* Power config is zero, select free run */
1089         if (data->actv_cycle_time == 0 || data->idle_cycle_time == 0) {
1090                 dev_dbg(dev, "Overriding power cfg to free run\n");
1091                 data->actv_cycle_time = 255;
1092                 data->idle_cycle_time = 255;
1093
1094                 error = mxt_set_power_cfg(data, MXT_POWER_CFG_RUN);
1095                 if (error)
1096                         return error;
1097         }
1098
1099         return 0;
1100 }
1101
1102 static int mxt_probe_power_cfg(struct mxt_data *data)
1103 {
1104         int error;
1105
1106         error = mxt_read_power_cfg(data, &data->actv_cycle_time,
1107                                    &data->idle_cycle_time);
1108         if (error)
1109                 return error;
1110
1111         /* If in deep sleep mode, attempt reset */
1112         if (data->actv_cycle_time == 0 || data->idle_cycle_time == 0) {
1113                 error = mxt_soft_reset(data, MXT_RESET_VALUE);
1114                 if (error)
1115                         return error;
1116
1117                 error = mxt_check_power_cfg_post_reset(data);
1118                 if (error)
1119                         return error;
1120         }
1121
1122         return 0;
1123 }
1124
1125 static int mxt_check_reg_init(struct mxt_data *data)
1126 {
1127         struct device *dev = &data->client->dev;
1128         int timeout_counter = 0;
1129         int ret;
1130         u8 command_register;
1131
1132         ret = mxt_download_config(data, MXT_CFG_NAME);
1133         if (ret < 0)
1134                 return ret;
1135         else if (ret == 0)
1136                 /* CRC matched, or no config file, or config parse failure
1137                  * - no need to reset */
1138                 return 0;
1139
1140         /* Backup to memory */
1141         mxt_write_object(data, MXT_GEN_COMMAND_T6,
1142                         MXT_COMMAND_BACKUPNV,
1143                         MXT_BACKUP_VALUE);
1144         msleep(MXT_BACKUP_TIME);
1145         do {
1146                 ret =  mxt_read_object(data, MXT_GEN_COMMAND_T6,
1147                                         MXT_COMMAND_BACKUPNV,
1148                                         &command_register);
1149                 if (ret)
1150                         return ret;
1151                 msleep(20);
1152         } while ((command_register != 0) && (timeout_counter++ <= 100));
1153         if (timeout_counter > 100) {
1154                 dev_err(dev, "No response after backup!\n");
1155                 return -EIO;
1156         }
1157
1158         ret = mxt_soft_reset(data, MXT_RESET_VALUE);
1159         if (ret)
1160                 return ret;
1161
1162         ret = mxt_check_power_cfg_post_reset(data);
1163         if (ret)
1164                 return ret;
1165
1166         return 0;
1167 }
1168
1169 static int mxt_get_info(struct mxt_data *data)
1170 {
1171         struct i2c_client *client = data->client;
1172         struct mxt_info *info = &data->info;
1173         int error;
1174         u8 val;
1175
1176         error = mxt_read_reg(client, MXT_FAMILY_ID, &val);
1177         if (error)
1178                 return error;
1179         info->family_id = val;
1180
1181         error = mxt_read_reg(client, MXT_VARIANT_ID, &val);
1182                 if (error)
1183                         return error;
1184         info->variant_id = val;
1185
1186         error = mxt_read_reg(client, MXT_VERSION, &val);
1187                 if (error)
1188                         return error;
1189         info->version = val;
1190
1191         error = mxt_read_reg(client, MXT_BUILD, &val);
1192         if (error)
1193                 return error;
1194         info->build = val;
1195
1196         error = mxt_read_reg(client, MXT_OBJECT_NUM, &val);
1197         if (error)
1198                 return error;
1199         info->object_num = val;
1200
1201         return 0;
1202 }
1203
1204 static int mxt_get_object_table(struct mxt_data *data)
1205 {
1206         struct device *dev = &data->client->dev;
1207         int error;
1208         int i;
1209         u16 reg;
1210         u16 end_address;
1211         u8 reportid = 0;
1212         u8 buf[MXT_OBJECT_SIZE];
1213         data->mem_size = 0;
1214
1215         for (i = 0; i < data->info.object_num; i++) {
1216                 struct mxt_object *object = data->object_table + i;
1217
1218                 reg = MXT_OBJECT_START + MXT_OBJECT_SIZE * i;
1219                 error = mxt_read_object_table(data->client, reg, buf);
1220         if (error)
1221                 return error;
1222
1223                 object->type = buf[0];
1224                 object->start_address = (buf[2] << 8) | buf[1];
1225                 object->size = buf[3] + 1;
1226                 object->instances = buf[4] + 1;
1227                 object->num_report_ids = buf[5];
1228
1229                 if (object->num_report_ids) {
1230                         reportid += object->num_report_ids * object->instances;
1231                         object->max_reportid = reportid;
1232                         object->min_reportid = object->max_reportid -
1233                                 object->instances * object->num_report_ids + 1;
1234                 }
1235
1236                 end_address = object->start_address
1237                         + object->size * object->instances - 1;
1238
1239                 if (end_address >= data->mem_size)
1240                         data->mem_size = end_address + 1;
1241
1242                 dev_dbg(dev, "T%u, start:%u size:%u instances:%u "
1243                         "min_reportid:%u max_reportid:%u\n",
1244                         object->type, object->start_address, object->size,
1245                         object->instances,
1246                         object->min_reportid, object->max_reportid);
1247         }
1248
1249         /* Store maximum reportid */
1250         data->max_reportid = reportid;
1251
1252         return 0;
1253 }
1254
1255 static int mxt_read_resolution(struct mxt_data *data)
1256 {
1257         struct i2c_client *client = data->client;
1258         int error;
1259         unsigned int x_range, y_range;
1260         unsigned char orient;
1261         unsigned char val;
1262
1263         /* Update matrix size in info struct */
1264         error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, &val);
1265         if (error)
1266                 return error;
1267         data->info.matrix_xsize = val;
1268
1269         error = mxt_read_reg(client, MXT_MATRIX_Y_SIZE, &val);
1270         if (error)
1271                 return error;
1272         data->info.matrix_ysize = val;
1273
1274         /* Read X/Y size of touchscreen */
1275         error =  mxt_read_object(data, MXT_TOUCH_MULTI_T9,
1276                         MXT_TOUCH_XRANGE_MSB, &val);
1277         if (error)
1278                 return error;
1279         x_range = val << 8;
1280
1281         error =  mxt_read_object(data, MXT_TOUCH_MULTI_T9,
1282                         MXT_TOUCH_XRANGE_LSB, &val);
1283         if (error)
1284                 return error;
1285         x_range |= val;
1286
1287         error =  mxt_read_object(data, MXT_TOUCH_MULTI_T9,
1288                         MXT_TOUCH_YRANGE_MSB, &val);
1289         if (error)
1290                 return error;
1291         y_range = val << 8;
1292
1293         error =  mxt_read_object(data, MXT_TOUCH_MULTI_T9,
1294                         MXT_TOUCH_YRANGE_LSB, &val);
1295         if (error)
1296                 return error;
1297         y_range |= val;
1298
1299         error =  mxt_read_object(data, MXT_TOUCH_MULTI_T9,
1300                         MXT_TOUCH_ORIENT, &orient);
1301         if (error)
1302                 return error;
1303
1304         /* Handle default values */
1305         if (x_range == 0)
1306                 x_range = 1023;
1307
1308         if (y_range == 0)
1309                 y_range = 1023;
1310
1311         if (orient & MXT_XY_SWITCH) {
1312                 data->max_x = y_range;
1313                 data->max_y = x_range;
1314         } else {
1315                 data->max_x = x_range;
1316                 data->max_y = y_range;
1317         }
1318
1319         dev_info(&client->dev,
1320                         "Matrix Size X%uY%u Touchscreen size X%uY%u\n",
1321                         data->info.matrix_xsize, data->info.matrix_ysize,
1322                         data->max_x, data->max_y);
1323
1324         return 0;
1325 }
1326
1327 static int mxt_initialize(struct mxt_data *data)
1328 {
1329         struct i2c_client *client = data->client;
1330         struct mxt_info *info = &data->info;
1331         int error;
1332
1333         error = mxt_get_info(data);
1334         if (error) {
1335                 error = mxt_probe_bootloader(data);
1336
1337                 if (error) {
1338                         return error;
1339                 } else {
1340                         data->state = BOOTLOADER;
1341                         return 0;
1342                 }
1343         }
1344
1345         dev_info(&client->dev,
1346                 "Family ID: %d Variant ID: %d Version: %d.%d.%02X "
1347                 "Object Num: %d\n",
1348                 info->family_id, info->variant_id,
1349                 info->version >> 4, info->version & 0xf,
1350                 info->build, info->object_num);
1351
1352         data->state = APPMODE;
1353
1354         data->object_table = kcalloc(info->object_num,
1355                                      sizeof(struct mxt_object),
1356                                      GFP_KERNEL);
1357         if (!data->object_table) {
1358                 dev_err(&client->dev, "Failed to allocate memory\n");
1359                 return -ENOMEM;
1360         }
1361
1362         /* Get object table information */
1363         error = mxt_get_object_table(data);
1364         if (error) {
1365                 dev_err(&client->dev, "Error %d reading object table\n", error);
1366                 return error;
1367         }
1368
1369         error = mxt_probe_power_cfg(data);
1370         if (error) {
1371                 dev_err(&client->dev, "Failed to initialize power cfg\n");
1372                 return error;
1373         }
1374
1375         /* Check register init values */
1376         error = mxt_check_reg_init(data);
1377         if (error) {
1378                 dev_err(&client->dev, "Failed to initialize config\n");
1379                 return error;
1380         }
1381
1382         error = mxt_read_resolution(data);
1383         if (error) {
1384                 dev_err(&client->dev, "Failed to initialize screen size\n");
1385                 return error;
1386         }
1387
1388         return 0;
1389 }
1390
1391 static int mxt_load_fw(struct device *dev, const char *fn)
1392 {
1393         struct mxt_data *data = dev_get_drvdata(dev);
1394         const struct firmware *fw = NULL;
1395         unsigned int frame_size;
1396         unsigned int pos = 0;
1397         unsigned int retry = 0;
1398         unsigned int frame = 0;
1399         int ret;
1400
1401         ret = request_firmware(&fw, fn, dev);
1402         if (ret < 0) {
1403                 dev_err(dev, "Unable to open firmware %s\n", fn);
1404                 return ret;
1405         }
1406
1407         if (data->state != BOOTLOADER) {
1408                 /* Change to the bootloader mode */
1409                 ret = mxt_soft_reset(data, MXT_BOOT_VALUE);
1410                 if (ret)
1411                         goto release_firmware;
1412
1413                 ret = mxt_get_bootloader_address(data);
1414                 if (ret)
1415                         goto release_firmware;
1416
1417                 data->state = BOOTLOADER;
1418         }
1419
1420         ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD);
1421         if (ret) {
1422                 /* Bootloader may still be unlocked from previous update
1423                  * attempt */
1424                 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA);
1425                 if (ret) {
1426                         data->state = FAILED;
1427                         goto release_firmware;
1428                 }
1429         } else {
1430                 dev_info(dev, "Unlocking bootloader\n");
1431
1432                 /* Unlock bootloader */
1433                 ret = mxt_unlock_bootloader(data);
1434                 if (ret) {
1435                         data->state = FAILED;
1436                         goto release_firmware;
1437                 }
1438         }
1439
1440         while (pos < fw->size) {
1441                 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA);
1442                 if (ret) {
1443                         data->state = FAILED;
1444                         goto release_firmware;
1445                 }
1446
1447                 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
1448
1449                 /* Take account of CRC bytes */
1450                 frame_size += 2;
1451
1452                 /* Write one frame to device */
1453                 ret = mxt_bootloader_write(data, fw->data + pos, frame_size);
1454                 if (ret) {
1455                         data->state = FAILED;
1456                         goto release_firmware;
1457                 }
1458
1459                 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS);
1460                 if (ret) {
1461                         retry++;
1462
1463                         /* Back off by 20ms per retry */
1464                         msleep(retry * 20);
1465
1466                         if (retry > 20) {
1467                                 data->state = FAILED;
1468                                 goto release_firmware;
1469                         }
1470                 } else {
1471                         retry = 0;
1472                         pos += frame_size;
1473                         frame++;
1474                 }
1475
1476                 if (frame % 10 == 0)
1477                         dev_info(dev, "Updated %d frames, %d/%zd bytes\n",
1478                                  frame, pos, fw->size);
1479
1480         }
1481
1482         dev_info(dev, "Finished, sent %d frames, %zd bytes\n", frame, pos);
1483
1484         data->state = INIT;
1485
1486 release_firmware:
1487         release_firmware(fw);
1488         return ret;
1489 }
1490
1491 static ssize_t mxt_update_fw_store(struct device *dev,
1492                                         struct device_attribute *attr,
1493                                         const char *buf, size_t count)
1494 {
1495         struct mxt_data *data = dev_get_drvdata(dev);
1496         int error;
1497
1498         disable_irq(data->irq);
1499
1500         error = mxt_load_fw(dev, MXT_FW_NAME);
1501         if (error) {
1502                 dev_err(dev, "The firmware update failed(%d)\n", error);
1503                 count = error;
1504         } else {
1505                 dev_info(dev, "The firmware update succeeded\n");
1506
1507                 /* Wait for reset */
1508                 msleep(MXT_FWRESET_TIME);
1509
1510                 kfree(data->object_table);
1511                 data->object_table = NULL;
1512
1513                 mxt_initialize(data);
1514         }
1515
1516         if (data->state == APPMODE) {
1517                 enable_irq(data->irq);
1518
1519                 error = mxt_make_highchg(data);
1520                 if (error)
1521                         return error;
1522         }
1523
1524         return count;
1525 }
1526
1527 static ssize_t mxt_pause_show(struct device *dev,
1528         struct device_attribute *attr, char *buf)
1529 {
1530         struct mxt_data *data = dev_get_drvdata(dev);
1531         ssize_t count;
1532         char c;
1533
1534         c = data->driver_paused ? '1' : '0';
1535         count = sprintf(buf, "%c\n", c);
1536
1537         return count;
1538 }
1539
1540 static ssize_t mxt_pause_store(struct device *dev,
1541         struct device_attribute *attr, const char *buf, size_t count)
1542 {
1543         struct mxt_data *data = dev_get_drvdata(dev);
1544         int i;
1545
1546         if (sscanf(buf, "%u", &i) == 1 && i < 2) {
1547                 data->driver_paused = (i == 1);
1548                 dev_dbg(dev, "%s\n", i ? "paused" : "unpaused");
1549                 return count;
1550         } else {
1551                 dev_dbg(dev, "pause_driver write error\n");
1552                 return -EINVAL;
1553         }
1554 }
1555
1556 static ssize_t mxt_debug_enable_show(struct device *dev,
1557         struct device_attribute *attr, char *buf)
1558 {
1559         struct mxt_data *data = dev_get_drvdata(dev);
1560         int count;
1561         char c;
1562
1563         c = data->debug_enabled ? '1' : '0';
1564         count = sprintf(buf, "%c\n", c);
1565
1566         return count;
1567 }
1568
1569 static ssize_t mxt_debug_enable_store(struct device *dev,
1570         struct device_attribute *attr, const char *buf, size_t count)
1571 {
1572         struct mxt_data *data = dev_get_drvdata(dev);
1573         int i;
1574
1575         if (sscanf(buf, "%u", &i) == 1 && i < 2) {
1576                 data->debug_enabled = (i == 1);
1577
1578                 dev_dbg(dev, "%s\n", i ? "debug enabled" : "debug disabled");
1579                 return count;
1580         } else {
1581                 dev_dbg(dev, "debug_enabled write error\n");
1582                 return -EINVAL;
1583         }
1584 }
1585
1586 static int mxt_check_mem_access_params(struct mxt_data *data, loff_t off,
1587                                        size_t *count)
1588 {
1589         if (data->state != APPMODE) {
1590                 dev_err(&data->client->dev, "Not in APPMODE\n");
1591                 return -EINVAL;
1592         }
1593
1594         if (off >= data->mem_size)
1595                 return -EIO;
1596
1597         if (off + *count > data->mem_size)
1598                 *count = data->mem_size - off;
1599
1600         if (*count > MXT_MAX_BLOCK_WRITE)
1601                 *count = MXT_MAX_BLOCK_WRITE;
1602
1603         return 0;
1604 }
1605
1606 static ssize_t mxt_mem_access_read(struct file *filp, struct kobject *kobj,
1607         struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
1608 {
1609         struct device *dev = container_of(kobj, struct device, kobj);
1610         struct mxt_data *data = dev_get_drvdata(dev);
1611         int ret = 0;
1612
1613         ret = mxt_check_mem_access_params(data, off, &count);
1614         if (ret < 0)
1615                 return ret;
1616
1617         if (count > 0)
1618                 ret = __mxt_read_reg(data->client, off, count, buf);
1619
1620         return ret == 0 ? count : ret;
1621 }
1622
1623 static ssize_t mxt_mem_access_write(struct file *filp, struct kobject *kobj,
1624         struct bin_attribute *bin_attr, char *buf, loff_t off,
1625         size_t count)
1626 {
1627         struct device *dev = container_of(kobj, struct device, kobj);
1628         struct mxt_data *data = dev_get_drvdata(dev);
1629         int ret = 0;
1630
1631         ret = mxt_check_mem_access_params(data, off, &count);
1632         if (ret < 0)
1633                 return ret;
1634
1635         if (count > 0)
1636                 ret = mxt_write_block(data->client, off, count, buf);
1637
1638         return ret == 0 ? count : 0;
1639 }
1640
1641 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
1642 static DEVICE_ATTR(debug_enable, S_IWUSR | S_IRUSR, mxt_debug_enable_show,
1643                    mxt_debug_enable_store);
1644 static DEVICE_ATTR(pause_driver, S_IWUSR | S_IRUSR, mxt_pause_show,
1645                    mxt_pause_store);
1646
1647 static struct attribute *mxt_attrs[] = {
1648         &dev_attr_update_fw.attr,
1649         &dev_attr_debug_enable.attr,
1650         &dev_attr_pause_driver.attr,
1651         NULL
1652 };
1653
1654 static const struct attribute_group mxt_attr_group = {
1655         .attrs = mxt_attrs,
1656 };
1657
1658 static void mxt_start(struct mxt_data *data)
1659 {
1660         int error;
1661         struct device *dev = &data->client->dev;
1662
1663         if (data->is_stopped == 0)
1664                 return;
1665
1666         error = mxt_set_power_cfg(data, MXT_POWER_CFG_RUN);
1667         if (error)
1668                 return;
1669
1670         /* At this point, it may be necessary to clear state
1671          * by disabling/re-enabling the noise suppression object */
1672
1673         /* Recalibrate since chip has been in deep sleep */
1674         error = mxt_write_object(data, MXT_GEN_COMMAND_T6,
1675                 MXT_COMMAND_CALIBRATE, 1);
1676
1677         if (!error)
1678                 dev_dbg(dev, "MXT started\n");
1679 }
1680
1681 static void mxt_stop(struct mxt_data *data)
1682 {
1683         int error;
1684         struct device *dev = &data->client->dev;
1685
1686         if (data->is_stopped)
1687                 return;
1688
1689         error = mxt_set_power_cfg(data, MXT_POWER_CFG_DEEPSLEEP);
1690
1691         if (!error)
1692                 dev_dbg(dev, "MXT suspended\n");
1693 }
1694
1695 static int mxt_input_open(struct input_dev *dev)
1696 {
1697         struct mxt_data *data = input_get_drvdata(dev);
1698
1699         mxt_start(data);
1700
1701         return 0;
1702 }
1703
1704 static void mxt_input_close(struct input_dev *dev)
1705 {
1706         struct mxt_data *data = input_get_drvdata(dev);
1707
1708         mxt_stop(data);
1709 }
1710
1711 static int __devinit mxt_probe(struct i2c_client *client,
1712                 const struct i2c_device_id *id)
1713 {
1714         const struct mxt_platform_data *pdata = client->dev.platform_data;
1715         struct mxt_data *data;
1716         struct input_dev *input_dev;
1717         int error;
1718
1719         if (!pdata)
1720                 return -EINVAL;
1721
1722         data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
1723         input_dev = input_allocate_device();
1724         if (!data || !input_dev) {
1725                 dev_err(&client->dev, "Failed to allocate memory\n");
1726                 error = -ENOMEM;
1727                 goto err_free_mem;
1728         }
1729
1730         data->state = INIT;
1731
1732         data->client = client;
1733         data->input_dev = input_dev;
1734         data->pdata = pdata;
1735         data->irq = client->irq;
1736
1737         /* Initialize i2c device */
1738         error = mxt_initialize(data);
1739         if (error)
1740                 goto err_free_object;
1741
1742         /* Initialize input device */
1743         input_dev->name = "Atmel maXTouch Touchscreen";
1744         input_dev->id.bustype = BUS_I2C;
1745         input_dev->dev.parent = &client->dev;
1746         input_dev->open = mxt_input_open;
1747         input_dev->close = mxt_input_close;
1748
1749         __set_bit(EV_ABS, input_dev->evbit);
1750         __set_bit(EV_KEY, input_dev->evbit);
1751         __set_bit(BTN_TOUCH, input_dev->keybit);
1752
1753         /* For single touch */
1754         input_set_abs_params(input_dev, ABS_X,
1755                              0, data->max_x, 0, 0);
1756         input_set_abs_params(input_dev, ABS_Y,
1757                              0, data->max_y, 0, 0);
1758         input_set_abs_params(input_dev, ABS_PRESSURE,
1759                              0, 255, 0, 0);
1760
1761         /* For multi touch */
1762         input_mt_init_slots(input_dev, MXT_MAX_FINGER);
1763         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1764                              0, MXT_MAX_AREA, 0, 0);
1765         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1766                              0, data->max_x, 0, 0);
1767         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1768                              0, data->max_y, 0, 0);
1769         input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1770                              0, 255, 0, 0);
1771
1772         input_set_drvdata(input_dev, data);
1773         i2c_set_clientdata(client, data);
1774
1775         error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
1776                         pdata->irqflags, client->dev.driver->name, data);
1777         if (error) {
1778                 dev_err(&client->dev, "Error %d registering irq\n", error);
1779                 goto err_free_object;
1780         }
1781
1782         if (data->state == APPMODE) {
1783                 error = mxt_make_highchg(data);
1784                 if (error)
1785                         goto err_free_irq;
1786         }
1787
1788         error = input_register_device(input_dev);
1789         if (error) {
1790                 dev_err(&client->dev, "Error %d registering input device\n",
1791                         error);
1792                 goto err_free_irq;
1793         }
1794
1795         error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
1796         if (error) {
1797                 dev_err(&client->dev, "Failure %d creating sysfs group\n",
1798                         error);
1799                 goto err_unregister_device;
1800         }
1801
1802         sysfs_bin_attr_init(&data->mem_access_attr);
1803         data->mem_access_attr.attr.name = "mem_access";
1804         data->mem_access_attr.attr.mode = S_IRUGO | S_IWUSR;
1805         data->mem_access_attr.read = mxt_mem_access_read;
1806         data->mem_access_attr.write = mxt_mem_access_write;
1807         data->mem_access_attr.size = data->mem_size;
1808
1809         if (sysfs_create_bin_file(&client->dev.kobj,
1810                                   &data->mem_access_attr) < 0) {
1811                 dev_err(&client->dev, "Failed to create %s\n",
1812                         data->mem_access_attr.attr.name);
1813                 goto err_remove_sysfs_group;
1814         }
1815
1816         return 0;
1817
1818 err_remove_sysfs_group:
1819         sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
1820 err_unregister_device:
1821         input_unregister_device(input_dev);
1822         input_dev = NULL;
1823 err_free_irq:
1824         free_irq(client->irq, data);
1825 err_free_object:
1826         kfree(data->object_table);
1827 err_free_mem:
1828         input_free_device(input_dev);
1829         kfree(data);
1830         return error;
1831 }
1832
1833 static int __devexit mxt_remove(struct i2c_client *client)
1834 {
1835         struct mxt_data *data = i2c_get_clientdata(client);
1836
1837         sysfs_remove_bin_file(&client->dev.kobj, &data->mem_access_attr);
1838         sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
1839         free_irq(data->irq, data);
1840         input_unregister_device(data->input_dev);
1841         kfree(data->object_table);
1842         kfree(data);
1843
1844         return 0;
1845 }
1846
1847 #ifdef CONFIG_PM_SLEEP
1848 static int mxt_suspend(struct device *dev)
1849 {
1850         struct i2c_client *client = to_i2c_client(dev);
1851         struct mxt_data *data = i2c_get_clientdata(client);
1852         struct input_dev *input_dev = data->input_dev;
1853
1854         mutex_lock(&input_dev->mutex);
1855
1856         if (input_dev->users)
1857                 mxt_stop(data);
1858
1859         mutex_unlock(&input_dev->mutex);
1860
1861         return 0;
1862 }
1863
1864 static int mxt_resume(struct device *dev)
1865 {
1866         struct i2c_client *client = to_i2c_client(dev);
1867         struct mxt_data *data = i2c_get_clientdata(client);
1868         struct input_dev *input_dev = data->input_dev;
1869
1870         mutex_lock(&input_dev->mutex);
1871
1872         if (input_dev->users)
1873                 mxt_start(data);
1874
1875         mutex_unlock(&input_dev->mutex);
1876
1877         return 0;
1878 }
1879 #endif
1880
1881 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
1882
1883 static const struct i2c_device_id mxt_id[] = {
1884         { "qt602240_ts", 0 },
1885         { "atmel_mxt_ts", 0 },
1886         { "mXT224", 0 },
1887         { }
1888 };
1889 MODULE_DEVICE_TABLE(i2c, mxt_id);
1890
1891 static struct i2c_driver mxt_driver = {
1892         .driver = {
1893                 .name   = "atmel_mxt_ts",
1894                 .owner  = THIS_MODULE,
1895                 .pm     = &mxt_pm_ops,
1896         },
1897         .probe          = mxt_probe,
1898         .remove         = __devexit_p(mxt_remove),
1899         .id_table       = mxt_id,
1900 };
1901
1902 static int __init mxt_init(void)
1903 {
1904         return i2c_add_driver(&mxt_driver);
1905 }
1906
1907 static void __exit mxt_exit(void)
1908 {
1909         i2c_del_driver(&mxt_driver);
1910 }
1911
1912 module_init(mxt_init);
1913 module_exit(mxt_exit);
1914
1915 /* Module information */
1916 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
1917 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
1918 MODULE_LICENSE("GPL");