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