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