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