Fcet6Unf

1/*
2 * Atmel maXTouch Touchscreen driver
3 *
4 * Copyright (C) 2010 Samsung Electronics Co.Ltd
5 * Copyright (C) 2011 Atmel Corporation
6 * Author: Joonyoung Shim <jy0922.shim@samsung.com>
7 * Copyright (C) 2015 XiaoMi, Inc.
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_xiaomi.h>
22#include <linux/debugfs.h>
23#include <linux/input/mt.h>
24#include <linux/interrupt.h>
25#include <linux/slab.h>
26#include <linux/regulator/consumer.h>
27#include <linux/gpio.h>
28#include <linux/string.h>
29#include <linux/of_gpio.h>
30#include <asm/bootinfo.h>
31#include <mach/gpiomux.h>
32#ifdef CONFIG_FB
33#include <linux/notifier.h>
34#include <linux/fb.h>
35#endif
36#ifdef CONFIG_PREVENT_SLEEP
37#include <linux/input/sweep2wake.h>
38#include <linux/input/doubletap2wake.h>
39#include <linux/input/wake_helpers.h>
40#endif
41
42/* Version */
43#define MXT_VER_20		20
44#define MXT_VER_21		21
45#define MXT_VER_22		22
46
47/* Firmware files */
48#define MXT_FW_NAME		"maxtouch.fw"
49#define MXT_CFG_MAGIC		"OBP_RAW V1"
50
51#define REV_D	0x32
52
53/* Registers */
54#define MXT_FAMILY_ID		0x00
55#define MXT_VARIANT_ID		0x01
56#define MXT_VERSION		0x02
57#define MXT_BUILD		0x03
58#define MXT_MATRIX_X_SIZE	0x04
59#define MXT_MATRIX_Y_SIZE	0x05
60#define MXT_OBJECT_NUM		0x06
61#define MXT_OBJECT_START	0x07
62
63#define MXT_OBJECT_SIZE		6
64
65#define MXT_MAX_BLOCK_WRITE	256
66
67/* Object types */
68#define MXT_DEBUG_DIAGNOSTIC_T37	37
69#define MXT_SPT_USERDATA_T38		38
70#define MXT_GEN_MESSAGE_T5		5
71#define MXT_GEN_COMMAND_T6		6
72#define MXT_GEN_POWER_T7		7
73#define MXT_GEN_ACQUIRE_T8		8
74#define MXT_GEN_DATASOURCE_T53		53
75#define MXT_TOUCH_MULTI_T9		9
76#define MXT_TOUCH_KEYARRAY_T15		15
77#define MXT_TOUCH_PROXIMITY_T23		23
78#define MXT_TOUCH_PROXKEY_T52		52
79#define MXT_PROCI_GRIPFACE_T20		20
80#define MXT_PROCG_NOISE_T22		22
81#define MXT_PROCI_ACTIVE_STYLUS_T63	63
82#define MXT_PROCI_ONETOUCH_T24		24
83#define MXT_PROCI_TWOTOUCH_T27		27
84#define MXT_PROCI_GRIP_T40		40
85#define MXT_PROCI_PALM_T41		41
86#define MXT_PROCI_TOUCHSUPPRESSION_T42	42
87#define MXT_PROCI_STYLUS_T47		47
88#define MXT_PROCG_NOISESUPPRESSION_T48	48
89#define MXT_SPT_COMMSCONFIG_T18		18
90#define MXT_SPT_GPIOPWM_T19		19
91#define MXT_SPT_SELFTEST_T25		25
92#define MXT_SPT_CTECONFIG_T28		28
93#define MXT_SPT_DIGITIZER_T43		43
94#define MXT_SPT_MESSAGECOUNT_T44	44
95#define MXT_SPT_CTECONFIG_T46		46
96#define MXT_SPT_NOISESUPPRESSION_T48    48
97#define MXT_PROCI_LENSBENDING_T65	65
98#define MXT_SPT_GOLDENREF_T66		66
99#define MXT_SERIALDATACOMMAND_T68	68
100#define MXT_SPT_DYMCFG_T70		70
101#define MXT_SPT_DYMDATA_T71		71
102#define MXT_PROCG_NOISESUPPRESSION_T72	72
103#define MXT_PROCI_GLOVEDETECTION_T78		78
104#define MXT_PROCI_RETRANSMISSIONCOMPENSATION_T80	80
105#define MXT_TOUCH_MORE_GESTURE_T81	81
106#define MXT_TOUCH_GESTURE_T92		92
107#define MXT_TOUCH_MULTI_T100		100
108#define MXT_SPT_TOUCHSCREENHOVER_T101	101
109#define MXT_PROCG_NOISESUPSELFCAP_T108	108
110#define MXT_SPT_SELFCAPGLOBALCONFIG_T109	109
111#define MXT_SPT_AUXTOUCHCONFIG_T104	104
112
113/* MXT_GEN_MESSAGE_T5 object */
114#define MXT_RPTID_NOMSG		0xff
115
116/* MXT_GEN_COMMAND_T6 field */
117#define MXT_COMMAND_RESET	0
118#define MXT_COMMAND_BACKUPNV	1
119#define MXT_COMMAND_CALIBRATE	2
120#define MXT_COMMAND_REPORTALL	3
121#define MXT_COMMAND_DIAGNOSTIC	5
122
123/* MXT_GEN_POWER_T7 field */
124#define MXT_POWER_IDLEACQINT	0
125#define MXT_POWER_ACTVACQINT	1
126#define MXT_POWER_ACTV2IDLETO	2
127
128#define MXT_POWER_CFG_RUN		0
129#define MXT_POWER_CFG_DEEPSLEEP		1
130
131/* MXT_GEN_ACQUIRE_T8 field */
132#define MXT_ACQUIRE_CHRGTIME	0
133#define MXT_ACQUIRE_TCHDRIFT	2
134#define MXT_ACQUIRE_DRIFTST	3
135#define MXT_ACQUIRE_TCHAUTOCAL	4
136#define MXT_ACQUIRE_SYNC	5
137#define MXT_ACQUIRE_ATCHCALST	6
138#define MXT_ACQUIRE_ATCHCALSTHR	7
139#define MXT_ACQUIRE_MEASALLOW	10
140
141/* MXT_TOUCH_MULTI_T9 field */
142#define MXT_TOUCH_CTRL		0
143#define MXT_TOUCH_XORIGIN	1
144#define MXT_TOUCH_YORIGIN	2
145#define MXT_TOUCH_XSIZE		3
146#define MXT_TOUCH_YSIZE		4
147#define MXT_TOUCH_BLEN		6
148#define MXT_TOUCH_TCHTHR	7
149#define MXT_TOUCH_TCHDI		8
150#define MXT_TOUCH_ORIENT	9
151#define MXT_TOUCH_MOVHYSTI	11
152#define MXT_TOUCH_MOVHYSTN	12
153#define MXT_TOUCH_NUMTOUCH	14
154#define MXT_TOUCH_MRGHYST	15
155#define MXT_TOUCH_MRGTHR	16
156#define MXT_TOUCH_AMPHYST	17
157#define MXT_TOUCH_XRANGE_LSB	18
158#define MXT_TOUCH_XRANGE_MSB	19
159#define MXT_TOUCH_YRANGE_LSB	20
160#define MXT_TOUCH_YRANGE_MSB	21
161#define MXT_TOUCH_XLOCLIP	22
162#define MXT_TOUCH_XHICLIP	23
163#define MXT_TOUCH_YLOCLIP	24
164#define MXT_TOUCH_YHICLIP	25
165#define MXT_TOUCH_XEDGECTRL	26
166#define MXT_TOUCH_XEDGEDIST	27
167#define MXT_TOUCH_YEDGECTRL	28
168#define MXT_TOUCH_YEDGEDIST	29
169#define MXT_TOUCH_JUMPLIMIT	30
170
171/* MXT_TOUCH_MULTI_T100 field */
172#define MXT_MULTITOUCH_CTRL		0
173#define MXT_MULTITOUCH_CFG1		1
174#define MXT_MULTITOUCH_SCRAUX			2
175#define MXT_MULTITOUCH_TCHAUX		3
176#define MXT_MULTITOUCH_TCHEVENTCFG		4
177#define MXT_MULTITOUCH_AKSCFG			5
178#define MXT_MULTITOUCH_NUMTCH		6
179#define MXT_MULTITOUCH_XYCFG		7
180#define MXT_MULTITOUCH_XORIGIN		8
181#define MXT_MULTITOUCH_XSIZE		9
182#define MXT_MULTITOUCH_XPITCH			10
183#define MXT_MULTITOUCH_XLOCLIP		11
184#define MXT_MULTITOUCH_XHICLIP		12
185#define MXT_MULTITOUCH_XRANGE_LSB		13
186#define MXT_MULTITOUCH_XRANGE_MSB		14
187#define MXT_MULTITOUCH_XEDGECFG		15
188#define MXT_MULTITOUCH_XEDGEDIST		16
189#define MXT_MULTITOUCH_DXEDGECFG		17
190#define MXT_MULTITOUCH_DXEDGEDIST		18
191#define MXT_MULTITOUCH_YORIGIN		19
192#define MXT_MULTITOUCH_YSIZE		20
193#define MXT_MULTITOUCH_YPITCH			21
194#define MXT_MULTITOUCH_YLOCLIP		22
195#define MXT_MULTITOUCH_YHICLIP		23
196#define MXT_MULTITOUCH_YRANGE_LSB		24
197#define MXT_MULTITOUCH_YRANGE_MSB		25
198#define MXT_MULTITOUCH_YEDGECFG		26
199#define MXT_MULTITOUCH_YEDGEDIST		27
200#define MXT_MULTITOUCH_GAIN		28
201#define MXT_MULTITOUCH_DXGAIN			29
202#define MXT_MULTITOUCH_TCHTHR			30
203#define MXT_MULTITOUCH_TCHHYST		31
204#define MXT_MULTITOUCH_INTTHR			32
205#define MXT_MULTITOUCH_NOISESF		33
206#define MXT_MULTITOUCH_MGRTHR		35
207#define MXT_MULTITOUCH_MRGTHRADJSTR		36
208#define MXT_MULTITOUCH_MRGHYST		37
209#define MXT_MULTITOUCH_DXTHRSF		38
210#define MXT_MULTITOUCH_TCHDIDOWN		39
211#define MXT_MULTITOUCH_TCHDIUP		40
212#define MXT_MULTITOUCH_NEXTTCHDI		41
213#define MXT_MULTITOUCH_JUMPLIMIT		43
214#define MXT_MULTITOUCH_MOVFILTER		44
215#define MXT_MULTITOUCH_MOVSMOOTH		45
216#define MXT_MULTITOUCH_MOVPRED		46
217#define MXT_MULTITOUCH_MOVHYSTILSB		47
218#define MXT_MULTITOUCH_MOVHYSTIMSB		48
219#define MXT_MULTITOUCH_MOVHYSTNLSB		49
220#define MXT_MULTITOUCH_MOVHYSTNMSB		50
221#define MXT_MULTITOUCH_AMPLHYST		51
222#define MXT_MULTITOUCH_SCRAREAHYST		52
223
224/* MXT_TOUCH_KEYARRAY_T15 */
225#define MXT_KEYARRAY_CTRL	0
226
227/* MXT_PROCI_GRIPFACE_T20 field */
228#define MXT_GRIPFACE_CTRL	0
229#define MXT_GRIPFACE_XLOGRIP	1
230#define MXT_GRIPFACE_XHIGRIP	2
231#define MXT_GRIPFACE_YLOGRIP	3
232#define MXT_GRIPFACE_YHIGRIP	4
233#define MXT_GRIPFACE_MAXTCHS	5
234#define MXT_GRIPFACE_SZTHR1	7
235#define MXT_GRIPFACE_SZTHR2	8
236#define MXT_GRIPFACE_SHPTHR1	9
237#define MXT_GRIPFACE_SHPTHR2	10
238#define MXT_GRIPFACE_SUPEXTTO	11
239
240/* MXT_PROCI_NOISE field */
241#define MXT_NOISE_CTRL		0
242#define MXT_NOISE_OUTFLEN	1
243#define MXT_NOISE_GCAFUL_LSB	3
244#define MXT_NOISE_GCAFUL_MSB	4
245#define MXT_NOISE_GCAFLL_LSB	5
246#define MXT_NOISE_GCAFLL_MSB	6
247#define MXT_NOISE_ACTVGCAFVALID	7
248#define MXT_NOISE_NOISETHR	8
249#define MXT_NOISE_FREQHOPSCALE	10
250#define MXT_NOISE_FREQ0		11
251#define MXT_NOISE_FREQ1		12
252#define MXT_NOISE_FREQ2		13
253#define MXT_NOISE_FREQ3		14
254#define MXT_NOISE_FREQ4		15
255#define MXT_NOISE_IDLEGCAFVALID	16
256
257/* MXT_SPT_COMMSCONFIG_T18 */
258#define MXT_COMMS_CTRL		0
259#define MXT_COMMS_CMD		1
260
261/* MXT_SPT_GPIOPWM_T19 */
262#define MXT_GPIOPWM_CTRL		0
263#define MXT_GPIOPWM_INTPULLUP		3
264#define MXT_GPIO_FORCERPT		0x7
265#define MXT_GPIO_DISABLEOUTPUT		0
266
267/* MXT_SPT_CTECONFIG_T28 field */
268#define MXT_CTE_CTRL		0
269#define MXT_CTE_CMD		1
270#define MXT_CTE_MODE		2
271#define MXT_CTE_IDLEGCAFDEPTH	3
272#define MXT_CTE_ACTVGCAFDEPTH	4
273#define MXT_CTE_VOLTAGE		5
274
275#define MXT_VOLTAGE_DEFAULT	2700000
276#define MXT_VOLTAGE_STEP	10000
277
278/* MXT_DEBUG_DIAGNOSTIC_T37 */
279#define MXT_DIAG_PAGE_UP	0x01
280#define MXT_DIAG_MULT_DELTA	0x10
281#define MXT_DIAG_SELF_REF	0xF5
282#define MXT_DIAG_SELF_DELTA	0xFC
283#define MXT_DIAG_PAGE_SIZE	0x80
284#define MXT_DIAG_TOTAL_SIZE	0x438
285#define MXT_DIAG_SELF_SIZE	0x6C
286#define MXT_DIAG_REV_ID		21
287#define MXT_LOCKDOWN_OFFSET	4
288
289/* MXT_SPT_USERDATA_T38 */
290#define MXT_FW_UPDATE_FLAG	0
291#define MXT_USERDATA_SIZE	8
292
293/* MXT_PROCI_STYLUS_T47 */
294#define MXT_PSTYLUS_CTRL	0
295
296/* MXT_PROCI_LENSBENDING_T65 */
297#define MXT_LENSBENDING_CTRL	0
298
299/* MXT_SERIALDATACOMMAND_T68 */
300#define MXT_LOCKDOWN_SIZE	8
301
302/* MXT_PROCG_NOISESUPPRESSION_T72 */
303#define MXT_NOISESUP_CTRL	0
304#define MXT_NOISESUP_CALCFG	1
305#define MXT_NOISESUP_CFG1	2
306
307/* MXT_PROCI_GLOVEDETECTION_T78 */
308#define MXT_GLOVE_CTRL		0x00
309
310/* MXT_SPT_TOUCHSCREENHOVER_T101 */
311#define MXT_HOVER_CTRL		0x00
312
313/* MXT_SPT_AUXTOUCHCONFIG_T104 */
314#define MXT_AUXTCHCFG_XTCHTHR	2
315#define MXT_AUXTCHCFG_INTTHRX	4
316#define MXT_AUXTCHCFG_YTCHTHR	7
317#define MXT_AUXTCHCFG_INTTHRY	9
318
319/* MXT_SPT_SELFCAPGLOBALCONFIG_T109 */
320#define MXT_SELFCAPCFG_CTRL	0
321#define MXT_SELFCAPCFG_CMD	3
322
323
324/* Defines for Suspend/Resume */
325#define MXT_SUSPEND_STATIC      0
326#define MXT_SUSPEND_DYNAMIC     1
327#define MXT_T7_IDLEACQ_DISABLE  0
328#define MXT_T7_ACTVACQ_DISABLE  0
329#define MXT_T7_ACTV2IDLE_DISABLE 0
330#define MXT_T9_DISABLE          0
331#define MXT_T9_ENABLE           0x83
332#define MXT_T22_DISABLE         0
333#define MXT_T100_DISABLE	0
334
335/* Define for MXT_GEN_COMMAND_T6 */
336#define MXT_RESET_VALUE		0x01
337#define MXT_BACKUP_VALUE	0x55
338
339/* Define for MXT_PROCG_NOISESUPPRESSION_T42 */
340#define MXT_T42_MSG_TCHSUP	(1 << 0)
341
342/* Delay times */
343#define MXT_BACKUP_TIME		25	/* msec */
344#define MXT_RESET_TIME		200	/* msec */
345#define MXT_RESET_NOCHGREAD	400	/* msec */
346#define MXT_FWRESET_TIME	1000	/* msec */
347#define MXT_WAKEUP_TIME		25	/* msec */
348
349/* Defines for MXT_SLOWSCAN_EXTENSIONS */
350#define SLOSCAN_DISABLE         0       /* Disable slow scan */
351#define SLOSCAN_ENABLE          1       /* Enable slow scan */
352#define SLOSCAN_SET_ACTVACQINT  2       /* Set ACTV scan rate */
353#define SLOSCAN_SET_IDLEACQINT  3       /* Set IDLE scan rate */
354#define SLOSCAN_SET_ACTV2IDLETO 4       /* Set the ACTIVE to IDLE TimeOut */
355
356/* Command to unlock bootloader */
357#define MXT_UNLOCK_CMD_MSB	0xaa
358#define MXT_UNLOCK_CMD_LSB	0xdc
359
360/* Bootloader mode status */
361#define MXT_WAITING_BOOTLOAD_CMD	0xc0	/* valid 7 6 bit only */
362#define MXT_WAITING_FRAME_DATA	0x80	/* valid 7 6 bit only */
363#define MXT_FRAME_CRC_CHECK	0x02
364#define MXT_FRAME_CRC_FAIL	0x03
365#define MXT_FRAME_CRC_PASS	0x04
366#define MXT_APP_CRC_FAIL	0x40	/* valid 7 8 bit only */
367#define MXT_BOOT_STATUS_MASK	0x3f
368#define MXT_BOOT_EXTENDED_ID	(1 << 5)
369#define MXT_BOOT_ID_MASK	0x1f
370
371/* Define for T6 status byte */
372#define MXT_STATUS_RESET	(1 << 7)
373#define MXT_STATUS_OFL		(1 << 6)
374#define MXT_STATUS_SIGERR	(1 << 5)
375#define MXT_STATUS_CAL		(1 << 4)
376#define MXT_STATUS_CFGERR	(1 << 3)
377#define MXT_STATUS_COMSERR	(1 << 2)
378
379/* Define for T8 measallow byte */
380#define MXT_MEASALLOW_MULT	(1 << 0)
381#define MXT_MEASALLOW_SELT	(1 << 1)
382
383/* T9 Touch status */
384#define MXT_T9_UNGRIP		(1 << 0)
385#define MXT_T9_SUPPRESS		(1 << 1)
386#define MXT_T9_AMP		(1 << 2)
387#define MXT_T9_VECTOR		(1 << 3)
388#define MXT_T9_MOVE		(1 << 4)
389#define MXT_T9_RELEASE		(1 << 5)
390#define MXT_T9_PRESS		(1 << 6)
391#define MXT_T9_DETECT		(1 << 7)
392
393/* T100 Touch status */
394#define MXT_T100_CTRL_RPTEN	(1 << 1)
395
396#define MXT_T100_EVENT_NONE	0
397#define MXT_T100_EVENT_MOVE	1
398#define MXT_T100_EVENT_UNSUP	2
399#define MXT_T100_EVENT_SUP	3
400#define MXT_T100_EVENT_DOWN	4
401#define MXT_T100_EVENT_UP	5
402#define MXT_T100_EVENT_UNSUPSUP	6
403#define MXT_T100_EVENT_UNSUPUP	7
404#define MXT_T100_EVENT_DOWNSUP	8
405#define MXT_T100_EVENT_DOWNUP	9
406
407#define MXT_T100_TYPE_RESERVED	0
408#define MXT_T100_TYPE_FINGER	1
409#define MXT_T100_TYPE_PASSIVE_STYLUS	2
410#define MXT_T100_TYPE_ACTIVE_STYLUS	3
411#define MXT_T100_TYPE_HOVERING_FINGER	4
412#define MXT_T100_TYPE_HOVERING_GLOVE	5
413
414#define MXT_T100_DETECT		(1 << 7)
415#define MXT_T100_VECT		(1 << 0)
416#define MXT_T100_AMPL		(1 << 1)
417#define MXT_T100_AREA		(1 << 2)
418#define MXT_T100_PEAK		(1 << 4)
419
420#define MXT_T100_SUP		(1 << 6)
421
422/* T15 KeyArray */
423#define MXT_KEY_RPTEN		(1 << 1)
424#define MXT_KEY_ADAPTTHREN	(1 << 2)
425
426/* Touch orient bits */
427#define MXT_XY_SWITCH		(1 << 0)
428#define MXT_X_INVERT		(1 << 1)
429#define MXT_Y_INVERT		(1 << 2)
430
431/* T47 passive stylus */
432#define MXT_PSTYLUS_ENABLE	(1 << 0)
433
434/* T63 Stylus */
435#define MXT_STYLUS_PRESS	(1 << 0)
436#define MXT_STYLUS_RELEASE	(1 << 1)
437#define MXT_STYLUS_MOVE		(1 << 2)
438#define MXT_STYLUS_SUPPRESS	(1 << 3)
439
440#define MXT_STYLUS_DETECT	(1 << 4)
441#define MXT_STYLUS_TIP		(1 << 5)
442#define MXT_STYLUS_ERASER	(1 << 6)
443#define MXT_STYLUS_BARREL	(1 << 7)
444
445#define MXT_STYLUS_PRESSURE_MASK	0x3F
446
447/* Touchscreen absolute values */
448#define MXT_MAX_AREA		0xff
449
450/* T66 Golden Reference */
451#define MXT_GOLDENREF_CTRL		0x00
452#define MXT_GOLDENREF_FCALFAILTHR	0x01
453#define MXT_GOLDENREF_FCALDRIFTCNT	0x02
454#define MXT_GOLDENREF_FCALDRIFTCOEF	0x03
455#define MXT_GOLDENREF_FCALDRIFTTLIM	0x04
456
457#define MXT_GOLDCTRL_ENABLE		(1 << 0)
458#define MXT_GOLDCTRL_REPEN		(1 << 1)
459
460#define MXT_GOLDSTS_BADSTOREDATA	(1 << 0)
461#define MXT_GOLDSTS_FCALSEQERR	(1 << 3)
462#define MXT_GOLDSTS_FCALSEQTO		(1 << 4)
463#define MXT_GOLDSTS_FCALSEQDONE	(1 << 5)
464#define MXT_GOLDSTS_FCALPASS		(1 << 6)
465#define MXT_GOLDSTS_FCALFAIL		(1 << 7)
466
467#define MXT_GOLDCMD_NONE	0x00
468#define MXT_GOLDCMD_PRIME	0x04
469#define MXT_GOLDCMD_GENERATE	0x08
470#define MXT_GOLDCMD_CONFIRM	0x0C
471
472#define MXT_GOLD_CMD_MASK	0x0C
473
474#define MXT_GOLDSTATE_INVALID	0xFF
475#define MXT_GOLDSTATE_IDLE	MXT_GOLDSTS_FCALSEQDONE
476#define MXT_GOLDSTATE_PRIME	0x02
477#define MXT_GOLDSTATE_GEN	0x04
478#define MXT_GOLDSTATE_GEN_PASS	(0x04 | MXT_GOLDSTS_FCALPASS)
479#define MXT_GOLDSTATE_GEN_FAIL	(0x04 | MXT_GOLDSTS_FCALFAIL)
480
481#define MXT_GOLD_STATE_MASK	0x06
482
483/* T78 glove setting */
484#define MXT_GLOVECTL_ALL_ENABLE	0xB9
485#define MXT_GLOVECTL_GAINEN	(1 << 4)
486
487/* T80 retransmission */
488#define MXT_RETRANS_CTRL	0x0
489#define MXT_RETRANS_ATCHTHR	0x4
490#define MXT_RETRANS_CTRL_MOISTCALEN	(1 << 4)
491
492/* T81 gesture */
493#define MXT_GESTURE_CTRL	0x0
494
495/* T72 noise suppression */
496#define MXT_NOICTRL_ENABLE	(1 << 0)
497#define MXT_NOICFG_VNOISY	(1 << 1)
498#define MXT_NOICFG_NOISY	(1 << 0)
499
500/* T109 self-cap */
501#define MXT_SELFCTL_RPTEN	0x2
502#define MXT_SELFCMD_TUNE	0x1
503#define MXT_SELFCMD_STM_TUNE	0x2
504#define MXT_SELFCMD_AFN_TUNE	0x3
505#define MXT_SELFCMD_STCR_TUNE	0x4
506#define MXT_SELFCMD_AFCR_TUNE	0x5
507#define MXT_SELFCMD_AFNVMSTCR_TUNE	0x6
508#define MXT_SELFCMD_RCR_TUNE	0x7
509
510#define MXT_DEBUGFS_DIR		"atmel_mxt_ts"
511#define MXT_DEBUGFS_FILE		"object"
512
513
514#define MXT_INPUT_EVENT_START		0
515#define MXT_INPUT_EVENT_SENSITIVE_MODE_OFF		0
516#define MXT_INPUT_EVENT_SENSITIVE_MODE_ON		1
517#define MXT_INPUT_EVENT_STYLUS_MODE_OFF		2
518#define MXT_INPUT_EVENT_STYLUS_MODE_ON		3
519#define MXT_INPUT_EVENT_WAKUP_MODE_OFF		4
520#define MXT_INPUT_EVENT_WAKUP_MODE_ON		5
521#define MXT_INPUT_EVENT_END		5
522
523#define MXT_MAX_FINGER_NUM	16
524#define BOOTLOADER_1664_1188	1
525
526struct mxt_info {
527	u8 family_id;
528	u8 variant_id;
529	u8 version;
530	u8 build;
531	u8 matrix_xsize;
532	u8 matrix_ysize;
533	u8 object_num;
534};
535
536struct mxt_object {
537	u8 type;
538	u16 start_address;
539	u16 size;
540	u16 instances;
541	u8 num_report_ids;
542
543	/* to map object and message */
544	u8 min_reportid;
545	u8 max_reportid;
546};
547
548enum mxt_device_state { INIT, APPMODE, BOOTLOADER, FAILED, SHUTDOWN };
549
550/* This structure is used to save/restore values during suspend/resume */
551struct mxt_suspend {
552	u8 suspend_obj;
553	u8 suspend_reg;
554	u8 suspend_val;
555	u8 suspend_flags;
556	u8 restore_val;
557};
558
559struct mxt_golden_msg {
560	u8 status;
561	u8 fcalmaxdiff;
562	u8 fcalmaxdiffx;
563	u8 fcalmaxdiffy;
564};
565
566
567struct mxt_selfcap_status {
568	u8 cmd;
569	u8 error_code;
570};
571
572struct mxt_mode_switch {
573	struct mxt_data *data;
574	u8 mode;
575	struct work_struct switch_mode_work;
576};
577
578/* Each client has this additional data */
579struct mxt_data {
580	struct i2c_client *client;
581	struct input_dev *input_dev;
582	const struct mxt_platform_data *pdata;
583	enum mxt_device_state state;
584	struct mxt_object *object_table;
585	struct regulator *regulator_vdd;
586	struct regulator *regulator_avdd;
587	struct regulator *regulator_vddio;
588	u16 mem_size;
589	struct mxt_info info;
590	unsigned int irq;
591	unsigned int max_x;
592	unsigned int max_y;
593	struct bin_attribute mem_access_attr;
594	bool debug_enabled;
595	bool driver_paused;
596	u8 bootloader_addr;
597	u8 actv_cycle_time;
598	u8 idle_cycle_time;
599	u8 actv2idle_timeout;
600	u8 is_stopped;
601	u8 max_reportid;
602	u32 config_crc;
603	u32 info_block_crc;
604	u8 num_touchids;
605	u8 num_stylusids;
606	u8 *msg_buf;
607	u8 last_message_count;
608	u8 t100_tchaux_bits;
609	unsigned long keystatus;
610	u8 vendor_id;
611	u8 rev_id;
612	int current_index;
613	u8 update_flag;
614	u8 test_result[6];
615	int touch_num;
616	u8 diag_mode;
617	u8 atchthr;
618	u8 sensitive_mode;
619	u8 stylus_mode;
620	u8 wakeup_gesture_mode;
621	bool is_wakeup_by_gesture;
622	int hover_tune_status;
623	struct delayed_work calibration_delayed_work;
624	u8 adcperx_normal[10];
625	u8 adcperx_wakeup[10];
626	bool irq_enabled;
627	u8 lockdown_info[MXT_LOCKDOWN_SIZE];
628	u8 userdata_info[MXT_USERDATA_SIZE];
629	bool firmware_updated;
630	bool keys_off;
631	bool hw_wakeup;
632	bool screen_off;
633
634	/* Slowscan parameters	*/
635	int slowscan_enabled;
636	u8 slowscan_actv_cycle_time;
637	u8 slowscan_idle_cycle_time;
638	u8 slowscan_actv2idle_timeout;
639	u8 slowscan_shad_actv_cycle_time;
640	u8 slowscan_shad_idle_cycle_time;
641	u8 slowscan_shad_actv2idle_timeout;
642	struct mxt_golden_msg golden_msg;
643	struct mxt_selfcap_status selfcap_status;
644	struct work_struct self_tuning_work;
645	struct work_struct hover_loading_work;
646	bool finger_down[MXT_MAX_FINGER_NUM];
647
648	/* Cached parameters from object table */
649	u16 T5_address;
650	u8 T5_msg_size;
651	u8 T6_reportid;
652	u16 T7_address;
653	u8 T9_reportid_min;
654	u8 T9_reportid_max;
655	u8 T15_reportid_min;
656	u8 T15_reportid_max;
657	u8 T19_reportid_min;
658	u8 T19_reportid_max;
659	u8 T25_reportid_min;
660	u8 T25_reportid_max;
661	u16 T37_address;
662	u8 T42_reportid_min;
663	u8 T42_reportid_max;
664	u16 T44_address;
665	u8 T48_reportid;
666	u8 T63_reportid_min;
667	u8 T63_reportid_max;
668	u8 T66_reportid;
669	u8 T81_reportid_min;
670	u8 T81_reportid_max;
671	u8 T92_reportid_min;
672	u8 T92_reportid_max;
673	u8 T100_reportid_min;
674	u8 T100_reportid_max;
675	u8 T109_reportid;
676
677#ifdef CONFIG_FB
678	struct notifier_block fb_notif;
679#endif
680};
681
682static struct mxt_suspend mxt_save[] = {
683	{MXT_GEN_POWER_T7, MXT_POWER_IDLEACQINT,
684		MXT_T7_IDLEACQ_DISABLE, MXT_SUSPEND_DYNAMIC, 0},
685	{MXT_GEN_POWER_T7, MXT_POWER_ACTVACQINT,
686		MXT_T7_ACTVACQ_DISABLE, MXT_SUSPEND_DYNAMIC, 0},
687	{MXT_GEN_POWER_T7, MXT_POWER_ACTV2IDLETO,
688		MXT_T7_ACTV2IDLE_DISABLE, MXT_SUSPEND_DYNAMIC, 0}
689};
690
691/* I2C slave address pairs */
692struct mxt_i2c_address_pair {
693	u8 bootloader;
694	u8 application;
695};
696
697static const struct mxt_i2c_address_pair mxt_i2c_addresses[] = {
698#ifdef BOOTLOADER_1664_1188
699	{ 0x26, 0x4a },
700	{ 0x27, 0x4b },
701#else
702	{ 0x24, 0x4a },
703	{ 0x25, 0x4b },
704	{ 0x26, 0x4c },
705	{ 0x27, 0x4d },
706	{ 0x34, 0x5a },
707	{ 0x35, 0x5b },
708#endif
709};
710
711static struct gpiomux_setting mxt_rst_cutoff_pwr_cfg = {
712	.func = GPIOMUX_FUNC_GPIO,
713	.drv = GPIOMUX_DRV_6MA,
714	.pull = GPIOMUX_PULL_NONE,
715};
716
717static struct gpiomux_setting mxt_int_cutoff_pwr_cfg = {
718	.func = GPIOMUX_FUNC_GPIO,
719	.drv = GPIOMUX_DRV_6MA,
720	.pull = GPIOMUX_PULL_NONE,
721};
722
723static ssize_t mxt_update_firmware(struct device *dev,
724	struct device_attribute *attr, const char *buf, size_t count, bool *upgraded);
725
726static int mxt_bootloader_read(struct mxt_data *data, u8 *val, unsigned int count)
727{
728	int ret;
729	struct i2c_msg msg;
730
731	msg.addr = data->bootloader_addr;
732	msg.flags = data->client->flags & I2C_M_TEN;
733	msg.flags |= I2C_M_RD;
734	msg.len = count;
735	msg.buf = val;
736
737	ret = i2c_transfer(data->client->adapter, &msg, 1);
738
739	return (ret == 1) ? 0 : ret;
740}
741
742static int mxt_bootloader_write(struct mxt_data *data, const u8 * const val,
743	unsigned int count)
744{
745	int ret;
746	struct i2c_msg msg;
747
748	msg.addr = data->bootloader_addr;
749	msg.flags = data->client->flags & I2C_M_TEN;
750	msg.len = count;
751	msg.buf = (u8 *)val;
752
753	ret = i2c_transfer(data->client->adapter, &msg, 1);
754
755	return (ret == 1) ? 0 : ret;
756}
757
758static int mxt_get_bootloader_address(struct mxt_data *data)
759{
760	struct i2c_client *client = data->client;
761	int i;
762
763	for (i = 0; i < ARRAY_SIZE(mxt_i2c_addresses); i++) {
764		if (mxt_i2c_addresses[i].application == client->addr) {
765			data->bootloader_addr = mxt_i2c_addresses[i].bootloader;
766
767			dev_info(&client->dev, "Bootloader i2c addr: 0x%02x\n",
768				data->bootloader_addr);
769
770			return 0;
771		}
772	}
773
774	dev_err(&client->dev, "Address 0x%02x not found in address table\n",
775		client->addr);
776	return -EINVAL;
777}
778
779static int mxt_probe_bootloader(struct mxt_data *data)
780{
781	struct device *dev = &data->client->dev;
782	int ret;
783	u8 val;
784	bool crc_failure;
785
786	ret = mxt_get_bootloader_address(data);
787	if (ret)
788		return ret;
789
790	ret = mxt_bootloader_read(data, &val, 1);
791	if (ret) {
792		dev_err(dev, "%s: i2c recv failed\n", __func__);
793		return -EIO;
794	}
795
796	/* Check app crc fail mode */
797	crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL;
798
799	dev_err(dev, "Detected bootloader, status:%02X%s\n",
800		val, crc_failure ? ", APP_CRC_FAIL" : "");
801
802	return 0;
803}
804
805static u8 mxt_read_chg(struct mxt_data *data)
806{
807	int gpio_intr = data->pdata->irq_gpio;
808
809	u8 val = (u8)gpio_get_value(gpio_intr);
810	return val;
811}
812
813static void mxt_disable_irq(struct mxt_data *data)
814{
815	if (likely(data->irq_enabled)) {
816		disable_irq(data->irq);
817		data->irq_enabled = false;
818	}
819}
820
821static void mxt_enable_irq(struct mxt_data *data)
822{
823	if (likely(!data->irq_enabled)) {
824		enable_irq(data->irq);
825		data->irq_enabled = true;
826	}
827}
828
829static int mxt_wait_for_chg(struct mxt_data *data)
830{
831	int timeout_counter = 0;
832	int count = 10;
833
834	while ((timeout_counter++ <= count) && mxt_read_chg(data))
835		mdelay(10);
836
837	if (timeout_counter > count) {
838		dev_err(&data->client->dev, "mxt_wait_for_chg() timeout!\n");
839		return -EIO;
840	}
841
842	return 0;
843}
844
845static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
846{
847	struct device *dev = &data->client->dev;
848	u8 buf[3];
849
850	if (val & MXT_BOOT_EXTENDED_ID) {
851		if (mxt_bootloader_read(data, &buf[0], 3) != 0) {
852			dev_err(dev, "%s: i2c failure\n", __func__);
853			return -EIO;
854		}
855
856		dev_info(dev, "Bootloader ID:%d Version:%d\n", buf[1], buf[2]);
857
858		return buf[0];
859	} else {
860		dev_info(dev, "Bootloader ID:%d\n", val & MXT_BOOT_ID_MASK);
861
862		return val;
863	}
864}
865
866static int mxt_check_bootloader(struct mxt_data *data,
867				unsigned int state)
868{
869	struct device *dev = &data->client->dev;
870	int ret;
871	u8 val;
872
873recheck:
874	ret = mxt_bootloader_read(data, &val, 1);
875	if (ret) {
876		dev_err(dev, "%s: i2c recv failed, ret=%d\n",
877			__func__, ret);
878		return ret;
879	}
880
881	if (state == MXT_WAITING_BOOTLOAD_CMD) {
882		val = mxt_get_bootloader_version(data, val);
883	}
884
885	switch (state) {
886	case MXT_WAITING_BOOTLOAD_CMD:
887		val &= ~MXT_BOOT_STATUS_MASK;
888		break;
889	case MXT_WAITING_FRAME_DATA:
890	case MXT_APP_CRC_FAIL:
891		val &= ~MXT_BOOT_STATUS_MASK;
892		break;
893	case MXT_FRAME_CRC_PASS:
894		if (val == MXT_FRAME_CRC_CHECK) {
895			mxt_wait_for_chg(data);
896			goto recheck;
897		} else if (val == MXT_FRAME_CRC_FAIL) {
898			dev_err(dev, "Bootloader CRC fail\n");
899			return -EINVAL;
900		}
901		break;
902	default:
903		return -EINVAL;
904	}
905
906	if (val != state) {
907		dev_err(dev, "Invalid bootloader mode state 0x%02X\n", val);
908		return -EINVAL;
909	}
910
911	return 0;
912}
913
914static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock)
915{
916	int ret;
917	u8 buf[2];
918
919	if (unlock) {
920		buf[0] = MXT_UNLOCK_CMD_LSB;
921		buf[1] = MXT_UNLOCK_CMD_MSB;
922	} else {
923		buf[0] = 0x01;
924		buf[1] = 0x01;
925	}
926
927	ret = mxt_bootloader_write(data, buf, 2);
928	if (ret) {
929		dev_err(&data->client->dev, "%s: i2c send failed, ret=%d\n",
930				__func__, ret);
931		return ret;
932	}
933
934	return 0;
935}
936
937static int mxt_read_reg(struct i2c_client *client,
938			u16 reg, u16 len, void *val)
939{
940	struct device *dev = &client->dev;
941	struct i2c_msg xfer[2];
942	u8 buf[2];
943	int ret;
944
945	buf[0] = reg & 0xff;
946	buf[1] = (reg >> 8) & 0xff;
947
948	/* Write register */
949	xfer[0].addr = client->addr;
950	xfer[0].flags = 0;
951	xfer[0].len = 2;
952	xfer[0].buf = buf;
953
954	/* Read data */
955	xfer[1].addr = client->addr;
956	xfer[1].flags = I2C_M_RD;
957	xfer[1].len = len;
958	xfer[1].buf = val;
959
960	ret = i2c_transfer(client->adapter, xfer, ARRAY_SIZE(xfer));
961	if (ret != ARRAY_SIZE(xfer)) {
962		dev_err(dev, "%s: i2c transfer failed (%d)\n",
963			__func__, ret);
964		return -EIO;
965	}
966
967	return 0;
968}
969
970static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
971{
972	struct device *dev = &client->dev;
973	u8 buf[3];
974
975	buf[0] = reg & 0xff;
976	buf[1] = (reg >> 8) & 0xff;
977	buf[2] = val;
978
979	if (i2c_master_send(client, buf, 3) != 3) {
980		dev_err(dev, "%s: i2c send failed\n", __func__);
981		return -EIO;
982	}
983
984	return 0;
985}
986
987static int mxt_write_block(struct i2c_client *client, u16 addr, u16 length, u8 *value)
988{
989	int i;
990	struct {
991		__le16 le_addr;
992		u8  data[MXT_MAX_BLOCK_WRITE];
993	} i2c_block_transfer;
994
995	if (length > MXT_MAX_BLOCK_WRITE)
996		return -EINVAL;
997
998	memcpy(i2c_block_transfer.data, value, length);
999
1000	i2c_block_transfer.le_addr = cpu_to_le16(addr);
1001
1002	i = i2c_master_send(client, (u8 *) &i2c_block_transfer, length + 2);
1003
1004	if (i == (length + 2))
1005		return 0;
1006	else
1007		return -EIO;
1008}
1009
1010static struct mxt_object *mxt_get_object(struct mxt_data *data, u8 type)
1011{
1012	struct mxt_object *object;
1013	int i;
1014
1015	for (i = 0; i < data->info.object_num; i++) {
1016		object = data->object_table + i;
1017		if (object->type == type)
1018			return object;
1019	}
1020
1021	dev_err(&data->client->dev, "Invalid object type T%u\n", type);
1022	return NULL;
1023}
1024
1025static int mxt_read_object(struct mxt_data *data,
1026				u8 type, u8 offset, u8 *val)
1027{
1028	struct mxt_object *object;
1029	u16 reg;
1030
1031	object = mxt_get_object(data, type);
1032	if (!object)
1033		return -EINVAL;
1034
1035	reg = object->start_address;
1036	if (data->debug_enabled)
1037		dev_info(&data->client->dev, "read from object %d, reg 0x%02x, val 0x%x\n",
1038				(int)type, reg + offset, *val);
1039	return mxt_read_reg(data->client, reg + offset, 1, val);
1040}
1041
1042static int mxt_write_object(struct mxt_data *data,
1043				 u8 type, u8 offset, u8 val)
1044{
1045	struct mxt_object *object;
1046	u16 reg;
1047	int ret;
1048
1049	object = mxt_get_object(data, type);
1050	if (!object || offset >= object->size)
1051		return -EINVAL;
1052
1053	if (offset >= object->size * object->instances) {
1054		dev_err(&data->client->dev, "Tried to write outside object T%d"
1055			" offset:%d, size:%d\n", type, offset, object->size);
1056		return -EINVAL;
1057	}
1058
1059	reg = object->start_address;
1060	if (data->debug_enabled)
1061		dev_info(&data->client->dev, "write to object %d, reg 0x%02x, val 0x%x\n",
1062				(int)type, reg + offset, val);
1063	ret = mxt_write_reg(data->client, reg + offset, val);
1064
1065	return ret;
1066}
1067
1068static int mxt_set_clr_reg(struct mxt_data *data,
1069				u8 type, u8 offset, u8 mask_s, u8 mask_c)
1070{
1071	int error;
1072	u8 val;
1073
1074	error = mxt_read_object(data, type, offset, &val);
1075	if (error) {
1076		dev_err(&data->client->dev,
1077			"Failed to read object %d\n", (int)type);
1078		return error;
1079	}
1080
1081	val &= ~mask_c;
1082	val |= mask_s;
1083
1084	error = mxt_write_object(data, type, offset, val);
1085	if (error)
1086		dev_err(&data->client->dev,
1087			"Failed to write object %d\n", (int)type);
1088	return error;
1089}
1090
1091static int mxt_soft_reset(struct mxt_data *data, u8 value)
1092{
1093	struct device *dev = &data->client->dev;
1094
1095	dev_info(dev, "Resetting chip\n");
1096
1097	mxt_write_object(data, MXT_GEN_COMMAND_T6,
1098			MXT_COMMAND_RESET, value);
1099
1100	msleep(MXT_RESET_NOCHGREAD);
1101
1102	return 0;
1103}
1104
1105static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg)
1106{
1107	struct device *dev = &data->client->dev;
1108	u32 crc;
1109	u8 status = msg[1];
1110
1111	crc = msg[2] | (msg[3] << 8) | (msg[4] << 16);
1112
1113	if (crc != data->config_crc) {
1114		data->config_crc = crc;
1115		dev_dbg(dev, "T6 cfg crc 0x%06X\n", crc);
1116	}
1117
1118	if (status & MXT_STATUS_CAL) {
1119		dev_info(dev, "Calibration start!\n");
1120	}
1121
1122	if (status)
1123		dev_dbg(dev, "T6 status %s%s%s%s%s%s\n",
1124			(status & MXT_STATUS_RESET) ? "RESET " : "",
1125			(status & MXT_STATUS_OFL) ? "OFL " : "",
1126			(status & MXT_STATUS_SIGERR) ? "SIGERR " : "",
1127			(status & MXT_STATUS_CAL) ? "CAL " : "",
1128			(status & MXT_STATUS_CFGERR) ? "CFGERR " : "",
1129			(status & MXT_STATUS_COMSERR) ? "COMSERR " : "");
1130}
1131
1132static void mxt_input_sync(struct mxt_data *data)
1133{
1134	input_mt_report_pointer_emulation(data->input_dev, false);
1135	input_sync(data->input_dev);
1136}
1137
1138static void mxt_proc_t9_messages(struct mxt_data *data, u8 *message)
1139{
1140	struct device *dev = &data->client->dev;
1141	struct input_dev *input_dev = data->input_dev;
1142	u8 status;
1143	int x;
1144	int y;
1145	int area;
1146	int amplitude;
1147	u8 vector;
1148	int id;
1149
1150	if (!input_dev || data->driver_paused)
1151		return;
1152
1153	id = message[0] - data->T9_reportid_min;
1154
1155	if (id < 0 || id > data->num_touchids) {
1156		dev_err(dev, "invalid touch id %d, total num touch is %d\n",
1157			id, data->num_touchids);
1158		return;
1159	}
1160
1161	status = message[1];
1162
1163	x = (message[2] << 4) | ((message[4] >> 4) & 0xf);
1164	y = (message[3] << 4) | ((message[4] & 0xf));
1165	if (data->max_x < 1024)
1166		x >>= 2;
1167	if (data->max_y < 1024)
1168		y >>= 2;
1169	area = message[5];
1170	amplitude = message[6];
1171	vector = message[7];
1172
1173	dev_dbg(dev,
1174		"[%d] %c%c%c%c%c%c%c%c x: %d y: %d area: %d amp: %d vector: %02X\n",
1175		id,
1176		(status & MXT_T9_DETECT) ? 'D' : '.',
1177		(status & MXT_T9_PRESS) ? 'P' : '.',
1178		(status & MXT_T9_RELEASE) ? 'R' : '.',
1179		(status & MXT_T9_MOVE) ? 'M' : '.',
1180		(status & MXT_T9_VECTOR) ? 'V' : '.',
1181		(status & MXT_T9_AMP) ? 'A' : '.',
1182		(status & MXT_T9_SUPPRESS) ? 'S' : '.',
1183		(status & MXT_T9_UNGRIP) ? 'U' : '.',
1184		x, y, area, amplitude, vector);
1185
1186	input_mt_slot(input_dev, id);
1187
1188	if ((status & MXT_T9_DETECT) && (status & MXT_T9_RELEASE)) {
1189		/* Touch in detect, just after being released, so
1190		 * get new touch tracking ID */
1191		input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0);
1192		mxt_input_sync(data);
1193	}
1194
1195	if (status & MXT_T9_DETECT) {
1196		/* Touch in detect, report X/Y position */
1197		input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1);
1198
1199		input_report_abs(input_dev, ABS_MT_POSITION_X, x);
1200		input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
1201		input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
1202		input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
1203		input_report_abs(input_dev, ABS_MT_ORIENTATION, vector);
1204	} else {
1205		/* Touch no longer in detect, so close out slot */
1206		mxt_input_sync(data);
1207		input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0);
1208	}
1209}
1210
1211static int mxt_do_diagnostic(struct mxt_data *data, u8 mode)
1212{
1213	int error = 0;
1214	u8 val;
1215	int time_out = 500;
1216	int i = 0;
1217
1218	error = mxt_write_object(data, MXT_GEN_COMMAND_T6,
1219				MXT_COMMAND_DIAGNOSTIC, mode);
1220	if (error) {
1221		dev_err(&data->client->dev, "Failed to diag ref data value\n");
1222		return error;
1223	}
1224
1225	while(i < time_out) {
1226		error = mxt_read_object(data, MXT_GEN_COMMAND_T6,
1227				MXT_COMMAND_DIAGNOSTIC, &val);
1228		if (error) {
1229			dev_err(&data->client->dev, "Failed to diag ref data value\n");
1230			 return error;
1231		}
1232		if (val == 0)
1233			return 0;
1234		i++;
1235	}
1236
1237	return -ETIMEDOUT;
1238}
1239
1240static void mxt_set_t7_for_gesture(struct mxt_data *data, bool enable);
1241static void mxt_set_gesture_wake_up(struct mxt_data *data, bool enable);
1242
1243static int mxt_prevent_sleep() {
1244#ifdef CONFIG_PREVENT_SLEEP
1245	if (in_phone_call())
1246		return 0;
1247
1248	if (s2w_switch > 0 || dt2w_switch == 1)
1249		return 1;
1250	else
1251		return 0;
1252#else
1253    return 0;
1254#endif
1255}
1256
1257
1258static void mxt_proc_t100_messages(struct mxt_data *data, u8 *message)
1259{
1260	struct device *dev = &data->client->dev;
1261	struct input_dev *input_dev = data->input_dev;
1262	u8 status, touch_type, touch_event;
1263	int x;
1264	int y;
1265	int area = 0;
1266	int amplitude = 0;
1267	u8 vector = 0;
1268	u8 peak = 0;
1269	int id;
1270	int index = 0;
1271
1272	if (!input_dev || data->driver_paused)
1273		return;
1274
1275	id = message[0] - data->T100_reportid_min;
1276
1277	if (id < 0 || id > data->num_touchids) {
1278		dev_err(dev, "invalid touch id %d, total num touch is %d\n",
1279			id, data->num_touchids);
1280		return;
1281	}
1282
1283	if (id == 0) {
1284		status = message[1];
1285		data->touch_num = message[2];
1286		if (data->debug_enabled)
1287			dev_info(dev, "touch num = %d\n", data->touch_num);
1288
1289		if (status & MXT_T100_SUP)
1290		{
1291			int i;
1292			for (i = 0; i < data->num_touchids - 2; i++) {
1293				input_mt_slot(input_dev, i);
1294				input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0);
1295			}
1296			mxt_input_sync(data);
1297		}
1298	}
1299	else if (id >= 2) {
1300		/* deal with each point report */
1301		status = message[1];
1302		touch_type = (status & 0x70) >> 4;
1303		touch_event = status & 0x0F;
1304		x = (message[3] << 8) | (message[2] & 0xFF);
1305		y = (message[5] << 8) | (message[4] & 0xFF);
1306		index = 6;
1307
1308		if (data->t100_tchaux_bits &  MXT_T100_VECT)
1309			vector = message[index++];
1310		if (data->t100_tchaux_bits &  MXT_T100_AMPL) {
1311			amplitude = message[index++];
1312		}
1313		if (data->t100_tchaux_bits &  MXT_T100_AREA) {
1314			area = message[index++];
1315		}
1316		if (data->t100_tchaux_bits &  MXT_T100_PEAK)
1317			peak = message[index++];
1318
1319		input_mt_slot(input_dev, id - 2);
1320
1321		if (status & MXT_T100_DETECT) {
1322			if (touch_event == MXT_T100_EVENT_DOWN || touch_event == MXT_T100_EVENT_UNSUP
1323			|| touch_event == MXT_T100_EVENT_MOVE || touch_event == MXT_T100_EVENT_NONE) {
1324				/* Touch in detect, report X/Y position */
1325				if (touch_event == MXT_T100_EVENT_DOWN ||
1326					touch_event == MXT_T100_EVENT_UNSUP)
1327					data->finger_down[id - 2] = true;
1328				if ((touch_event == MXT_T100_EVENT_MOVE ||
1329					touch_event == MXT_T100_EVENT_NONE) &&
1330					!data->finger_down[id - 2])
1331					return;
1332
1333				input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1);
1334				input_report_abs(input_dev, ABS_MT_POSITION_X, x);
1335				input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
1336				if (touch_type == MXT_T100_TYPE_HOVERING_FINGER)
1337					input_report_abs(input_dev, BTN_TOUCH, 0);
1338				else
1339					input_report_abs(input_dev, BTN_TOUCH, 1);
1340
1341				if (data->t100_tchaux_bits &  MXT_T100_AMPL) {
1342					if (touch_type == MXT_T100_TYPE_HOVERING_FINGER)
1343						amplitude = 0;
1344					else if (amplitude == 0)
1345						amplitude = 1;
1346					input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
1347				}
1348				if (data->t100_tchaux_bits &  MXT_T100_AREA) {
1349					if (touch_type == MXT_T100_TYPE_HOVERING_FINGER)
1350						area = 0;
1351					else if (area == 0)
1352						area = 1;
1353					input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
1354				}
1355				if (data->t100_tchaux_bits &  MXT_T100_VECT)
1356					input_report_abs(input_dev, ABS_MT_ORIENTATION, vector);
1357			}
1358		} else {
1359			/* Touch no longer in detect, so close out slot */
1360			if (data->touch_num == 0 &&
1361				mxt_prevent_sleep() &&
1362				data->is_wakeup_by_gesture) {
1363				dev_info(dev, "wakeup finger release, restore t7 and t8!\n");
1364				data->is_wakeup_by_gesture = false;
1365				mxt_set_t7_for_gesture(data, false);
1366			}
1367			mxt_input_sync(data);
1368			input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0);
1369			data->finger_down[id - 2] = false;
1370		}
1371	}
1372}
1373
1374static void mxt_proc_t15_messages(struct mxt_data *data, u8 *msg)
1375{
1376	struct input_dev *input_dev = data->input_dev;
1377	struct device *dev = &data->client->dev;
1378	const struct mxt_platform_data *pdata = data->pdata;
1379	u8 key;
1380	bool curr_state, new_state;
1381	bool sync = false;
1382	unsigned long keystates = le32_to_cpu(msg[2]);
1383	int index = data->current_index;
1384	if(data->keys_off || data->screen_off) {
1385		return;
1386	}
1387
1388	for (key = 0; key < pdata->config_array[index].key_num; key++) {
1389		curr_state = test_bit(key, &data->keystatus);
1390		new_state = test_bit(key, &keystates);
1391
1392		if (!curr_state && new_state) {
1393			dev_dbg(dev, "T15 key press: %u\n", key);
1394			__set_bit(key, &data->keystatus);
1395			input_event(input_dev, EV_KEY, pdata->config_array[index].key_codes[key], 1);
1396			sync = true;
1397		} else if (curr_state && !new_state) {
1398			dev_dbg(dev, "T15 key release: %u\n", key);
1399			__clear_bit(key, &data->keystatus);
1400			input_event(input_dev, EV_KEY,  pdata->config_array[index].key_codes[key], 0);
1401			sync = true;
1402		}
1403	}
1404
1405	if (sync)
1406		input_sync(input_dev);
1407}
1408
1409static void mxt_proc_t19_messages(struct mxt_data *data, u8 *msg)
1410{
1411	struct device *dev = &data->client->dev;
1412	const struct mxt_platform_data *pdata = data->pdata;
1413
1414	if (get_hw_version_major() == 5) {
1415		dev_info(dev, "T19 is not used for distinguishing TP vendor in X5\n");
1416		return;
1417	}
1418
1419	data->vendor_id = msg[1];
1420	data->vendor_id &= pdata->gpio_mask;
1421	dev_info(dev, "T19: vendor_id & gpio_mask = 0x%x & 0x%x = 0x%x\n",
1422		msg[1], pdata->gpio_mask, data->vendor_id);
1423}
1424
1425static void mxt_proc_t25_messages(struct mxt_data *data, u8 *msg)
1426{
1427	memcpy(data->test_result,
1428		&msg[1], sizeof(data->test_result));
1429}
1430
1431static void mxt_proc_t42_messages(struct mxt_data *data, u8 *msg)
1432{
1433	struct device *dev = &data->client->dev;
1434	u8 status = msg[1];
1435
1436	if (status & MXT_T42_MSG_TCHSUP)
1437		dev_info(dev, "T42 suppress\n");
1438	else
1439		dev_info(dev, "T42 normal\n");
1440}
1441
1442static int mxt_proc_t48_messages(struct mxt_data *data, u8 *msg)
1443{
1444	struct device *dev = &data->client->dev;
1445	u8 status, state;
1446
1447	status = msg[1];
1448	state  = msg[4];
1449
1450	dev_dbg(dev, "T48 state %d status %02X %s%s%s%s%s\n",
1451			state,
1452			status,
1453			(status & 0x01) ? "FREQCHG " : "",
1454			(status & 0x02) ? "APXCHG " : "",
1455			(status & 0x04) ? "ALGOERR " : "",
1456			(status & 0x10) ? "STATCHG " : "",
1457			(status & 0x20) ? "NLVLCHG " : "");
1458
1459	return 0;
1460}
1461
1462static void mxt_proc_t63_messages(struct mxt_data *data, u8 *msg)
1463{
1464	struct device *dev = &data->client->dev;
1465	struct input_dev *input_dev = data->input_dev;
1466	u8 id;
1467	u16 x, y;
1468	u8 pressure;
1469
1470	if (!input_dev)
1471		return;
1472
1473	/* stylus slots come after touch slots */
1474	id = data->num_touchids + (msg[0] - data->T63_reportid_min);
1475
1476	if (id < 0 || id > (data->num_touchids + data->num_stylusids)) {
1477		dev_err(dev, "invalid stylus id %d, max slot is %d\n",
1478			id, data->num_stylusids);
1479		return;
1480	}
1481
1482	x = msg[3] | (msg[4] << 8);
1483	y = msg[5] | (msg[6] << 8);
1484	pressure = msg[7] & MXT_STYLUS_PRESSURE_MASK;
1485
1486	dev_dbg(dev,
1487		"[%d] %c%c%c%c x: %d y: %d pressure: %d stylus:%c%c%c%c\n",
1488		id,
1489		(msg[1] & MXT_STYLUS_SUPPRESS) ? 'S' : '.',
1490		(msg[1] & MXT_STYLUS_MOVE)     ? 'M' : '.',
1491		(msg[1] & MXT_STYLUS_RELEASE)  ? 'R' : '.',
1492		(msg[1] & MXT_STYLUS_PRESS)    ? 'P' : '.',
1493		x, y, pressure,
1494		(msg[2] & MXT_STYLUS_BARREL) ? 'B' : '.',
1495		(msg[2] & MXT_STYLUS_ERASER) ? 'E' : '.',
1496		(msg[2] & MXT_STYLUS_TIP)    ? 'T' : '.',
1497		(msg[2] & MXT_STYLUS_DETECT) ? 'D' : '.');
1498
1499	input_mt_slot(input_dev, id);
1500
1501	if (msg[2] & MXT_STYLUS_DETECT) {
1502		input_mt_report_slot_state(input_dev, MT_TOOL_PEN, 1);
1503		input_report_abs(input_dev, ABS_MT_POSITION_X, x);
1504		input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
1505		input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
1506	} else {
1507		input_mt_report_slot_state(input_dev, MT_TOOL_PEN, 0);
1508	}
1509
1510	input_report_key(input_dev, BTN_STYLUS, (msg[2] & MXT_STYLUS_ERASER));
1511	input_report_key(input_dev, BTN_STYLUS2, (msg[2] & MXT_STYLUS_BARREL));
1512
1513	mxt_input_sync(data);
1514}
1515
1516static void mxt_proc_t66_messages(struct mxt_data *data, u8 *msg)
1517{
1518	struct device *dev = &data->client->dev;
1519
1520	dev_info(dev, "message for t66= 0x%x 0x%x 0x%x 0x%x\n",
1521			msg[1], msg[2], msg[3], msg[4]);
1522
1523	data->golden_msg.status = msg[1];
1524	data->golden_msg.fcalmaxdiff = msg[2];
1525	data->golden_msg.fcalmaxdiffx = msg[3];
1526	data->golden_msg.fcalmaxdiffy = msg[4];
1527}
1528
1529static void mxt_proc_t81_message(struct mxt_data *data, u8 *msg)
1530{
1531	struct device *dev = &data->client->dev;
1532	struct input_dev *input_dev = data->input_dev;
1533
1534	dev_info(dev, "msg for t81 = 0x%x 0x%x\n",
1535		msg[0], msg[1]);
1536
1537	if (data->is_stopped) {
1538		data->is_wakeup_by_gesture = true;
1539		input_event(input_dev, EV_KEY, KEY_POWER, 1);
1540		input_sync(input_dev);
1541		input_event(input_dev, EV_KEY, KEY_POWER, 0);
1542		input_sync(input_dev);
1543	}
1544}
1545
1546static void mxt_proc_t92_message(struct mxt_data *data, u8 *msg)
1547{
1548	struct device *dev = &data->client->dev;
1549
1550	dev_info(dev, "msg for t92 = 0x%x 0x%x\n",
1551		msg[0], msg[1]);
1552
1553	/* we can do something to handle wakeup gesture */
1554}
1555
1556static void mxt_proc_t109_messages(struct mxt_data *data, u8 *msg)
1557{
1558	struct device *dev = &data->client->dev;
1559
1560	dev_info(dev, "msg for t109 = 0x%x 0x%x\n",
1561		msg[1], msg[2]);
1562
1563	data->selfcap_status.cmd = msg[1];
1564	data->selfcap_status.error_code = msg[2];
1565}
1566
1567static int mxt_proc_message(struct mxt_data *data, u8 *msg)
1568{
1569	u8 report_id = msg[0];
1570
1571	if (report_id == MXT_RPTID_NOMSG)
1572		return -1;
1573
1574	if (data->debug_enabled)
1575		print_hex_dump(KERN_DEBUG, "MXT MSG:", DUMP_PREFIX_NONE, 16, 1,
1576			       msg, data->T5_msg_size, false);
1577
1578	if (report_id >= data->T9_reportid_min
1579	    && report_id <= data->T9_reportid_max) {
1580		mxt_proc_t9_messages(data, msg);
1581	} else if (report_id >= data->T63_reportid_min
1582		   && report_id <= data->T63_reportid_max) {
1583		mxt_proc_t63_messages(data, msg);
1584	} else if (report_id >= data->T15_reportid_min
1585		   && report_id <= data->T15_reportid_max) {
1586		mxt_proc_t15_messages(data, msg);
1587	} else if (report_id >= data->T19_reportid_min
1588		   && report_id <= data->T19_reportid_max) {
1589		mxt_proc_t19_messages(data, msg);
1590	} else if (report_id >= data->T25_reportid_min
1591		   && report_id <= data->T25_reportid_max) {
1592		mxt_proc_t25_messages(data, msg);
1593	} else if (report_id == data->T6_reportid) {
1594		mxt_proc_t6_messages(data, msg);
1595	} else if (report_id == data->T48_reportid) {
1596		mxt_proc_t48_messages(data, msg);
1597	} else if (report_id >= data->T42_reportid_min
1598		   && report_id <= data->T42_reportid_max) {
1599		mxt_proc_t42_messages(data, msg);
1600	} else if (report_id == data->T66_reportid) {
1601		mxt_proc_t66_messages(data, msg);
1602	} else if (report_id >= data->T81_reportid_min
1603		   && report_id <= data->T81_reportid_max) {
1604		mxt_proc_t81_message(data, msg);
1605	} else if (report_id >= data->T92_reportid_min
1606		   && report_id <= data->T92_reportid_max) {
1607		mxt_proc_t92_message(data, msg);
1608	} else if (report_id >= data->T100_reportid_min
1609		   && report_id <= data->T100_reportid_max) {
1610		mxt_proc_t100_messages(data, msg);
1611	} else if (report_id == data->T109_reportid) {
1612		mxt_proc_t109_messages(data, msg);
1613	}
1614
1615	return 0;
1616}
1617
1618static int mxt_read_count_messages(struct mxt_data *data, u8 count)
1619{
1620	struct device *dev = &data->client->dev;
1621	int ret;
1622	int i;
1623	u8 num_valid = 0;
1624
1625	/* Safety check for msg_buf */
1626	if (count > data->max_reportid)
1627		return -EINVAL;
1628
1629	/* Process remaining messages if necessary */
1630	ret = mxt_read_reg(data->client, data->T5_address,
1631				data->T5_msg_size * count, data->msg_buf);
1632	if (ret) {
1633		dev_err(dev, "Failed to read %u messages (%d)\n", count, ret);
1634		return ret;
1635	}
1636
1637	for (i = 0;  i < count; i++) {
1638		ret = mxt_proc_message(data,
1639			data->msg_buf + data->T5_msg_size * i);
1640
1641		if (ret == 0)
1642			num_valid++;
1643		else
1644			break;
1645	}
1646
1647	/* return number of messages read */
1648	return num_valid;
1649}
1650
1651static irqreturn_t mxt_read_messages_t44(struct mxt_data *data)
1652{
1653	struct device *dev = &data->client->dev;
1654	int ret;
1655	u8 count, num_left;
1656
1657	/* Read T44 and T5 together */
1658	ret = mxt_read_reg(data->client, data->T44_address,
1659		data->T5_msg_size + 1, data->msg_buf);
1660	if (ret) {
1661		dev_err(dev, "Failed to read T44 and T5 (%d)\n", ret);
1662		return IRQ_NONE;
1663	}
1664
1665	count = data->msg_buf[0];
1666
1667	if (count == 0) {
1668		dev_warn(dev, "Interrupt triggered but zero messages\n");
1669		return IRQ_NONE;
1670	} else if (count > data->max_reportid) {
1671		dev_err(dev, "T44 count exceeded max report id\n");
1672		count = data->max_reportid;
1673	}
1674
1675	/* Process first message */
1676	ret = mxt_proc_message(data, data->msg_buf + 1);
1677	if (ret < 0) {
1678		dev_warn(dev, "Unexpected invalid message\n");
1679		return IRQ_NONE;
1680	}
1681
1682	num_left = count - 1;
1683
1684	/* Process remaining messages if necessary */
1685	if (num_left) {
1686		ret = mxt_read_count_messages(data, num_left);
1687		if (ret < 0) {
1688			mxt_input_sync(data);
1689			return IRQ_NONE;
1690		} else if (ret != num_left) {
1691			dev_warn(dev, "Unexpected invalid message\n");
1692		}
1693	}
1694
1695	mxt_input_sync(data);
1696
1697	return IRQ_HANDLED;
1698}
1699
1700static int mxt_read_t9_messages_until_invalid(struct mxt_data *data)
1701{
1702	struct device *dev = &data->client->dev;
1703	int count, read;
1704	u8 tries = 2;
1705
1706	count = data->max_reportid;
1707
1708	/* Read messages until we force an invalid */
1709	do {
1710		read = mxt_read_count_messages(data, count);
1711		if (read < count)
1712			return 0;
1713	} while (--tries);
1714
1715	dev_err(dev, "CHG pin isn't cleared\n");
1716	return -EBUSY;
1717}
1718
1719static irqreturn_t mxt_read_t9_messages(struct mxt_data *data)
1720{
1721	int total_handled, num_handled;
1722	u8 count = data->last_message_count;
1723
1724	if (count < 1 || count > data->max_reportid)
1725		count = 1;
1726
1727	/* include final invalid message */
1728	total_handled = mxt_read_count_messages(data, count + 1);
1729	if (total_handled < 0)
1730		return IRQ_NONE;
1731	/* if there were invalid messages, then we are done */
1732	else if (total_handled <= count)
1733		goto update_count;
1734
1735	/* read two at a time until an invalid message or else we reach
1736	 * reportid limit */
1737	do {
1738		num_handled = mxt_read_count_messages(data, 2);
1739		if (num_handled < 0)
1740			return IRQ_NONE;
1741
1742		total_handled += num_handled;
1743
1744		if (num_handled < 2)
1745			break;
1746	} while (total_handled < data->num_touchids);
1747
1748update_count:
1749	data->last_message_count = total_handled;
1750	mxt_input_sync(data);
1751	return IRQ_HANDLED;
1752}
1753
1754static irqreturn_t mxt_interrupt(int irq, void *dev_id)
1755{
1756	struct mxt_data *data = dev_id;
1757
1758	if (data->T44_address)
1759		return mxt_read_messages_t44(data);
1760	else
1761		return mxt_read_t9_messages(data);
1762}
1763
1764static void mxt_read_current_crc(struct mxt_data *data)
1765{
1766	/* CRC has already been read */
1767	if (data->config_crc > 0)
1768		return;
1769
1770	mxt_write_object(data, MXT_GEN_COMMAND_T6,
1771		MXT_COMMAND_REPORTALL, 1);
1772
1773	msleep(30);
1774
1775	/* Read all messages until invalid, this will update the
1776	   config crc stored in mxt_data */
1777	mxt_read_t9_messages_until_invalid(data);
1778
1779	/* on failure, CRC is set to 0 and config will always be downloaded */
1780}
1781
1782static int mxt_download_config(struct mxt_data *data, const char *fn)
1783{
1784	struct device *dev = &data->client->dev;
1785	struct mxt_info cfg_info;
1786	struct mxt_object *object;
1787	const struct firmware *cfg = NULL;
1788	int ret;
1789	int offset;
1790	int data_pos;
1791	int byte_offset;
1792	int i;
1793	int config_start_offset;
1794	u32 info_crc, config_crc;
1795	u8 *config_mem;
1796	size_t config_mem_size;
1797	unsigned int type, instance, size;
1798	u8 val;
1799	u16 reg;
1800	int add_num = 0;
1801
1802	ret = request_firmware(&cfg, fn, dev);
1803	if (ret < 0) {
1804		dev_err(dev, "Failure to request config file %s\n", fn);
1805		return 0;
1806	}
1807
1808	mxt_read_current_crc(data);
1809
1810	if (strncmp(cfg->data, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
1811		dev_err(dev, "Unrecognised config file\n");
1812		ret = -EINVAL;
1813		goto release;
1814	}
1815
1816	data_pos = strlen(MXT_CFG_MAGIC);
1817
1818	/* Load information block and check */
1819	for (i = 0; i < sizeof(struct mxt_info); i++) {
1820		ret = sscanf(cfg->data + data_pos, "%hhx%n",
1821			     (unsigned char *)&cfg_info + i,
1822			     &offset);
1823		if (ret != 1) {
1824			dev_err(dev, "Bad format\n");
1825			ret = -EINVAL;
1826			goto release;
1827		}
1828
1829		data_pos += offset;
1830	}
1831
1832	/* Read CRCs */
1833	ret = sscanf(cfg->data + data_pos, "%x%n", &info_crc, &offset);
1834	if (ret != 1) {
1835		dev_err(dev, "Bad format\n");
1836		ret = -EINVAL;
1837		goto release;
1838	}
1839	data_pos += offset;
1840
1841	ret = sscanf(cfg->data + data_pos, "%x%n", &config_crc, &offset);
1842	if (ret != 1) {
1843		dev_err(dev, "Bad format\n");
1844		ret = -EINVAL;
1845		goto release;
1846	}
1847	data_pos += offset;
1848
1849	/* The Info Block CRC is calculated over mxt_info and the object table
1850	 * If it does not match then we are trying to load the configuration
1851	 * from a different chip or firmware version, so the configuration CRC
1852	 * is invalid anyway. */
1853	if (info_crc == data->info_block_crc) {
1854		if (config_crc == 0 || data->config_crc == 0) {
1855			dev_info(dev, "CRC zero, attempting to apply config\n");
1856		} else if (config_crc == data->config_crc) {
1857			dev_info(dev, "Config CRC 0x%06X: OK\n", data->config_crc);
1858			ret = 0;
1859			goto release;
1860		} else {
1861			dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n",
1862				 data->config_crc, config_crc);
1863		}
1864	} else {
1865		dev_warn(dev, "Info block CRC mismatch - attempting to apply config\n");
1866	}
1867
1868	/* Malloc memory to store configuration */
1869	config_start_offset = MXT_OBJECT_START
1870		+ data->info.object_num * MXT_OBJECT_SIZE;
1871	config_mem_size = data->mem_size - config_start_offset;
1872	config_mem = kzalloc(config_mem_size, GFP_KERNEL);
1873	if (!config_mem) {
1874		dev_err(dev, "Failed to allocate memory\n");
1875		ret = -ENOMEM;
1876		goto release;
1877	}
1878
1879	while (data_pos < cfg->size) {
1880		/* Read type, instance, length */
1881		ret = sscanf(cfg->data + data_pos, "%x %x %x%n",
1882			     &type, &instance, &size, &offset);
1883		if (ret == 0) {
1884			/* EOF */
1885			break;
1886		} else if (ret != 3) {
1887			dev_err(dev, "Bad format\n");
1888			ret = -EINVAL;
1889			goto release_mem;
1890		}
1891		data_pos += offset;
1892		if (type == 35) {
1893			if (instance == 0) {
1894				type = 150 + add_num;
1895				add_num ++;
1896			} else
1897				type = 150 + add_num - 1;
1898		}
1899
1900		pr_info("write to type = %d, instance = %d, size = %d, offset = %d\n",
1901			(int)type, (int)instance, (int)size, (int)offset);
1902
1903		object = mxt_get_object(data, type);
1904		if (!object) {
1905			ret = -EINVAL;
1906			goto release_mem;
1907		}
1908
1909		if (instance >= object->instances) {
1910			dev_err(dev, "Object instances exceeded!\n");
1911			ret = -EINVAL;
1912			goto release_mem;
1913		}
1914
1915		reg = object->start_address + object->size * instance;
1916
1917		if (size > object->size) {
1918			/* Either we are in fallback mode due to wrong
1919			* config or config from a later fw version,
1920			* or the file is corrupt or hand-edited */
1921			dev_warn(dev, "Discarding %u bytes in T%u!\n",
1922				size - object->size, type);
1923			size = object->size;
1924		} else if (object->size > size) {
1925			/* If firmware is upgraded, new bytes may be added to
1926			* end of objects. It is generally forward compatible
1927			* to zero these bytes - previous behaviour will be
1928			* retained. However this does invalidate the CRC and
1929			* will force fallback mode until the configuration is
1930			* updated. We warn here but do nothing else - the
1931			* malloc has zeroed the entire configuration. */
1932			dev_warn(dev, "Zeroing %d byte(s) in T%d\n",
1933				object->size - size, type);
1934		}
1935
1936		for (i = 0; i < size; i++) {
1937			ret = sscanf(cfg->data + data_pos, "%hhx%n",
1938					&val,
1939					&offset);
1940			if (ret != 1) {
1941				dev_err(dev, "Bad format\n");
1942				ret = -EINVAL;
1943				goto release_mem;
1944			}
1945
1946			byte_offset = reg + i - config_start_offset;
1947
1948			/* Special case for T38:
1949			 * Since T38 is used to store userdata, when we update the
1950			 * config, the userdata shall not be updated. */
1951			if (get_hw_version_major() <= 4) {
1952				/* T38 is stored as config info in X5,
1953				 * no need to protect this register */
1954				if (type == MXT_SPT_USERDATA_T38 && i < MXT_USERDATA_SIZE)
1955					val = data->userdata_info[i];
1956			}
1957
1958			if ((byte_offset >= 0)
1959				&& (byte_offset <= config_mem_size)) {
1960				*(config_mem + byte_offset) = val;
1961			} else {
1962				dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n",
1963					reg, object->type, byte_offset);
1964				ret = -EINVAL;
1965				goto release_mem;
1966			}
1967
1968			data_pos += offset;
1969		}
1970	}
1971
1972	/* calculate crc of the received configs (not the raw config file) */
1973	if (data->T7_address < config_start_offset) {
1974		dev_err(dev, "Bad T7 address, T7addr = %x, config offset %x\n",
1975				data->T7_address, config_start_offset);
1976		ret = 0;
1977		goto release_mem;
1978	}
1979
1980
1981	/* Write configuration as blocks */
1982	byte_offset = 0;
1983	while (byte_offset < config_mem_size) {
1984		size = config_mem_size - byte_offset;
1985
1986		if (size > MXT_MAX_BLOCK_WRITE)
1987			size = MXT_MAX_BLOCK_WRITE;
1988
1989		ret = mxt_write_block(data->client,
1990				      config_start_offset + byte_offset,
1991				      size, config_mem + byte_offset);
1992		if (ret != 0) {
1993			dev_err(dev, "Config write error, ret=%d\n", ret);
1994			goto release_mem;
1995		}
1996
1997		byte_offset += size;
1998	}
1999
2000	ret = 1; /* tell the caller config has been sent */
2001
2002release_mem:
2003	kfree(config_mem);
2004release:
2005	release_firmware(cfg);
2006	return ret;
2007}
2008
2009static int mxt_chip_reset(struct mxt_data *data);
2010
2011static int mxt_set_power_cfg(struct mxt_data *data, u8 mode)
2012{
2013	struct device *dev = &data->client->dev;
2014	int error = 0;
2015	int i, cnt;
2016
2017	if (data->state != APPMODE) {
2018		dev_err(dev, "Not in APPMODE\n");
2019		return -EINVAL;
2020	}
2021
2022	switch (mode) {
2023	case MXT_POWER_CFG_DEEPSLEEP:
2024		/* Touch disable */
2025		cnt = ARRAY_SIZE(mxt_save);
2026		for (i = 0; i < cnt; i++) {
2027			if (mxt_get_object(data, mxt_save[i].suspend_obj) == NULL)
2028				continue;
2029			if (mxt_save[i].suspend_flags == MXT_SUSPEND_DYNAMIC)
2030				error |= mxt_write_object(data,
2031					mxt_save[i].suspend_obj,
2032					mxt_save[i].suspend_reg,
2033					mxt_save[i].suspend_val);
2034			if (error) {
2035				error = mxt_chip_reset(data);
2036				if (error)
2037					dev_err(dev, "Failed to do chip reset!\n");
2038				break;
2039			}
2040		}
2041		break;
2042
2043	case MXT_POWER_CFG_RUN:
2044	default:
2045		/* Touch enable */
2046		cnt =  ARRAY_SIZE(mxt_save);
2047		while (cnt--) {
2048			if (mxt_get_object(data, mxt_save[cnt].suspend_obj) == NULL)
2049				continue;
2050			error |= mxt_write_object(data,
2051						mxt_save[cnt].suspend_obj,
2052						mxt_save[cnt].suspend_reg,
2053						mxt_save[cnt].restore_val);
2054			if (error) {
2055				error = mxt_chip_reset(data);
2056				if (error)
2057					dev_err(dev, "Failed to do chip reset!\n");
2058				break;
2059			}
2060		}
2061		break;
2062	}
2063
2064	if (error)
2065		goto i2c_error;
2066
2067	data->is_stopped = (mode == MXT_POWER_CFG_DEEPSLEEP) ? 1 : 0;
2068
2069	return 0;
2070
2071i2c_error:
2072	dev_err(dev, "Failed to set power cfg\n");
2073	return error;
2074}
2075
2076static int mxt_read_power_cfg(struct mxt_data *data, u8 *actv_cycle_time,
2077				u8 *idle_cycle_time, u8 *actv2idle_timeout)
2078{
2079	int error;
2080
2081	error = mxt_read_object(data, MXT_GEN_POWER_T7,
2082				MXT_POWER_ACTVACQINT,
2083				actv_cycle_time);
2084	if (error)
2085		return error;
2086
2087	error = mxt_read_object(data, MXT_GEN_POWER_T7,
2088				MXT_POWER_IDLEACQINT,
2089				idle_cycle_time);
2090	if (error)
2091		return error;
2092
2093	error = mxt_read_object(data, MXT_GEN_POWER_T7,
2094				MXT_POWER_ACTV2IDLETO,
2095				actv2idle_timeout);
2096	if (error)
2097		return error;
2098
2099	return 0;
2100}
2101
2102static int mxt_check_power_cfg_post_reset(struct mxt_data *data)
2103{
2104	struct device *dev = &data->client->dev;
2105	int error;
2106
2107	error = mxt_read_power_cfg(data, &data->actv_cycle_time,
2108				   &data->idle_cycle_time,
2109				   &data->actv2idle_timeout);
2110	if (error)
2111		return error;
2112
2113	/* Power config is zero, select free run */
2114	if (data->actv_cycle_time == 0 || data->idle_cycle_time == 0) {
2115		dev_dbg(dev, "Overriding power cfg to free run\n");
2116		data->actv_cycle_time = 255;
2117		data->idle_cycle_time = 255;
2118
2119		error = mxt_set_power_cfg(data, MXT_POWER_CFG_RUN);
2120		if (error)
2121			return error;
2122	}
2123
2124	return 0;
2125}
2126
2127static int mxt_probe_power_cfg(struct mxt_data *data)
2128{
2129	int error;
2130
2131	data->slowscan_actv_cycle_time = 120;   /* 120mS */
2132	data->slowscan_idle_cycle_time = 10;    /* 10mS */
2133	data->slowscan_actv2idle_timeout = 100; /* 10 seconds */
2134
2135	error = mxt_read_power_cfg(data, &data->actv_cycle_time,
2136				   &data->idle_cycle_time,
2137				   &data->actv2idle_timeout);
2138	if (error)
2139		return error;
2140
2141	/* If in deep sleep mode, attempt reset */
2142	if (data->actv_cycle_time == 0 || data->idle_cycle_time == 0) {
2143		error = mxt_soft_reset(data, MXT_RESET_VALUE);
2144		if (error)
2145			return error;
2146
2147		error = mxt_check_power_cfg_post_reset(data);
2148		if (error)
2149			return error;
2150	}
2151
2152	return 0;
2153}
2154
2155static int mxt_read_internal_gpio(struct mxt_data *data)
2156{
2157	int ret;
2158	int timeout = 1000;
2159	int i = 0;
2160	bool is_timeout = true;
2161	struct device *dev = &data->client->dev;
2162	u8 val;
2163
2164	ret = mxt_write_object(data, MXT_SPT_GPIOPWM_T19,
2165			MXT_GPIOPWM_INTPULLUP, 0xFF);
2166	if (ret) {
2167		dev_err(dev, "Failed to enable internal pull-up resistor!\n");
2168		return ret;
2169	}
2170
2171	ret = mxt_write_object(data, MXT_SPT_GPIOPWM_T19,
2172			MXT_GPIOPWM_CTRL, MXT_GPIO_FORCERPT);
2173	if (ret) {
2174		dev_err(dev, "Failed to write force report to GPIO !\n");
2175		return ret;
2176	}
2177
2178	while (i < timeout) {
2179		ret = mxt_read_object(data, MXT_SPT_GPIOPWM_T19,
2180				MXT_GPIOPWM_CTRL, &val);
2181		if (ret) {
2182			dev_err(dev, "Failed to read GPIO ctrl status !\n");
2183			return ret;
2184		}
2185
2186		if ((val & MXT_GPIO_FORCERPT) == 0x3) {
2187			is_timeout = false;
2188			break;
2189		}
2190		i++;
2191		msleep(1);
2192	}
2193
2194	if (is_timeout) {
2195		dev_err(dev, "polling forcerpt bit timeout !\n");
2196		return -ETIMEDOUT;
2197	}
2198
2199	mxt_read_t9_messages_until_invalid(data);
2200
2201	ret = mxt_write_object(data, MXT_SPT_GPIOPWM_T19,
2202			MXT_GPIOPWM_INTPULLUP, 0);
2203	if (ret) {
2204		dev_err(dev, "Failed to disable internal pull-up resistor!\n");
2205		return ret;
2206	}
2207
2208	ret = mxt_write_object(data, MXT_SPT_GPIOPWM_T19,
2209			MXT_GPIOPWM_CTRL, MXT_GPIO_DISABLEOUTPUT);
2210	if (ret) {
2211		dev_err(dev, "Failed to disable reading GPIO status!\n");
2212		return ret;
2213	}
2214
2215	return 0;
2216}
2217
2218static const char * mxt_get_config(struct mxt_data *data, bool is_default)
2219{
2220	const struct mxt_platform_data *pdata = data->pdata;
2221	int i;
2222    extern int panel_id;
2223	int lcd_id = panel_id;
2224
2225	if (pdata->default_config == -1) {
2226		/* no default config is set */
2227		is_default = false;
2228	}
2229
2230	for (i = 0; i < pdata->config_array_size; i++) {
2231		if (data->info.family_id== pdata->config_array[i].family_id &&
2232			data->info.variant_id == pdata->config_array[i].variant_id &&
2233			data->info.version == pdata->config_array[i].version &&
2234			data->info.build == pdata->config_array[i].build &&
2235			data->vendor_id == pdata->config_array[i].vendor_id) {
2236			if (get_hw_version_major() == 4 && data->rev_id == pdata->config_array[i].rev_id) {
2237				break;
2238			} else if (get_hw_version_major() == 3 && lcd_id == pdata->config_array[i].lcd_id) {
2239				break;
2240			}
2241		}
2242	}
2243
2244	if (i >= pdata->config_array_size) {
2245		/* No matching config */
2246		if (!is_default)
2247			return NULL;
2248		else
2249			i = pdata->default_config;
2250	}
2251
2252	dev_info(&data->client->dev, "Choose config %d: %s, is_default = %d\n",
2253		i, pdata->config_array[i].mxt_cfg_name, is_default);
2254
2255	data->current_index = i;
2256	return pdata->config_array[i].mxt_cfg_name;
2257}
2258
2259static int mxt_backup_nv(struct mxt_data *data)
2260{
2261	int error;
2262	u8 command_register;
2263	int timeout_counter = 0;
2264
2265	/* Backup to memory */
2266	mxt_write_object(data, MXT_GEN_COMMAND_T6,
2267			MXT_COMMAND_BACKUPNV,
2268			MXT_BACKUP_VALUE);
2269	msleep(MXT_BACKUP_TIME);
2270
2271	do {
2272		error = mxt_read_object(data, MXT_GEN_COMMAND_T6,
2273					MXT_COMMAND_BACKUPNV,
2274					&command_register);
2275		if (error)
2276			return error;
2277
2278		msleep(20);
2279
2280	} while ((command_register != 0) && (++timeout_counter <= 100));
2281
2282	if (timeout_counter > 100) {
2283		dev_err(&data->client->dev, "No response after backup!\n");
2284		return -EIO;
2285	}
2286
2287	/* Soft reset */
2288	error = mxt_soft_reset(data, MXT_RESET_VALUE);
2289	if (error) {
2290		dev_err(&data->client->dev, "Failed to do reset!\n");
2291		return error;
2292	}
2293
2294	return 0;
2295}
2296
2297static int mxt_read_rev(struct mxt_data *data)
2298{
2299	struct device *dev = &data->client->dev;
2300	int ret;
2301	int i = 0;
2302	u8 val;
2303
2304	ret = mxt_write_object(data, MXT_GEN_COMMAND_T6,
2305				MXT_COMMAND_DIAGNOSTIC, 0x80);
2306	if (ret) {
2307		dev_err(dev, "Failed to send rev read command!\n");
2308		return ret;
2309	}
2310
2311	while (i < 100) {
2312		ret = mxt_read_object(data, MXT_GEN_COMMAND_T6,
2313					MXT_COMMAND_DIAGNOSTIC, &val);
2314		if (ret) {
2315			dev_err(dev, "Failed to read diagnostic!\n");
2316			return ret;
2317		}
2318
2319		if (val == 0)
2320			break;
2321		i++;
2322		msleep(10);
2323	}
2324
2325	ret = mxt_read_object(data, MXT_DEBUG_DIAGNOSTIC_T37,
2326				MXT_DIAG_REV_ID, &data->rev_id);
2327	if (ret) {
2328		pr_err("Failed to read rev id!\n");
2329		return ret;
2330	}
2331
2332	pr_info("read rev_id = 0x%x\n", data->rev_id);
2333
2334	return 0;
2335}
2336
2337static int mxt_read_userdata_info(struct mxt_data *data)
2338{
2339	int ret = 0;
2340	struct mxt_object *object;
2341	u16 reg;
2342
2343	object = mxt_get_object(data, MXT_SPT_USERDATA_T38);
2344	if (!object)
2345		return -EINVAL;
2346
2347	reg = object->start_address;
2348	ret = mxt_read_reg(data->client, reg,
2349		MXT_USERDATA_SIZE, data->userdata_info);
2350	if (ret)
2351		dev_err(&data->client->dev, "Failed to read T38\n");
2352
2353	return ret;
2354}
2355
2356static int mxt_read_lockdown_info(struct mxt_data *data)
2357{
2358	struct device *dev = &data->client->dev;
2359	struct mxt_object *object;
2360	int ret, i = 0;
2361	u8 val;
2362	u16 reg;
2363
2364	ret = mxt_write_object(data, MXT_GEN_COMMAND_T6,
2365				MXT_COMMAND_DIAGNOSTIC, 0x81);
2366	if (ret) {
2367		dev_err(dev, "Failed to send lockdown info read command!\n");
2368		return ret;
2369	}
2370
2371	while (i < 100) {
2372		ret = mxt_read_object(data, MXT_GEN_COMMAND_T6,
2373				MXT_COMMAND_DIAGNOSTIC, &val);
2374		if (ret) {
2375			dev_err(dev, "Failed to read diagnostic!\n");
2376			return ret;
2377		}
2378
2379		if (val == 0)
2380			break;
2381
2382		i++;
2383		msleep(10);
2384	}
2385
2386	object = mxt_get_object(data, MXT_DEBUG_DIAGNOSTIC_T37);
2387	if (!object)
2388		return -EINVAL;
2389
2390	reg = object->start_address;
2391	ret = mxt_read_reg(data->client, reg + MXT_LOCKDOWN_OFFSET,
2392			MXT_LOCKDOWN_SIZE, data->lockdown_info);
2393	if (ret)
2394		dev_err(dev, "Failed to read lockdown info!\n");
2395
2396	return 0;
2397}
2398
2399static int mxt_check_reg_init(struct mxt_data *data)
2400{
2401	struct device *dev = &data->client->dev;
2402	int ret;
2403	const char* config_name = NULL;
2404	bool is_recheck = false, use_default_cfg = false;
2405
2406	if (data->firmware_updated)
2407		use_default_cfg = true;
2408
2409start:
2410	if (get_hw_version_major() == 4) {
2411		ret = mxt_read_rev(data);
2412		if (ret) {
2413			dev_err(dev, "Can not get rev!\n");
2414			is_recheck = true;
2415		} else {
2416			is_recheck = false;
2417		}
2418	}
2419
2420	ret = mxt_read_internal_gpio(data);
2421	if (ret) {
2422		dev_err(dev, "Can not get internal gpio status!\n");
2423		is_recheck = true;
2424	} else {
2425		is_recheck = false;
2426	}
2427
2428	if (get_hw_version_major() >= 5) {
2429		/*
2430		 * Firmware 1.5.AA supports lockdown info, which is only
2431		 * used for X5
2432		 */
2433		ret = mxt_read_lockdown_info(data);
2434		if (ret) {
2435			dev_err(dev, "Cannot get lockdown info, set lockdown info to 0xFF!\n");
2436			memset(data->lockdown_info, 0xFF, MXT_LOCKDOWN_SIZE);
2437		}
2438
2439		dev_info(dev, "Got lockdown info: %02X %02X %02X %02X %02X %02X %02X %02X\n",
2440				data->lockdown_info[0], data->lockdown_info[1],
2441				data->lockdown_info[2], data->lockdown_info[3],
2442				data->lockdown_info[4], data->lockdown_info[5],
2443				data->lockdown_info[6], data->lockdown_info[7]);
2444
2445		/* In X5, we use lockdown info for storing TP vendor info */
2446		data->vendor_id = data->lockdown_info[0];
2447
2448		/* Lockdown info is not flashed into some old TP panels,
2449		 * set the default vendor id to 0x38 */
2450		if (data->vendor_id == 0) {
2451			dev_err(dev, "TP maker info is empty, use the default one!\n");
2452			data->vendor_id = 0x38;	/* Default vendor is sharp */
2453		}
2454	}
2455
2456	config_name = mxt_get_config(data, use_default_cfg);
2457
2458	/* If we need to recheck, we shall not get a default config */
2459	if (use_default_cfg)
2460		use_default_cfg = false;
2461
2462	ret = mxt_read_userdata_info(data);
2463	if (ret) {
2464		dev_err(dev, "Can not get userdata info(T38)!\n");
2465	} else {
2466		dev_info(dev, "Got userdata info: %02X %02X %02X %02X %02X %02X %02X %02X",
2467			data->userdata_info[0], data->userdata_info[1],
2468			data->userdata_info[2], data->userdata_info[3],
2469			data->userdata_info[4], data->userdata_info[5],
2470			data->userdata_info[6], data->userdata_info[7]);
2471	}
2472
2473	if (config_name == NULL) {
2474		dev_info(dev, "Not found matched config!\n");
2475		return -ENOENT;
2476	}
2477
2478	ret = mxt_download_config(data, config_name);
2479	if (ret < 0)
2480		return ret;
2481	else if (ret == 0)
2482		/* CRC matched, or no config file, or config parse failure
2483		 * - no need to reset */
2484		return 0;
2485
2486	/* Backup to memory */
2487	ret = mxt_backup_nv(data);
2488	if (ret) {
2489		dev_err(dev, "back nv failed!\n");
2490		return ret;
2491	}
2492
2493	if (is_recheck)
2494		goto start;
2495
2496	ret = mxt_check_power_cfg_post_reset(data);
2497	if (ret)
2498		return ret;
2499
2500	return 0;
2501}
2502
2503static int mxt_read_info_block_crc(struct mxt_data *data)
2504{
2505	int ret;
2506	u16 offset;
2507	u8 buf[3];
2508
2509	offset = MXT_OBJECT_START + MXT_OBJECT_SIZE * data->info.object_num;
2510
2511	ret = mxt_read_reg(data->client, offset, sizeof(buf), buf);
2512	if (ret)
2513		return ret;
2514
2515	data->info_block_crc = (buf[2] << 16) | (buf[1] << 8) | buf[0];
2516
2517	return 0;
2518}
2519
2520static int mxt_get_object_table(struct mxt_data *data)
2521{
2522	struct i2c_client *client = data->client;
2523	struct device *dev = &data->client->dev;
2524	int ret;
2525	int i;
2526	u16 end_address;
2527	u8 reportid = 0;
2528	u8 buf[data->info.object_num][MXT_OBJECT_SIZE];
2529	int add_num = 0;
2530	data->mem_size = 0;
2531
2532	data->object_table = kcalloc(data->info.object_num,
2533				     sizeof(struct mxt_object), GFP_KERNEL);
2534	if (!data->object_table) {
2535		dev_err(dev, "Failed to allocate object table\n");
2536		return -ENOMEM;
2537	}
2538
2539	ret = mxt_read_reg(client, MXT_OBJECT_START, sizeof(buf), buf);
2540	if (ret)
2541		goto free_object_table;
2542
2543	for (i = 0; i < data->info.object_num; i++) {
2544		struct mxt_object *object = data->object_table + i;
2545
2546		object->type = buf[i][0];
2547		if (object->type == 35) {
2548			object->type = 150 + add_num;
2549			add_num ++;
2550		}
2551		object->start_address = (buf[i][2] << 8) | buf[i][1];
2552		object->size = buf[i][3] + 1;
2553		object->instances = buf[i][4] + 1;
2554		object->num_report_ids = buf[i][5];
2555
2556		if (object->num_report_ids) {
2557			reportid += object->num_report_ids * object->instances;
2558			object->max_reportid = reportid;
2559			object->min_reportid = object->max_reportid -
2560				object->instances * object->num_report_ids + 1;
2561		}
2562
2563		end_address = object->start_address
2564			+ object->size * object->instances - 1;
2565
2566		if (end_address >= data->mem_size)
2567			data->mem_size = end_address + 1;
2568
2569		/* save data for objects used when processing interrupts */
2570		switch (object->type) {
2571		case MXT_TOUCH_MULTI_T9:
2572			data->T9_reportid_max = object->max_reportid;
2573			data->T9_reportid_min = object->min_reportid;
2574			data->num_touchids = object->num_report_ids * object->instances;
2575			break;
2576		case MXT_GEN_COMMAND_T6:
2577			data->T6_reportid = object->max_reportid;
2578			break;
2579		case MXT_GEN_MESSAGE_T5:
2580			if (data->info.family_id == 0x80) {
2581				/* On mXT224 must read and discard CRC byte
2582				 * otherwise DMA reads are misaligned */
2583				data->T5_msg_size = object->size;
2584			} else {
2585				/* CRC not enabled, therefore don't read last byte */
2586				data->T5_msg_size = object->size - 1;
2587			}
2588			data->T5_address = object->start_address;
2589			break;
2590		case MXT_GEN_POWER_T7:
2591			data->T7_address = object->start_address;
2592			break;
2593		case MXT_TOUCH_KEYARRAY_T15:
2594			data->T15_reportid_max = object->max_reportid;
2595			data->T15_reportid_min = object->min_reportid;
2596			break;
2597		case MXT_SPT_GPIOPWM_T19:
2598			data->T19_reportid_max = object->max_reportid;
2599			data->T19_reportid_min = object->min_reportid;
2600			break;
2601		case MXT_SPT_SELFTEST_T25:
2602			data->T25_reportid_max = object->max_reportid;
2603			data->T25_reportid_min = object->min_reportid;
2604			break;
2605		case MXT_DEBUG_DIAGNOSTIC_T37:
2606			data->T37_address = object->start_address;
2607			break;
2608		case MXT_PROCI_TOUCHSUPPRESSION_T42:
2609			data->T42_reportid_max = object->max_reportid;
2610			data->T42_reportid_min = object->min_reportid;
2611			break;
2612		case MXT_SPT_MESSAGECOUNT_T44:
2613			data->T44_address = object->start_address;
2614			break;
2615		case MXT_SPT_NOISESUPPRESSION_T48:
2616			data->T48_reportid = object->max_reportid;
2617			break;
2618		case MXT_PROCI_ACTIVE_STYLUS_T63:
2619			data->T63_reportid_max = object->max_reportid;
2620			data->T63_reportid_min = object->min_reportid;
2621			data->num_stylusids =
2622				object->num_report_ids * object->instances;
2623			break;
2624		case MXT_SPT_GOLDENREF_T66:
2625			data->T66_reportid = object->max_reportid;
2626			break;
2627		case MXT_TOUCH_MORE_GESTURE_T81:
2628			data->T81_reportid_min = object->min_reportid;
2629			data->T81_reportid_max = object->max_reportid;
2630			break;
2631		case MXT_TOUCH_GESTURE_T92:
2632			data->T92_reportid_min = object->min_reportid;
2633			data->T92_reportid_max = object->max_reportid;
2634			break;
2635		case MXT_TOUCH_MULTI_T100:
2636			data->T100_reportid_max = object->max_reportid;
2637			data->T100_reportid_min = object->min_reportid;
2638			data->num_touchids = object->num_report_ids * object->instances;
2639			break;
2640		case MXT_SPT_SELFCAPGLOBALCONFIG_T109:
2641			data->T109_reportid = object->max_reportid;
2642			break;
2643		}
2644
2645		dev_dbg(dev, "T%u, start:%u size:%u instances:%u "
2646			"min_reportid:%u max_reportid:%u\n",
2647			object->type, object->start_address, object->size,
2648			object->instances,
2649			object->min_reportid, object->max_reportid);
2650	}
2651
2652	/* Store maximum reportid */
2653	data->max_reportid = reportid;
2654
2655	/* If T44 exists, T9 position has to be directly after */
2656	if (data->T44_address && (data->T5_address != data->T44_address + 1)) {
2657		dev_err(dev, "Invalid T44 position\n");
2658		ret = -EINVAL;
2659		goto free_object_table;
2660	}
2661
2662	/* Allocate message buffer */
2663	data->msg_buf = kcalloc(data->max_reportid, data->T5_msg_size, GFP_KERNEL);
2664	if (!data->msg_buf) {
2665		dev_err(dev, "Failed to allocate message buffer\n");
2666		ret = -ENOMEM;
2667		goto free_object_table;
2668	}
2669
2670	return 0;
2671
2672free_object_table:
2673	kfree(data->object_table);
2674	return ret;
2675}
2676
2677static int mxt_read_resolution(struct mxt_data *data)
2678{
2679	struct i2c_client *client = data->client;
2680	int error;
2681	unsigned int x_range, y_range;
2682	unsigned char orient;
2683	unsigned char val;
2684
2685	/* Update matrix size in info struct */
2686	error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, 1, &val);
2687	if (error)
2688		return error;
2689	data->info.matrix_xsize = val;
2690
2691	error = mxt_read_reg(client, MXT_MATRIX_Y_SIZE, 1, &val);
2692	if (error)
2693		return error;
2694	data->info.matrix_ysize = val;
2695
2696	if (mxt_get_object(data, MXT_TOUCH_MULTI_T100) != NULL) {
2697		/* Read X/Y size of touchscreen */
2698		error =  mxt_read_object(data, MXT_TOUCH_MULTI_T100,
2699				MXT_MULTITOUCH_XRANGE_MSB, &val);
2700		if (error)
2701			return error;
2702		x_range = val << 8;
2703
2704		error =  mxt_read_object(data, MXT_TOUCH_MULTI_T100,
2705				MXT_MULTITOUCH_XRANGE_LSB, &val);
2706		if (error)
2707			return error;
2708		x_range |= val;
2709
2710		error =  mxt_read_object(data, MXT_TOUCH_MULTI_T100,
2711				MXT_MULTITOUCH_YRANGE_MSB, &val);
2712		if (error)
2713			return error;
2714		y_range = val << 8;
2715
2716		error =  mxt_read_object(data, MXT_TOUCH_MULTI_T100,
2717				MXT_MULTITOUCH_YRANGE_LSB, &val);
2718		if (error)
2719			return error;
2720		y_range |= val;
2721
2722		error =  mxt_read_object(data, MXT_TOUCH_MULTI_T100,
2723				MXT_MULTITOUCH_CFG1, &val);
2724		if (error)
2725			return error;
2726		orient = (val & 0xE0) >> 5;
2727	} else {
2728		/* Read X/Y size of touchscreen */
2729		error =  mxt_read_object(data, MXT_TOUCH_MULTI_T9,
2730				MXT_TOUCH_XRANGE_MSB, &val);
2731		if (error)
2732			return error;
2733		x_range = val << 8;
2734
2735		error =  mxt_read_object(data, MXT_TOUCH_MULTI_T9,
2736				MXT_TOUCH_XRANGE_LSB, &val);
2737		if (error)
2738			return error;
2739		x_range |= val;
2740
2741		error =  mxt_read_object(data, MXT_TOUCH_MULTI_T9,
2742				MXT_TOUCH_YRANGE_MSB, &val);
2743		if (error)
2744			return error;
2745		y_range = val << 8;
2746
2747		error =  mxt_read_object(data, MXT_TOUCH_MULTI_T9,
2748				MXT_TOUCH_YRANGE_LSB, &val);
2749		if (error)
2750			return error;
2751		y_range |= val;
2752
2753		error =  mxt_read_object(data, MXT_TOUCH_MULTI_T9,
2754				MXT_TOUCH_ORIENT, &orient);
2755		if (error)
2756			return error;
2757	}
2758
2759	dev_info(&client->dev, "xrange = %d, yrange = %d\n", x_range, y_range);
2760	/* Handle default values */
2761	if (x_range == 0)
2762		x_range = 1023;
2763
2764	if (y_range == 0)
2765		y_range = 1023;
2766
2767	if (orient & MXT_XY_SWITCH) {
2768		data->max_x = y_range;
2769		data->max_y = x_range;
2770	} else {
2771		data->max_x = x_range;
2772		data->max_y = y_range;
2773	}
2774
2775	dev_info(&client->dev,
2776			"Matrix Size X%uY%u Touchscreen size X%uY%u\n",
2777			data->info.matrix_xsize, data->info.matrix_ysize,
2778			data->max_x, data->max_y);
2779
2780	return 0;
2781}
2782
2783static void mxt_initialize_regulator(struct mxt_data *data)
2784{
2785	int ret;
2786	struct i2c_client *client = data->client;
2787
2788	/*
2789		Vdd and AVdd can be powered up in any order
2790		XVdd must not be powered up until after Vdd
2791		and must obey the rate-of-rise specification
2792	*/
2793
2794	data->regulator_vdd = devm_regulator_get(&client->dev, "vdd");
2795	if (IS_ERR(data->regulator_vdd)) {
2796		dev_info(&client->dev,
2797			"Atmel regulator_get for vdd failed: %ld\n",
2798						PTR_ERR(data->regulator_vdd));
2799		goto err_null_regulator;
2800	}
2801
2802	data->regulator_avdd = devm_regulator_get(&client->dev, "avdd");
2803	if (IS_ERR(data->regulator_avdd)) {
2804		dev_info(&client->dev,
2805			"Atmel regulator_get for avdd failed: %ld\n",
2806						PTR_ERR(data->regulator_avdd));
2807		goto err_put_regulator_vdd;
2808	}
2809
2810	data->regulator_vddio = devm_regulator_get(&client->dev, "vddio");
2811	if (IS_ERR(data->regulator_vddio)) {
2812		dev_info(&client->dev,
2813			"Atmel regulator_get for avdd failed: %ld\n",
2814						PTR_ERR(data->regulator_vddio));
2815		goto err_put_regulator_avdd;
2816	}
2817
2818	dev_info(&client->dev,
2819		"Atmel regulator_get for vdd and avdd succeeded\n");
2820
2821	ret = regulator_enable(data->regulator_vdd);
2822	if (ret < 0)
2823		dev_err(&client->dev,
2824		"Atmel regulator_enable for vdd failed; Error code:%d\n", ret);
2825
2826	ret = regulator_enable(data->regulator_avdd);
2827	if (ret < 0)
2828		dev_err(&client->dev,
2829		"Atmel regulator_enable for avdd failed; Error code:%d\n", ret);
2830
2831	ret = regulator_enable(data->regulator_vddio);
2832	if (ret < 0)
2833		dev_err(&client->dev,
2834		"Atmel regulator_enable for avdd failed; Error code:%d\n", ret);
2835	return;
2836
2837err_put_regulator_avdd:
2838	devm_regulator_put(data->regulator_avdd);
2839err_put_regulator_vdd:
2840	devm_regulator_put(data->regulator_vdd);
2841err_null_regulator:
2842	data->regulator_vddio = NULL;
2843	data->regulator_avdd = NULL;
2844	data->regulator_vdd = NULL;
2845}
2846
2847static ssize_t mxt_update_fw_store(struct device *dev,
2848					struct device_attribute *attr,
2849					const char *buf, size_t count);
2850
2851
2852static int mxt_wait_for_self_tune_msg(struct mxt_data *data, u8 expect_val)
2853{
2854	int time_out = 1000;
2855	int i = 0;
2856
2857	while(i < time_out) {
2858		if (data->selfcap_status.cmd == expect_val)
2859			return 0;
2860		i++;
2861		msleep(10);
2862	}
2863
2864	return -ETIMEDOUT;
2865}
2866
2867static int mxt_do_self_tune(struct mxt_data *data, u8 cmd)
2868{
2869	int error;
2870	struct device *dev = &data->client->dev;
2871
2872	memset(&data->selfcap_status, 0x0, sizeof(data->selfcap_status));
2873
2874	if (mxt_get_object(data, MXT_SPT_SELFCAPGLOBALCONFIG_T109) == NULL) {
2875		dev_err(dev, "No T109 exist!\n");
2876		return 0;
2877	}
2878
2879	error = mxt_write_object(data, MXT_SPT_SELFCAPGLOBALCONFIG_T109,
2880					MXT_SELFCAPCFG_CTRL, MXT_SELFCTL_RPTEN);
2881	if (error) {
2882		dev_err(dev, "Error when enable t109 report en!\n");
2883		return error;
2884	}
2885
2886	error = mxt_write_object(data, MXT_SPT_SELFCAPGLOBALCONFIG_T109,
2887					MXT_SELFCAPCFG_CMD, cmd);
2888	if (error) {
2889		dev_err(dev, "Error when execute cmd 0x%x!\n", cmd);
2890		return error;
2891	}
2892
2893	error = mxt_wait_for_self_tune_msg(data, cmd);
2894
2895	if(!error) {
2896		if (data->selfcap_status.error_code != 0)
2897			return -EINVAL;
2898	}
2899
2900	return 0;
2901}
2902
2903static int mxt_get_t38_flag(struct mxt_data *data)
2904{
2905	int error;
2906	u8 flag;
2907
2908	error = mxt_read_object(data, MXT_SPT_USERDATA_T38,
2909					MXT_FW_UPDATE_FLAG, &flag);
2910	if (error)
2911		return error;
2912
2913	data->update_flag = flag;
2914
2915	return 0;
2916}
2917
2918static int mxt_get_init_setting(struct mxt_data *data)
2919{
2920	int error;
2921	u8 selfthr;
2922	u8 intthr;
2923	u8 glovectrl;
2924	u8 atchthr;
2925	int i;
2926	struct device *dev = &data->client->dev;
2927	const struct mxt_platform_data *pdata = data->pdata;
2928	int index = data->current_index;
2929
2930	if (mxt_get_object(data, MXT_SPT_AUXTOUCHCONFIG_T104) != NULL) {
2931		error = mxt_read_object(data, MXT_SPT_AUXTOUCHCONFIG_T104,
2932						MXT_AUXTCHCFG_XTCHTHR, &selfthr);
2933		if (error) {
2934			dev_err(dev, "Failed to read self threshold from t104!\n");
2935			return error;
2936		}
2937
2938		error = mxt_read_object(data, MXT_SPT_AUXTOUCHCONFIG_T104,
2939						MXT_AUXTCHCFG_INTTHRX, &intthr);
2940		if (error) {
2941			dev_err(dev, "Failed to read internal threshold from t104!\n");
2942			return error;
2943		}
2944	}
2945
2946	if (mxt_get_object(data, MXT_PROCI_GLOVEDETECTION_T78) != NULL) {
2947		error = mxt_read_object(data, MXT_PROCI_GLOVEDETECTION_T78,
2948						MXT_GLOVE_CTRL, &glovectrl);
2949		if (error) {
2950			dev_err(dev, "Failed to read glove setting from t78!\n");
2951			return error;
2952		}
2953		if ((glovectrl & 0x01) != 0)
2954			data->sensitive_mode = 1;
2955	}
2956
2957	if (mxt_get_object(data, MXT_PROCI_RETRANSMISSIONCOMPENSATION_T80) != NULL) {
2958		error = mxt_read_object(data, MXT_PROCI_RETRANSMISSIONCOMPENSATION_T80,
2959					MXT_RETRANS_ATCHTHR, &atchthr);
2960		if (error) {
2961			dev_err(dev, "Faield to read from t80 anti-touch threshold!\n");
2962			return error;
2963		}
2964		data->atchthr = atchthr;
2965	}
2966
2967	for (i = 0; i < ARRAY_SIZE(mxt_save); i++) {
2968		error = mxt_read_object(data, MXT_GEN_POWER_T7,
2969					i, &mxt_save[i].restore_val);
2970		if (error) {
2971			dev_err(dev, "Failed to read T7 byte %d\n", i);
2972			return error;
2973		}
2974	}
2975
2976	if (mxt_get_object(data, MXT_PROCG_NOISESUPSELFCAP_T108) != NULL) {
2977		for (i = 0; i < ARRAY_SIZE(data->adcperx_normal); i++) {
2978			data->adcperx_wakeup[i] = pdata->config_array[index].wake_up_self_adcx;
2979			error = mxt_read_object(data, MXT_PROCG_NOISESUPSELFCAP_T108,
2980						19 + i, &data->adcperx_normal[i]);
2981			if (error)  {
2982				dev_err(dev, "Failed to read T108 setting %d\n", i);
2983				return error;
2984			}
2985		}
2986	}
2987
2988	error = mxt_read_resolution(data);
2989	if (error) {
2990		dev_err(dev, "Failed to initialize screen size\n");
2991		return error;
2992	}
2993
2994	return 0;
2995}
2996
2997static int mxt_initialize(struct mxt_data *data)
2998{
2999	struct i2c_client *client = data->client;
3000	struct mxt_info *info = &data->info;
3001	int error;
3002	u8 retry_count = 0;
3003
3004retry_probe:
3005	/* Read info block */
3006	error = mxt_read_reg(client, 0, sizeof(*info), info);
3007	if (error) {
3008		error = mxt_probe_bootloader(data);
3009		if (error) {
3010			/* Chip is not in appmode or bootloader mode */
3011			return error;
3012		} else {
3013			if (++retry_count > 10) {
3014				dev_err(&client->dev,
3015					"Could not recover device from "
3016					"bootloader mode\n");
3017				data->state = BOOTLOADER;
3018				/* this is not an error state, we can reflash
3019				 * from here */
3020				 error = mxt_update_firmware(&client->dev, NULL,
3021						data->pdata->mxt_fw_name,
3022						strlen(data->pdata->mxt_fw_name),
3023						&data->firmware_updated);
3024				if (error != strlen(data->pdata->mxt_fw_name))
3025				{
3026					dev_err(&client->dev, "Error when update firmware!\n");
3027					return error;
3028				}
3029				return 0;
3030			}
3031
3032			/* Tell bootloader to enter app mode. Ignore errors
3033			 * since we're in a retry loop */
3034			mxt_send_bootloader_cmd(data, false);
3035			msleep(MXT_FWRESET_TIME);
3036			goto retry_probe;
3037		}
3038	}
3039
3040	dev_info(&client->dev,
3041		"Family ID: %d Variant ID: %d Version: %d.%d.%02X "
3042		"Object Num: %d\n",
3043		info->family_id, info->variant_id,
3044		info->version >> 4, info->version & 0xf,
3045		info->build, info->object_num);
3046
3047	data->state = APPMODE;
3048
3049	/* Get object table information */
3050	error = mxt_get_object_table(data);
3051	if (error) {
3052		dev_err(&client->dev, "Error %d reading object table\n", error);
3053		return error;
3054	}
3055
3056	error = mxt_get_t38_flag(data);
3057	if (error) {
3058		dev_err(&client->dev, "Error %d getting update flag\n", error);
3059		return error;
3060	}
3061
3062	/* Read information block CRC */
3063	error = mxt_read_info_block_crc(data);
3064	if (error) {
3065		dev_err(&client->dev, "Error %d reading info block CRC\n", error);
3066	}
3067
3068	error = mxt_probe_power_cfg(data);
3069	if (error) {
3070		dev_err(&client->dev, "Failed to initialize power cfg\n");
3071		return error;
3072	}
3073
3074	/* Check register init values */
3075	error = mxt_check_reg_init(data);
3076	if (error) {
3077		dev_err(&client->dev, "Failed to initialize config\n");
3078		return error;
3079	}
3080
3081	if (mxt_get_object(data, MXT_TOUCH_MULTI_T100) != NULL)
3082	{
3083		error = mxt_read_object(data, MXT_TOUCH_MULTI_T100,
3084					MXT_MULTITOUCH_TCHAUX,
3085					&data->t100_tchaux_bits);
3086		if (error) {
3087			dev_err(&client->dev, "Failed to read tchaux!\n");
3088			return error;
3089		}
3090	}
3091
3092	error = mxt_get_init_setting(data);
3093	if (error) {
3094		dev_err(&client->dev, "Failed to get init setting.\n");
3095		return error;
3096	}
3097
3098	return 0;
3099}
3100
3101static int strtobyte(const char *data, u8 *value)
3102{
3103	char str[3];
3104
3105	str[0] = data[0];
3106	str[1] = data[1];
3107	str[2] = '\0';
3108
3109	return kstrtou8(str, 16, value);
3110}
3111
3112static size_t mxt_convert_text_to_binary(u8 *buffer, size_t len)
3113{
3114	int ret;
3115	int i;
3116	int j = 0;
3117
3118	for (i = 0; i < len; i+=2) {
3119		ret = strtobyte(&buffer[i], &buffer[j]);
3120		if (ret) {
3121			return -EINVAL;
3122		}
3123		j++;
3124	}
3125
3126	return (size_t)j;
3127}
3128
3129static int mxt_check_firmware_format(struct device *dev, const struct firmware *fw)
3130{
3131	unsigned int pos = 0;
3132	char c;
3133
3134	while (pos < fw->size) {
3135		c = *(fw->data + pos);
3136
3137		if (c < '0' || (c > '9' && c < 'A') || c > 'F')
3138			return 0;
3139
3140		pos++;
3141	}
3142
3143	/* To convert file try
3144	  * xxd -r -p mXTXXX__APP_VX-X-XX.enc > maxtouch.fw */
3145	dev_err(dev, "Aborting: firmware file must be in binary format\n");
3146
3147	return -1;
3148}
3149
3150static void mxt_reset_toggle(struct mxt_data *data)
3151{
3152	const struct mxt_platform_data *pdata = data->pdata;
3153	int i;
3154
3155	for (i = 0; i < 10; i++) {
3156		gpio_set_value_cansleep(pdata->reset_gpio, 0);
3157		msleep(1);
3158		gpio_set_value_cansleep(pdata->reset_gpio, 1);
3159		msleep(60);
3160	}
3161
3162	gpio_set_value_cansleep(pdata->reset_gpio, 1);
3163}
3164
3165static int mxt_load_fw(struct device *dev, const char *fn)
3166{
3167	struct mxt_data *data = dev_get_drvdata(dev);
3168	const struct firmware *fw = NULL;
3169	unsigned int frame_size;
3170	unsigned int pos = 0;
3171	unsigned int retry = 0;
3172	unsigned int frame= 0;
3173	int ret;
3174	unsigned short ori_addr = data->client->addr;
3175	size_t len = 0;
3176	u8 *buffer;
3177
3178	ret = request_firmware(&fw, fn, dev);
3179	if (ret < 0) {
3180		dev_err(dev, "Unable to open firmware %s\n", fn);
3181		return ret;
3182	}
3183
3184	buffer = kmalloc(fw->size ,GFP_KERNEL);
3185	if (!buffer) {
3186		dev_err(dev, "malloc firmware buffer failed!\n");
3187		return -ENOMEM;
3188	}
3189	memcpy(buffer, fw->data, fw->size);
3190	len = fw->size;
3191
3192	ret  = mxt_check_firmware_format(dev, fw);
3193	if (ret) {
3194		dev_info(dev, "text format, convert it to binary!\n");
3195		len = mxt_convert_text_to_binary(buffer, len);
3196		if (len <= 0)
3197			goto release_firmware;
3198	}
3199
3200
3201	if (data->state != BOOTLOADER) {
3202		/* Change to the bootloader mode */
3203		mxt_reset_toggle(data);
3204
3205		ret = mxt_get_bootloader_address(data);
3206		if (ret)
3207			goto release_firmware;
3208
3209		data->client->addr = data->bootloader_addr;
3210		data->state = BOOTLOADER;
3211	}
3212
3213	ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD);
3214	if (ret) {
3215		mxt_wait_for_chg(data);
3216		/* Bootloader may still be unlocked from previous update
3217		 * attempt */
3218		ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA);
3219		if (ret) {
3220			data->state = FAILED;
3221			goto release_firmware;
3222		}
3223	} else {
3224		dev_info(dev, "Unlocking bootloader\n");
3225
3226		/* Unlock bootloader */
3227		ret = mxt_send_bootloader_cmd(data, true);
3228		if (ret) {
3229			data->state = FAILED;
3230			goto release_firmware;
3231		}
3232	}
3233
3234	while (pos < len) {
3235		mxt_wait_for_chg(data);
3236		ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA);
3237		if (ret) {
3238			data->state = FAILED;
3239			goto release_firmware;
3240		}
3241
3242		frame_size = ((*(buffer + pos) << 8) | *(buffer + pos + 1));
3243
3244		/* Take account of CRC bytes */
3245		frame_size += 2;
3246
3247		/* Write one frame to device */
3248		ret = mxt_bootloader_write(data,buffer + pos, frame_size);
3249		if (ret) {
3250			data->state = FAILED;
3251			goto release_firmware;
3252		}
3253
3254		mxt_wait_for_chg(data);
3255		ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS);
3256
3257		if (ret) {
3258			retry ++;
3259
3260			/* Back off by 20ms per retry */
3261			msleep(retry * 20);
3262
3263			if (retry > 20) {
3264				data->state = FAILED;
3265				goto release_firmware;
3266			}
3267		} else {
3268				retry ++;
3269				pos += frame_size;
3270				frame ++;
3271		}
3272
3273		if (frame % 10 == 0) {
3274			dev_info(dev, "Updated %d frames, %d/%zd bytes\n", frame, pos, len);
3275		}
3276	}
3277
3278	dev_info(dev, "Finished, sent %d frames, %zd bytes\n", frame, pos);
3279
3280	data->state = INIT;
3281
3282release_firmware:
3283	data->client->addr = ori_addr;
3284	release_firmware(fw);
3285	kfree(buffer);
3286	return ret;
3287}
3288
3289static ssize_t mxt_update_firmware(struct device *dev,
3290	struct device_attribute *attr, const char *buf,
3291	size_t count, bool *upgraded)
3292{
3293	struct mxt_data *data = dev_get_drvdata(dev);
3294	int error;
3295	char *fw_name;
3296	int len = 0;
3297
3298	if (upgraded)
3299		*upgraded = false;
3300
3301	if (count <= 0)
3302		return -EINVAL;
3303
3304	len = strnlen(buf, count);
3305	fw_name = kmalloc(len + 1, GFP_KERNEL);
3306	if (fw_name == NULL)
3307		return -ENOMEM;
3308
3309	if (count > 0) {
3310		strncpy(fw_name, buf, len);
3311		if (fw_name[len - 1] == '\n')
3312			fw_name[len - 1] = 0;
3313		else
3314			fw_name[len] = 0;
3315	}
3316
3317	dev_info(dev, "Identify firmware name :%s\n", fw_name);
3318	mxt_disable_irq(data);
3319
3320	error = mxt_load_fw(dev, fw_name);
3321	if (error) {
3322		dev_err(dev, "The firmware update failed(%d)\n", error);
3323		count = error;
3324	} else {
3325		dev_info(dev, "The firmware update succeeded\n");
3326
3327		/* Wait for reset */
3328		msleep(MXT_FWRESET_TIME);
3329
3330		kfree(data->object_table);
3331		data->object_table = NULL;
3332		kfree(data->msg_buf);
3333		data->msg_buf = NULL;
3334
3335		if (upgraded)
3336			*upgraded = true;
3337
3338		mxt_initialize(data);
3339	}
3340
3341	if (data->state == APPMODE) {
3342		mxt_enable_irq(data);
3343	}
3344
3345	kfree(fw_name);
3346	return count;
3347}
3348
3349static ssize_t mxt_update_fw_show(struct device *dev,
3350	struct device_attribute *attr, char *buf)
3351{
3352	struct mxt_data *data = dev_get_drvdata(dev);
3353
3354	ssize_t count = sprintf(buf,
3355			"family_id=0x%02x, variant_id=0x%02x, version=0x%02x, build=0x%02x, vendor=0x%02x\n",
3356			data->info.family_id, data->info.variant_id,
3357			data->info.version, data->info.build,
3358			data->vendor_id);
3359	return count;
3360}
3361
3362static ssize_t mxt_update_fw_store(struct device *dev,
3363					struct device_attribute *attr,
3364					const char *buf, size_t count)
3365{
3366	return mxt_update_firmware(dev, attr, buf, count, NULL);
3367}
3368
3369static ssize_t mxt_keys_off_show(struct device *dev,
3370	struct device_attribute *attr, char *buf)
3371{
3372	struct mxt_data *data = dev_get_drvdata(dev);
3373	int count;
3374	char c;
3375
3376	c = data->keys_off ? '1' : '0';
3377	count = sprintf(buf, "%c\n", c);
3378
3379	return count;
3380}
3381
3382static ssize_t mxt_keys_off_store(struct device *dev,
3383	struct device_attribute *attr, const char *buf, size_t count)
3384{
3385	struct mxt_data *data = dev_get_drvdata(dev);
3386	int i;
3387
3388	if (sscanf(buf, "%u", &i) == 1 && i < 2) {
3389		data->keys_off = (i == 1);
3390
3391		dev_dbg(dev, "%s\n", i ? "hw keys off" : "hw keys on");
3392		return count;
3393	} else {
3394		dev_dbg(dev, "keys_off write error\n");
3395		return -EINVAL;
3396	}
3397}
3398
3399static ssize_t mxt_version_show(struct device *dev,
3400	struct device_attribute *attr, char *buf)
3401{
3402	struct mxt_data *data = dev_get_drvdata(dev);
3403	int count = 0;
3404
3405	count += sprintf(buf + count, "%d", data->info.version);
3406	count += sprintf(buf + count, "\n");
3407
3408	return count;
3409}
3410
3411static ssize_t mxt_build_show(struct device *dev,
3412	struct device_attribute *attr, char *buf)
3413{
3414	struct mxt_data *data = dev_get_drvdata(dev);
3415	int count = 0;
3416
3417	count += sprintf(buf + count, "%d", data->info.build);
3418	count += sprintf(buf + count, "\n");
3419
3420	return count;
3421}
3422
3423static ssize_t mxt_pause_show(struct device *dev,
3424	struct device_attribute *attr, char *buf)
3425{
3426	struct mxt_data *data = dev_get_drvdata(dev);
3427	ssize_t count;
3428	char c;
3429
3430	c = data->driver_paused ? '1' : '0';
3431	count = sprintf(buf, "%c\n", c);
3432
3433	return count;
3434}
3435
3436static ssize_t mxt_pause_store(struct device *dev,
3437	struct device_attribute *attr, const char *buf, size_t count)
3438{
3439	struct mxt_data *data = dev_get_drvdata(dev);
3440	int i;
3441
3442	if (sscanf(buf, "%u", &i) == 1 && i < 2) {
3443		data->driver_paused = (i == 1);
3444		dev_dbg(dev, "%s\n", i ? "paused" : "unpaused");
3445		return count;
3446	} else {
3447		dev_dbg(dev, "pause_driver write error\n");
3448		return -EINVAL;
3449	}
3450}
3451
3452static ssize_t mxt_debug_enable_show(struct device *dev,
3453	struct device_attribute *attr, char *buf)
3454{
3455	struct mxt_data *data = dev_get_drvdata(dev);
3456	int count;
3457	char c;
3458
3459	c = data->debug_enabled ? '1' : '0';
3460	count = sprintf(buf, "%c\n", c);
3461
3462	return count;
3463}
3464
3465static ssize_t mxt_debug_enable_store(struct device *dev,
3466	struct device_attribute *attr, const char *buf, size_t count)
3467{
3468	struct mxt_data *data = dev_get_drvdata(dev);
3469	int i;
3470
3471	if (sscanf(buf, "%u", &i) == 1 && i < 2) {
3472		data->debug_enabled = (i == 1);
3473
3474		dev_dbg(dev, "%s\n", i ? "debug enabled" : "debug disabled");
3475		return count;
3476	} else {
3477		dev_dbg(dev, "debug_enabled write error\n");
3478		return -EINVAL;
3479	}
3480}
3481
3482static int mxt_check_mem_access_params(struct mxt_data *data, loff_t off,
3483				       size_t *count)
3484{
3485	if (data->state != APPMODE) {
3486		dev_err(&data->client->dev, "Not in APPMODE\n");
3487		return -EINVAL;
3488	}
3489
3490	if (off >= data->mem_size)
3491		return -EIO;
3492
3493	if (off + *count > data->mem_size)
3494		*count = data->mem_size - off;
3495
3496	if (*count > MXT_MAX_BLOCK_WRITE)
3497		*count = MXT_MAX_BLOCK_WRITE;
3498
3499	return 0;
3500}
3501
3502static ssize_t mxt_slowscan_show(struct device *dev,
3503	struct device_attribute *attr, char *buf)
3504{
3505	struct mxt_data *data = dev_get_drvdata(dev);
3506	int count = 0;
3507	int error;
3508	u8 actv_cycle_time;
3509	u8 idle_cycle_time;
3510	u8 actv2idle_timeout;
3511	dev_info(dev, "Calling mxt_slowscan_show()\n");
3512
3513	error = mxt_read_object(data, MXT_GEN_POWER_T7,
3514		MXT_POWER_ACTVACQINT,
3515		&actv_cycle_time);
3516
3517	if (error)
3518		return error;
3519
3520	error = mxt_read_object(data, MXT_GEN_POWER_T7,
3521		MXT_POWER_IDLEACQINT,
3522		&idle_cycle_time);
3523
3524	if (error)
3525		return error;
3526
3527	error = mxt_read_object(data, MXT_GEN_POWER_T7,
3528		MXT_POWER_ACTV2IDLETO,
3529		&actv2idle_timeout);
3530
3531	if (error)
3532		return error;
3533
3534	count += sprintf(buf + count,
3535			"SLOW SCAN (enable/disable) = %s.\n",
3536			data->slowscan_enabled ? "enabled" : "disabled");
3537	count += sprintf(buf + count,
3538			"SLOW SCAN (actv_cycle_time) = %umS.\n",
3539			data->slowscan_actv_cycle_time);
3540	count += sprintf(buf + count,
3541			"SLOW SCAN (idle_cycle_time) = %umS.\n",
3542			data->slowscan_idle_cycle_time);
3543	count += sprintf(buf + count,
3544			"SLOW SCAN (actv2idle_timeout) = %u.%0uS.\n",
3545			data->slowscan_actv2idle_timeout / 10,
3546			data->slowscan_actv2idle_timeout % 10);
3547	count += sprintf(buf + count,
3548			"CURRENT   (actv_cycle_time) = %umS.\n",
3549			actv_cycle_time);
3550	count += sprintf(buf + count,
3551			"CURRENT   (idle_cycle_time) = %umS.\n",
3552			idle_cycle_time);
3553	count += sprintf(buf + count,
3554			"CURRENT   (actv2idle_timeout) = %u.%0uS.\n",
3555			actv2idle_timeout / 10, actv2idle_timeout % 10);
3556
3557	return count;
3558}
3559
3560static ssize_t mxt_slowscan_store(struct device *dev,
3561	struct device_attribute *attr, const char *buf, size_t count)
3562{
3563	struct mxt_data *data = dev_get_drvdata(dev);
3564	int fn;
3565	int val;
3566	int ret;
3567
3568	dev_info(dev, "Calling mxt_slowscan_store()\n");
3569	ret = sscanf(buf, "%u %u", &fn, &val);
3570	if ((ret == 1) || (ret == 2)) {
3571		switch (fn) {
3572		case SLOSCAN_DISABLE:
3573			if (data->slowscan_enabled) {
3574				data->actv_cycle_time =
3575					data->slowscan_shad_actv_cycle_time;
3576				data->idle_cycle_time =
3577					data->slowscan_shad_idle_cycle_time;
3578				data->actv2idle_timeout =
3579					data->slowscan_shad_actv2idle_timeout;
3580				data->slowscan_enabled = 0;
3581				mxt_set_power_cfg(data, 0);
3582			}
3583			break;
3584
3585		case SLOSCAN_ENABLE:
3586			if (!data->slowscan_enabled) {
3587				data->slowscan_shad_actv_cycle_time =
3588					data->actv_cycle_time;
3589				data->slowscan_shad_idle_cycle_time =
3590					data->idle_cycle_time;
3591				data->slowscan_shad_actv2idle_timeout =
3592					data->actv2idle_timeout;
3593				data->actv_cycle_time =
3594					data->slowscan_actv_cycle_time;
3595				data->idle_cycle_time =
3596					data->slowscan_idle_cycle_time;
3597				data->actv2idle_timeout =
3598					data->slowscan_actv2idle_timeout;
3599				data->slowscan_enabled = 1;
3600				mxt_set_power_cfg(data, 0);
3601			}
3602			break;
3603
3604		case SLOSCAN_SET_ACTVACQINT:
3605			data->slowscan_actv_cycle_time = val;
3606			break;
3607
3608		case SLOSCAN_SET_IDLEACQINT:
3609			data->slowscan_idle_cycle_time = val;
3610			break;
3611
3612		case SLOSCAN_SET_ACTV2IDLETO:
3613			data->slowscan_actv2idle_timeout = val;
3614			break;
3615		}
3616	}
3617	return count;
3618}
3619
3620static void mxt_self_tune(struct mxt_data *data, u8 save_cmd)
3621{
3622	struct device *dev = &data->client->dev;
3623	int retry_times = 10;
3624	int i = 0;
3625	int error;
3626
3627	while(i++ < retry_times) {
3628		error = mxt_do_self_tune(data, MXT_SELFCMD_TUNE);
3629		if (error) {
3630			dev_err(dev, "Self tune cmd failed!\n");
3631			continue;
3632		}
3633		error = mxt_do_self_tune(data, save_cmd);
3634		if (!error)
3635			return;
3636		else {
3637			dev_err(dev, "Self store cmd failed!\n");
3638			continue;
3639		}
3640	}
3641
3642	dev_err(dev, "Even retry self tuning for 10 times, still can't pass.!\n");
3643}
3644
3645static bool mxt_self_tune_pass(struct mxt_data *data, bool is_hover_mode)
3646{
3647	int error;
3648	struct device *dev = &data->client->dev;
3649	u16 addr = data->T37_address;
3650	u8 mode = MXT_DIAG_SELF_REF;
3651	size_t bufsize = MXT_DIAG_SELF_SIZE;
3652	int read_size = 0;
3653	int i, j = 0;
3654	u8 *buf;
3655	short val;
3656	int bound[] = {32, 68};
3657	int start[] = {40, 80};
3658
3659	buf = kmalloc(MXT_DIAG_TOTAL_SIZE, GFP_KERNEL);
3660	if (buf == NULL) {
3661		dev_err(dev, "Failed to alloc buffer for delta getting!\n");
3662		return false;
3663	}
3664
3665	error = mxt_do_diagnostic(data, mode);
3666	if (error) {
3667		dev_err(dev, "Failed to do diagnostic!\n");
3668		kfree(buf);
3669		return false;
3670	}
3671
3672	if (is_hover_mode) {
3673		error = mxt_do_diagnostic(data, MXT_DIAG_PAGE_UP);
3674		if (error) {
3675			dev_err(dev, "do diagnostic 0x%02x failed\n", MXT_DIAG_PAGE_UP);
3676			kfree(buf);
3677			return false;
3678		}
3679	}
3680
3681	while (read_size < bufsize) {
3682		error = mxt_read_reg(data->client, addr + 2,
3683				MXT_DIAG_PAGE_SIZE, buf + read_size);
3684		if (error) {
3685			dev_err(dev, "Read from T37 failed!\n");
3686			kfree(buf);
3687			return false;
3688		}
3689
3690		read_size += MXT_DIAG_PAGE_SIZE;
3691
3692		error = mxt_do_diagnostic(data, MXT_DIAG_PAGE_UP);
3693		if (error) {
3694			dev_err(dev, "do diagnostic 0x%02x failed!\n", MXT_DIAG_PAGE_UP);
3695			kfree(buf);
3696			return false;
3697		}
3698	}
3699
3700	for (i = 0; i < bufsize; i += 2) {
3701		if (i == bound[j]) {
3702			i = start[j];
3703			j++;
3704		}
3705		val = (buf[i+1] << 8) | buf[i];
3706		pr_info("tune val [%d] = %d\n", i, val);
3707		if (val > 17384 || val < 15384) {
3708			kfree(buf);
3709			return false;
3710		}
3711	}
3712
3713	kfree(buf);
3714	return true;
3715}
3716
3717static void mxt_hover_loading_work(struct work_struct* work)
3718{
3719	struct mxt_data *data = container_of(work, struct mxt_data, hover_loading_work);
3720	int error;
3721
3722	if (data->rev_id == REV_D) {
3723		error = mxt_do_self_tune(data, MXT_SELFCMD_AFN_TUNE);
3724		if (error)
3725			dev_err(&data->client->dev,
3726				"Failed to load hover ref from flash!\n");
3727	}
3728}
3729
3730static void mxt_self_tuning_work(struct work_struct* work)
3731{
3732	struct mxt_data *data = container_of(work, struct mxt_data, self_tuning_work);
3733
3734	if (data->rev_id == REV_D) {
3735		do {
3736			mxt_self_tune(data, MXT_SELFCMD_STCR_TUNE);
3737			if (mxt_self_tune_pass(data, false))
3738				break;
3739		} while (1);
3740	}
3741}
3742
3743static ssize_t mxt_self_tune_store(struct device *dev,
3744	struct device_attribute *attr, const char *buf, size_t count)
3745{
3746	u8 execute_cmd;
3747	struct mxt_data *data = dev_get_drvdata(dev);
3748
3749	if (sscanf(buf, "%hhu", &execute_cmd) == 1)
3750		mxt_self_tune(data, MXT_SELFCMD_STCR_TUNE);
3751	else
3752		return -EINVAL;
3753
3754	return count;
3755}
3756
3757static void mxt_do_calibration(struct mxt_data *data)
3758{
3759	struct device *dev = &data->client->dev;
3760	int error, i;
3761	u8 val;
3762	int time_out = 100;
3763
3764	error = mxt_write_object(data, MXT_GEN_COMMAND_T6,
3765				MXT_COMMAND_CALIBRATE, 1);
3766	if (error) {
3767		dev_err(dev, "failed to do calibration!\n");
3768		return;
3769	}
3770
3771	for (i = 0; i < time_out; i++) {
3772		error = mxt_read_object(data, MXT_GEN_COMMAND_T6,
3773					MXT_COMMAND_CALIBRATE, &val);
3774		if (error) {
3775			dev_err(dev, "failed to read calibration!\n");
3776			return;
3777		}
3778
3779		if (val == 0)
3780			break;
3781		msleep(10);
3782	}
3783}
3784
3785static void mxt_calibration_delayed_work(struct work_struct *work)
3786{
3787	struct delayed_work *delayed_work = to_delayed_work(work);
3788	struct mxt_data *data = container_of(delayed_work, struct mxt_data,
3789						calibration_delayed_work);
3790
3791	mxt_do_calibration(data);
3792}
3793
3794static ssize_t mxt_update_fw_flag_store(struct device *dev,
3795	struct device_attribute *attr, const char *buf, size_t count)
3796{
3797	struct mxt_data *data = dev_get_drvdata(dev);
3798	int ret = 0;
3799	int i;
3800
3801	if (sscanf(buf, "%u", &i) == 1)  {
3802		dev_dbg(dev, "write fw update flag %d to t38\n", i);
3803		ret = mxt_write_object(data, MXT_SPT_USERDATA_T38,
3804					MXT_FW_UPDATE_FLAG, (u8)i);
3805		if (ret < 0)
3806			return ret;
3807		ret = mxt_backup_nv(data);
3808		if (ret)
3809			return ret;
3810	}
3811
3812	return count;
3813}
3814
3815static ssize_t mxt_selftest_show(struct device *dev,
3816	struct device_attribute *attr, char *buf)
3817{
3818	struct mxt_data *data = dev_get_drvdata(dev);
3819	return sprintf(buf, "%02x, %02x, %02x, %02x, %02x, %02x\n",
3820			data->test_result[0], data->test_result[1],
3821			data->test_result[2], data->test_result[3],
3822			data->test_result[4], data->test_result[5]);
3823}
3824
3825static ssize_t mxt_selftest_store(struct device *dev,
3826	struct device_attribute *attr, const char *buf, size_t count)
3827{
3828	struct mxt_data *data = dev_get_drvdata(dev);
3829	int error;
3830	u8 selftest_cmd;
3831
3832	/* run all selftest */
3833	error = mxt_write_object(data,
3834			MXT_SPT_SELFTEST_T25,
3835			0x01, 0xfe);
3836	if (!error) {
3837		while (true) {
3838			msleep(10);
3839			error = mxt_read_object(data,
3840					MXT_SPT_SELFTEST_T25,
3841					0x01, &selftest_cmd);
3842			if (error || selftest_cmd == 0)
3843				break;
3844		}
3845	}
3846
3847	return error ? : count;
3848}
3849
3850static int mxt_stylus_mode_switch(struct mxt_data *data, bool mode_on)
3851{
3852	struct device *dev = &data->client->dev;
3853	const struct mxt_platform_data *pdata = data->pdata;
3854	int error;
3855	u8 ctrl;
3856	u8 mult_intthr;
3857	u8 mult_tchthr;
3858	int index = data->current_index;
3859
3860	error = mxt_read_object(data, MXT_PROCI_STYLUS_T47,
3861					MXT_PSTYLUS_CTRL, &ctrl);
3862	if (error) {
3863		dev_err(dev, "Failed to read from T47!\n");
3864		return error;
3865	}
3866
3867	if (mode_on) {
3868		ctrl |= MXT_PSTYLUS_ENABLE;
3869		mult_intthr = pdata->config_array[index].mult_intthr_sensitive;
3870		mult_tchthr = pdata->config_array[index].mult_tchthr_sensitive;
3871	}
3872	else {
3873		ctrl &= ~(MXT_PSTYLUS_ENABLE);
3874		if (!data->sensitive_mode) {
3875			mult_intthr = pdata->config_array[index].mult_intthr_not_sensitive;
3876			mult_tchthr = pdata->config_array[index].mult_tchthr_not_sensitive;
3877		}
3878		else {
3879			mult_intthr = pdata->config_array[index].mult_intthr_sensitive;
3880			mult_tchthr = pdata->config_array[index].mult_tchthr_sensitive;
3881		}
3882	}
3883
3884	error = mxt_write_object(data, MXT_PROCI_STYLUS_T47,
3885			MXT_PSTYLUS_CTRL, ctrl);
3886	if (error) {
3887		dev_err(dev, "Failed to read from t47!\n");
3888		return error;
3889	}
3890
3891	error = mxt_write_object(data, MXT_TOUCH_MULTI_T100,
3892					MXT_MULTITOUCH_INTTHR, mult_intthr);
3893	if (error) {
3894		dev_err(dev, "Failed in writing t100 intthr!\n");
3895		return error;
3896	}
3897
3898	if (mult_tchthr != 0) {
3899		error = mxt_write_object(data, MXT_TOUCH_MULTI_T100,
3900						MXT_MULTITOUCH_TCHTHR, mult_tchthr);
3901		if (error) {
3902			dev_err(dev, "Failed in writing t100 tchthr!\n");
3903			return error;
3904		}
3905
3906		error = mxt_write_object(data, MXT_SPT_DYMDATA_T71,
3907						pdata->config_array[index].t71_tchthr_pos, mult_tchthr);
3908		if (error) {
3909			dev_err(dev, "Failed in writing t71 tchthr!\n");
3910			return error;
3911		}
3912	}
3913
3914	data->stylus_mode = (u8)mode_on;
3915	return 0;
3916}
3917
3918static ssize_t mxt_stylus_show(struct device *dev,
3919	struct device_attribute *attr, char *buf)
3920{
3921	struct mxt_data *data = dev_get_drvdata(dev);
3922	int count;
3923
3924	count = sprintf(buf, "%d\n", (int)data->stylus_mode);
3925
3926	return count;
3927}
3928
3929static ssize_t mxt_stylus_store(struct device *dev,
3930	struct device_attribute *attr, const char *buf, size_t count)
3931{
3932	struct mxt_data *data = dev_get_drvdata(dev);
3933	int error, i;
3934
3935	if (sscanf(buf, "%u", &i) == 1)  {
3936		if (i == 1) {
3937			error = mxt_stylus_mode_switch(data, true);
3938			if (error) {
3939				dev_err(dev, "Failed to enable stylus mode!\n");
3940				return error;
3941			}
3942		}
3943		else if (i == 0) {
3944			error = mxt_stylus_mode_switch(data, false);
3945			if (error) {
3946				dev_err(dev, "Failed to disable stylus mode!\n");
3947				return error;
3948			}
3949		}
3950		else
3951			return -EINVAL;
3952
3953	}
3954
3955	return count;
3956}
3957
3958static int mxt_get_diag_data(struct mxt_data *data, char *buf)
3959{
3960	struct device *dev = &data->client->dev;
3961	int error;
3962	int read_size = 0;
3963	u16 addr = data->T37_address;
3964
3965	error = mxt_do_diagnostic(data, data->diag_mode);
3966	if (error) {
3967		dev_err(dev, "do diagnostic 0x%02x failed!\n", data->diag_mode);
3968		return error;
3969	}
3970
3971	while (read_size < MXT_DIAG_TOTAL_SIZE) {
3972		error = mxt_read_reg(data->client, addr + 2,
3973					MXT_DIAG_PAGE_SIZE, buf + read_size);
3974		if (error) {
3975			dev_err(dev, "Read from T37 failed!\n");
3976			return error;
3977		}
3978
3979		read_size += MXT_DIAG_PAGE_SIZE;
3980
3981		error = mxt_do_diagnostic(data, MXT_DIAG_PAGE_UP);
3982		if (error) {
3983			dev_err(dev, "do diagnostic 0x%02x failed!\n", MXT_DIAG_PAGE_UP);
3984			return error;
3985		}
3986	}
3987
3988	if (data->debug_enabled)
3989		print_hex_dump(KERN_DEBUG, "Data: ", DUMP_PREFIX_NONE, 16, 1,
3990				       buf, MXT_DIAG_TOTAL_SIZE, false);
3991
3992	return 0;
3993}
3994
3995static ssize_t mxt_diagnostic_show(struct device *dev,
3996	struct device_attribute *attr, char *buf)
3997{
3998	struct mxt_data *data = dev_get_drvdata(dev);
3999	int error;
4000	int i = 0;
4001	int len = 0;
4002	int remain_size, transfer_size;
4003	int row_size = 16;
4004	int group_size = 1;
4005	char *tmp_buffer = kmalloc(MXT_DIAG_TOTAL_SIZE, GFP_KERNEL);
4006	if (tmp_buffer == NULL)
4007		return -ENOMEM;
4008
4009	error = mxt_get_diag_data(data, tmp_buffer);
4010	if (error) {
4011		kfree(tmp_buffer);
4012		return error;
4013	}
4014
4015	remain_size = MXT_DIAG_TOTAL_SIZE % row_size;
4016	transfer_size = MXT_DIAG_TOTAL_SIZE - remain_size;
4017	while (i  < transfer_size) {
4018		hex_dump_to_buffer(tmp_buffer + i, row_size, row_size, group_size,
4019					buf + len, PAGE_SIZE - len, false);
4020		i += row_size;
4021		len = strlen(buf);
4022		buf[len] = '\n';
4023		len ++;
4024	}
4025
4026	if (remain_size != 0)
4027		hex_dump_to_buffer(tmp_buffer + i, remain_size, row_size, group_size,
4028					buf + len, PAGE_SIZE - len, false);
4029
4030	kfree(tmp_buffer);
4031	return strlen(buf);
4032}
4033
4034static ssize_t mxt_diagnostic_store(struct device *dev,
4035	struct device_attribute *attr, const char *buf, size_t count)
4036{
4037	struct mxt_data *data = dev_get_drvdata(dev);
4038	int i;
4039	u8 mode;
4040
4041	if (sscanf(buf, "%u", &i) == 1)  {
4042		mode = (u8)i;
4043		dev_info(dev, "Diag mode = 0x%02x\n", mode);
4044		data->diag_mode = mode;
4045	}
4046
4047	return count;
4048}
4049
4050static int mxt_sensitive_mode_switch(struct mxt_data *data, bool mode_on)
4051{
4052	int error;
4053	struct device *dev = &data->client->dev;
4054	const struct mxt_platform_data *pdata = data->pdata;
4055	int index = data->current_index;
4056	u8 key_ctrl;
4057	u8 mult_intthr;
4058	u8 atchthr;
4059	u8 mult_tchthr;
4060
4061	error = mxt_read_object(data, MXT_TOUCH_KEYARRAY_T15,
4062					MXT_KEYARRAY_CTRL, &key_ctrl);
4063	if (error) {
4064		dev_err(dev, "Failed to read from T15 ctrl!\n");
4065		return error;
4066	}
4067
4068	if (mode_on) {
4069		error = mxt_write_object(data, MXT_PROCI_GLOVEDETECTION_T78,
4070						MXT_GLOVE_CTRL, MXT_GLOVECTL_ALL_ENABLE);
4071		if (error)
4072			return error;
4073
4074		key_ctrl |= MXT_KEY_ADAPTTHREN;
4075		mult_intthr = pdata->config_array[index].mult_intthr_sensitive;
4076		mult_tchthr = pdata->config_array[index].mult_tchthr_sensitive;
4077		atchthr = pdata->config_array[index].atchthr_sensitive;
4078	} else {
4079		error = mxt_write_object(data, MXT_PROCI_GLOVEDETECTION_T78,
4080						MXT_GLOVE_CTRL, 0x0);
4081		if (error)
4082			return error;
4083
4084		key_ctrl &= (~MXT_KEY_ADAPTTHREN);
4085		if (!data->stylus_mode) {
4086			mult_intthr = pdata->config_array[index].mult_intthr_not_sensitive;
4087			mult_tchthr = pdata->config_array[index].mult_tchthr_not_sensitive;
4088		}
4089		else {
4090			mult_intthr = pdata->config_array[index].mult_intthr_sensitive;
4091			mult_tchthr = pdata->config_array[index].mult_tchthr_sensitive;
4092		}
4093		atchthr = data->atchthr;
4094	}
4095
4096	error = mxt_write_object(data, MXT_PROCI_RETRANSMISSIONCOMPENSATION_T80,
4097					MXT_RETRANS_ATCHTHR, atchthr);
4098	if (error) {
4099		dev_err(dev, "Failed in writing t80 atchthr!\n");
4100		return error;
4101	}
4102
4103	error = mxt_write_object(data, MXT_TOUCH_MULTI_T100,
4104					MXT_MULTITOUCH_INTTHR, mult_intthr);
4105	if (error) {
4106		dev_err(dev, "Failed in writing t100 intthr!\n");
4107		return error;
4108	}
4109	if (mult_tchthr != 0) {
4110		error = mxt_write_object(data, MXT_TOUCH_MULTI_T100,
4111						MXT_MULTITOUCH_TCHTHR, mult_tchthr);
4112		if (error) {
4113			dev_err(dev, "Failed in writing t100 tchthr!\n");
4114			return error;
4115		}
4116
4117		error = mxt_write_object(data, MXT_SPT_DYMDATA_T71,
4118						pdata->config_array[index].t71_tchthr_pos, mult_tchthr);
4119		if (error) {
4120			dev_err(dev, "Failed in writing t71 tchthr!\n");
4121			return error;
4122		}
4123	}
4124
4125	error = mxt_write_object(data, MXT_TOUCH_KEYARRAY_T15,
4126					MXT_KEYARRAY_CTRL, key_ctrl);
4127	if (error) {
4128		dev_err(dev, "Failed in writing t15 key ctrl!\n");
4129		return error;
4130	}
4131
4132	data->sensitive_mode = (u8)mode_on;
4133
4134	return error;
4135}
4136
4137static ssize_t mxt_wakeup_mode_show(struct device *dev,
4138	struct device_attribute *attr, char *buf)
4139{
4140	struct mxt_data *data = dev_get_drvdata(dev);
4141	int count;
4142
4143	count = sprintf(buf, "%d\n", (int)data->wakeup_gesture_mode);
4144
4145	return count;
4146}
4147
4148static void mxt_enable_gesture_mode(struct mxt_data *data)
4149{
4150	if (!data->hw_wakeup){
4151		return;
4152	}
4153	u8 t81_val;
4154	int error;
4155
4156	if (data->wakeup_gesture_mode)
4157		t81_val = 7;
4158	else
4159		t81_val = 0;
4160
4161	error = mxt_write_object(data, MXT_TOUCH_MORE_GESTURE_T81,
4162				MXT_GESTURE_CTRL, t81_val);
4163	if (error)
4164		dev_info(&data->client->dev, "write to t81 enabled failed!\n");
4165}
4166
4167static ssize_t  mxt_wakeup_mode_store(struct device *dev,
4168				struct device_attribute *attr,
4169				const char *buf, size_t count)
4170{
4171	struct mxt_data *data = dev_get_drvdata(dev);
4172	const struct mxt_platform_data *pdata = data->pdata;
4173	int index = data->current_index;
4174	unsigned long val;
4175	int error;
4176
4177	if (pdata->config_array[index].wake_up_self_adcx == 0)
4178		return count;
4179
4180	error = strict_strtoul(buf, 0, &val);
4181
4182	if (!error) {
4183		data->wakeup_gesture_mode = (u8)val;
4184		data->hw_wakeup = true;
4185	}
4186
4187	mxt_enable_gesture_mode(data);
4188
4189	return error ? : count;
4190}
4191
4192static ssize_t mxt_sensitive_mode_show(struct device *dev,
4193	struct device_attribute *attr, char *buf)
4194{
4195	struct mxt_data *data = dev_get_drvdata(dev);
4196	int count;
4197
4198	count = sprintf(buf, "%d\n", (int)data->sensitive_mode);
4199
4200	return count;
4201}
4202
4203static ssize_t  mxt_sensitive_mode_store(struct device *dev,
4204				struct device_attribute *attr,
4205				const char *buf, size_t count)
4206{
4207	struct mxt_data *data = dev_get_drvdata(dev);
4208	unsigned long val;
4209	int error;
4210
4211	error = strict_strtoul(buf, 0, &val);
4212	if (!error) {
4213		if (val == 1) {
4214			error = mxt_sensitive_mode_switch(data, true);
4215			if (error)
4216				dev_err(dev, "Failed to open sensitive mode!\n");
4217		} else if (val == 0) {
4218			error = mxt_sensitive_mode_switch(data, false);
4219			if (error)
4220				dev_err(dev, "Failed to close sensitive mode!\n");
4221		}
4222	}
4223
4224	return error ? : count;
4225}
4226
4227
4228static void mxt_control_hover(struct mxt_data *data, bool enable)
4229{
4230	int error;
4231	u8 t8_val, t101_val;
4232	struct device *dev = &data->client->dev;
4233
4234	if (enable) {
4235		t8_val = 0x0F;
4236		t101_val = 0x01;
4237	} else {
4238		t8_val = 0x0B;
4239		t101_val = 0x00;
4240	}
4241
4242	error = mxt_write_object(data, MXT_GEN_ACQUIRE_T8,
4243			MXT_ACQUIRE_MEASALLOW, t8_val);
4244	if (error) {
4245		dev_err(dev, "Failed to set t8 value!\n");
4246		return;
4247	}
4248
4249	error = mxt_write_object(data, MXT_SPT_TOUCHSCREENHOVER_T101,
4250			MXT_HOVER_CTRL, t101_val);
4251	if (error)
4252		dev_err(dev, "Failed to set t101 value!\n");
4253}
4254
4255static ssize_t mxt_hover_tune_show(struct device *dev,
4256			struct device_attribute *attr, char *buf)
4257{
4258	struct mxt_data *data = dev_get_drvdata(dev);
4259	int count;
4260
4261	count = sprintf(buf, "%d\n", (int)data->hover_tune_status);
4262
4263	return count;
4264}
4265
4266static ssize_t mxt_hover_tune_store(struct device *dev,
4267				struct device_attribute *attr,
4268				const char *buf, size_t count)
4269{
4270	struct mxt_data *data = dev_get_drvdata(dev);
4271	unsigned long val;
4272	int error;
4273
4274	error = strict_strtoul(buf, 0, &val);
4275	if (!error) {
4276		if (val == 1 && data->rev_id == REV_D) {
4277			mxt_control_hover(data, true);
4278			mxt_self_tune(data, MXT_SELFCMD_STM_TUNE);
4279			if (mxt_self_tune_pass(data, true))
4280				data->hover_tune_status = 1;
4281			else
4282				data->hover_tune_status = 0;
4283			mxt_control_hover(data, false);
4284		}
4285	}
4286
4287	return error ? : count;
4288}
4289
4290static ssize_t mxt_hover_from_flash_store(struct device *dev,
4291				struct device_attribute *attr,
4292				const char *buf, size_t count)
4293{
4294	struct mxt_data *data = dev_get_drvdata(dev);
4295	unsigned long val;
4296	int error;
4297
4298	error = strict_strtoul(buf, 0, &val);
4299	if (!error && val == 0)
4300		schedule_work(&data->self_tuning_work);
4301
4302	return error ? : count;
4303}
4304
4305static ssize_t mxt_panel_color_show(struct device *dev,
4306			struct device_attribute *attr, char *buf)
4307{
4308	struct mxt_data *data = dev_get_drvdata(dev);
4309	int count;
4310
4311	if (get_hw_version_major() >= 5) {
4312		/* Panel color only supported in X5.
4313		 * Color info is stored in lockdown info byte2 */
4314		count = snprintf(buf, PAGE_SIZE, "%c\n",
4315				data->lockdown_info[2]);
4316	} else {
4317		count = snprintf(buf, PAGE_SIZE, "%s\n",
4318				"Unknown");
4319	}
4320
4321	return count;
4322}
4323
4324static int mxt_chip_reset(struct mxt_data *data)
4325{
4326	int error;
4327
4328	mxt_disable_irq(data);
4329	if (get_hw_version_major() <= 4) {
4330		/* Keep same behaviour in X4 */
4331		gpio_set_value(data->pdata->power_gpio, 0);
4332		msleep(20);
4333		gpio_set_value(data->pdata->power_gpio, 1);
4334	} else {
4335		/* In X5, power is controlled by both LCD an TP, so just toggle the reset pin */
4336		if (data->pdata->cut_off_power)
4337			gpio_direction_output(data->pdata->reset_gpio, 1);
4338
4339		gpio_set_value(data->pdata->reset_gpio, 0);
4340		msleep(20);
4341		gpio_set_value(data->pdata->reset_gpio, 1);
4342
4343		if (data->pdata->cut_off_power)
4344			gpio_direction_input(data->pdata->reset_gpio);
4345	}
4346	msleep(10);
4347	mxt_wait_for_chg(data);
4348	mxt_enable_irq(data);
4349	error = mxt_soft_reset(data, MXT_RESET_VALUE);
4350	if (error)
4351		return error;
4352
4353	error = mxt_initialize(data);
4354
4355	schedule_work(&data->hover_loading_work);
4356
4357	return error;
4358}
4359
4360static ssize_t mxt_chip_reset_store(struct device *dev,
4361				struct device_attribute *attr,
4362				const char *buf, size_t count)
4363{
4364	int error;
4365	struct mxt_data *data = dev_get_drvdata(dev);
4366
4367	error = mxt_chip_reset(data);
4368	if (error)
4369		return error;
4370	else
4371		return count;
4372}
4373
4374static ssize_t mxt_chg_state_show(struct device *dev,
4375	struct device_attribute *attr, char *buf)
4376{
4377	struct mxt_data *data = dev_get_drvdata(dev);
4378	int count;
4379	int chg_state;
4380
4381	chg_state = gpio_get_value(data->pdata->irq_gpio);
4382	count = sprintf(buf, "%d\n", chg_state);
4383
4384	return count;
4385}
4386
4387static void mxt_switch_mode_work(struct work_struct *work)
4388{
4389	struct mxt_mode_switch *ms = container_of(work, struct mxt_mode_switch, switch_mode_work);
4390	struct mxt_data *data = ms->data;
4391	const struct mxt_platform_data *pdata = data->pdata;
4392	int index = data->current_index;
4393	u8 value = ms->mode;
4394
4395	if (value == MXT_INPUT_EVENT_SENSITIVE_MODE_ON ||
4396				value == MXT_INPUT_EVENT_SENSITIVE_MODE_OFF)
4397		mxt_sensitive_mode_switch(data, (bool)(value - MXT_INPUT_EVENT_SENSITIVE_MODE_OFF));
4398	else if (value == MXT_INPUT_EVENT_STYLUS_MODE_ON ||
4399				value == MXT_INPUT_EVENT_STYLUS_MODE_OFF)
4400		mxt_stylus_mode_switch(data, (bool)(value - MXT_INPUT_EVENT_STYLUS_MODE_OFF));
4401
4402	if (ms != NULL) {
4403		kfree(ms);
4404		ms = NULL;
4405	}
4406}
4407
4408static int mxt_input_event(struct input_dev *dev,
4409		unsigned int type, unsigned int code, int value)
4410{
4411	struct mxt_data *data = input_get_drvdata(dev);
4412	char buffer[16];
4413	struct mxt_mode_switch *ms;
4414
4415	if (type == EV_SYN && code == SYN_CONFIG) {
4416		if (data->debug_enabled) {
4417			dev_info(&data->client->dev,
4418				"event write value = %d \n", value);
4419		}
4420		sprintf(buffer, "%d", value);
4421
4422		if (value >= MXT_INPUT_EVENT_START && value <= MXT_INPUT_EVENT_END) {
4423			ms = (struct mxt_mode_switch*)kmalloc(sizeof(struct mxt_mode_switch), GFP_ATOMIC);
4424			if (ms != NULL) {
4425				ms->data = data;
4426				ms->mode = (u8)value;
4427				INIT_WORK(&ms->switch_mode_work, mxt_switch_mode_work);
4428				schedule_work(&ms->switch_mode_work);
4429			} else {
4430				dev_err(&data->client->dev,
4431					"Failed in allocating memory for mxt_mode_switch!\n");
4432				return -ENOMEM;
4433			}
4434		}
4435	}
4436
4437	return 0;
4438}
4439
4440static ssize_t mxt_mem_access_read(struct file *filp, struct kobject *kobj,
4441	struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
4442{
4443	struct device *dev = container_of(kobj, struct device, kobj);
4444	struct mxt_data *data = dev_get_drvdata(dev);
4445	int ret = 0;
4446
4447	ret = mxt_check_mem_access_params(data, off, &count);
4448	if (ret < 0)
4449		return ret;
4450
4451	if (count > 0)
4452		ret = mxt_read_reg(data->client, off, count, buf);
4453
4454	return ret == 0 ? count : ret;
4455}
4456
4457static ssize_t mxt_mem_access_write(struct file *filp, struct kobject *kobj,
4458	struct bin_attribute *bin_attr, char *buf, loff_t off,
4459	size_t count)
4460{
4461	struct device *dev = container_of(kobj, struct device, kobj);
4462	struct mxt_data *data = dev_get_drvdata(dev);
4463	int ret = 0;
4464
4465	ret = mxt_check_mem_access_params(data, off, &count);
4466	if (ret < 0)
4467		return ret;
4468
4469	if (count > 0)
4470		ret = mxt_write_block(data->client, off, count, buf);
4471
4472	return ret == 0 ? count : 0;
4473}
4474
4475static DEVICE_ATTR(update_fw, S_IWUSR | S_IRUSR, mxt_update_fw_show, mxt_update_fw_store);
4476static DEVICE_ATTR(debug_enable, S_IWUSR | S_IRUSR, mxt_debug_enable_show,
4477			mxt_debug_enable_store);
4478static DEVICE_ATTR(keys_off, S_IWUSR | S_IRUSR, mxt_keys_off_show,
4479			mxt_keys_off_store);
4480static DEVICE_ATTR(pause_driver, S_IWUSR | S_IRUSR, mxt_pause_show,
4481			mxt_pause_store);
4482static DEVICE_ATTR(version, S_IRUGO, mxt_version_show, NULL);
4483static DEVICE_ATTR(build, S_IRUGO, mxt_build_show, NULL);
4484static DEVICE_ATTR(slowscan_enable, S_IWUSR | S_IRUSR,
4485			mxt_slowscan_show, mxt_slowscan_store);
4486static DEVICE_ATTR(self_tune, S_IWUSR, NULL, mxt_self_tune_store);
4487static DEVICE_ATTR(update_fw_flag, S_IWUSR, NULL, mxt_update_fw_flag_store);
4488static DEVICE_ATTR(selftest,  S_IWUSR | S_IRUSR, mxt_selftest_show, mxt_selftest_store);
4489static DEVICE_ATTR(stylus, S_IWUSR | S_IRUSR, mxt_stylus_show, mxt_stylus_store);
4490static DEVICE_ATTR(diagnostic, S_IWUSR | S_IRUSR, mxt_diagnostic_show, mxt_diagnostic_store);
4491static DEVICE_ATTR(sensitive_mode, S_IWUSR | S_IRUSR, mxt_sensitive_mode_show, mxt_sensitive_mode_store);
4492static DEVICE_ATTR(chip_reset, S_IWUSR, NULL, mxt_chip_reset_store);
4493static DEVICE_ATTR(chg_state, S_IRUGO, mxt_chg_state_show, NULL);
4494static DEVICE_ATTR(wakeup_mode, S_IWUSR | S_IRUSR, mxt_wakeup_mode_show, mxt_wakeup_mode_store);
4495static DEVICE_ATTR(hover_tune, S_IWUSR | S_IRUSR, mxt_hover_tune_show, mxt_hover_tune_store);
4496static DEVICE_ATTR(hover_from_flash, S_IWUSR, NULL, mxt_hover_from_flash_store);
4497static DEVICE_ATTR(panel_color, S_IRUSR, mxt_panel_color_show, NULL);
4498
4499static struct attribute *mxt_attrs[] = {
4500	&dev_attr_update_fw.attr,
4501	&dev_attr_debug_enable.attr,
4502	&dev_attr_pause_driver.attr,
4503	&dev_attr_version.attr,
4504	&dev_attr_keys_off.attr,
4505	&dev_attr_build.attr,
4506	&dev_attr_slowscan_enable.attr,
4507	&dev_attr_self_tune.attr,
4508	&dev_attr_update_fw_flag.attr,
4509	&dev_attr_selftest.attr,
4510	&dev_attr_stylus.attr,
4511	&dev_attr_diagnostic.attr,
4512	&dev_attr_sensitive_mode.attr,
4513	&dev_attr_chip_reset.attr,
4514	&dev_attr_chg_state.attr,
4515	&dev_attr_wakeup_mode.attr,
4516	&dev_attr_hover_tune.attr,
4517	&dev_attr_hover_from_flash.attr,
4518	&dev_attr_panel_color.attr,
4519	NULL
4520};
4521
4522static const struct attribute_group mxt_attr_group = {
4523	.attrs = mxt_attrs,
4524};
4525
4526static void mxt_set_t7_for_gesture(struct mxt_data *data, bool enable)
4527{
4528	if (!data->hw_wakeup) {
4529		return;
4530	}
4531	int error, i;
4532	u8 t7_gesture_enable[] = {
4533		135, 35, 20
4534	};
4535	u8 t7_gesture_disable[] = {
4536		32, 9, 20
4537	};
4538	u8 *t7_val;
4539
4540	if (enable)
4541		t7_val = t7_gesture_enable;
4542	else
4543		t7_val = t7_gesture_disable;
4544
4545	for (i = 0; i < sizeof(t7_gesture_enable); i++) {
4546		error = mxt_write_object(data, MXT_GEN_POWER_T7,
4547				i, t7_val[i]);
4548		if (error) {
4549			pr_info("write to t7 byte %d failed!\n", i);
4550			return;
4551		}
4552	}
4553}
4554
4555static void mxt_set_gesture_wake_up(struct mxt_data *data, bool enable)
4556{
4557	if (!data->hw_wakeup)
4558		return;
4559	int error, i;
4560	struct device *dev = &data->client->dev;
4561	u8 *t108_val;
4562
4563	if (enable)
4564		t108_val = data->adcperx_wakeup;
4565	else
4566		t108_val = data->adcperx_normal;
4567
4568	for (i = 0; i < sizeof(data->adcperx_normal); i++) {
4569		error = mxt_write_object(data, MXT_PROCG_NOISESUPSELFCAP_T108,
4570				i + 19, t108_val[i]);
4571		if (error) {
4572			dev_err(dev, "write to t108 byte %d failed!\n", i);
4573			return;
4574		}
4575	}
4576
4577	if (enable) {
4578		error = mxt_set_clr_reg(data, MXT_PROCG_NOISESUPPRESSION_T72,
4579					MXT_NOISESUP_CTRL, 0, MXT_NOICTRL_ENABLE);
4580	} else {
4581		error = mxt_set_clr_reg(data, MXT_PROCG_NOISESUPPRESSION_T72,
4582					MXT_NOISESUP_CTRL, MXT_NOICTRL_ENABLE, 0);
4583	}
4584
4585	if (error) {
4586		dev_err(dev, "write to t72 failed!\n");
4587		return;
4588	}
4589
4590	if (enable) {
4591		error = mxt_set_clr_reg(data, MXT_TOUCH_MULTI_T100,
4592				MXT_MULTITOUCH_CTRL, 0, MXT_T100_CTRL_RPTEN);
4593	} else {
4594		error = mxt_set_clr_reg(data, MXT_TOUCH_MULTI_T100,
4595				MXT_MULTITOUCH_CTRL, MXT_T100_CTRL_RPTEN, 0);
4596	}
4597
4598	if (error) {
4599		dev_err(dev, "write to t100 failed!\n");
4600		return;
4601	}
4602
4603	if (enable) {
4604		error = mxt_set_clr_reg(data, MXT_TOUCH_KEYARRAY_T15,
4605				MXT_KEYARRAY_CTRL, 0, MXT_KEY_RPTEN);
4606	} else {
4607		error = mxt_set_clr_reg(data, MXT_TOUCH_KEYARRAY_T15,
4608				MXT_KEYARRAY_CTRL, MXT_KEY_RPTEN, 0);
4609	}
4610
4611	if (error)
4612		dev_err(dev, "write to t15 failed!\n");
4613}
4614
4615static void mxt_start(struct mxt_data *data)
4616{
4617	int error;
4618	struct device *dev = &data->client->dev;
4619
4620	if (mxt_prevent_sleep() && data->is_stopped!=1) {
4621		mxt_set_gesture_wake_up(data, false);
4622		if (!data->is_wakeup_by_gesture)
4623			mxt_set_t7_for_gesture(data, false);
4624		data->is_stopped = 0;
4625		return;
4626	} else {
4627		if (data->is_stopped == 0)
4628			return;
4629
4630		error = mxt_set_power_cfg(data, MXT_POWER_CFG_RUN);
4631		if (error)
4632			return;
4633		/* At this point, it may be necessary to clear state
4634		 * by disabling/re-enabling the noise suppression object */
4635
4636		/* Recalibrate since chip has been in deep sleep */
4637		schedule_delayed_work(&data->calibration_delayed_work, msecs_to_jiffies(100));
4638	}
4639
4640	dev_dbg(dev, "MXT started\n");
4641}
4642
4643static void mxt_stop(struct mxt_data *data)
4644{
4645	int error;
4646	struct device *dev = &data->client->dev;
4647
4648	if (mxt_prevent_sleep()) {
4649		data->is_wakeup_by_gesture = false;
4650		mxt_set_t7_for_gesture(data, true);
4651		mxt_set_gesture_wake_up(data, true);
4652		data->is_stopped = 1;
4653	} else {
4654		if (data->is_stopped)
4655			return;
4656
4657		cancel_delayed_work_sync(&data->calibration_delayed_work);
4658		error = mxt_set_power_cfg(data, MXT_POWER_CFG_DEEPSLEEP);
4659
4660		if (!error)
4661			dev_dbg(dev, "MXT suspended\n");
4662	}
4663}
4664
4665static int mxt_input_open(struct input_dev *dev)
4666{
4667	struct mxt_data *data = input_get_drvdata(dev);
4668
4669	mxt_start(data);
4670
4671	return 0;
4672}
4673
4674static void mxt_input_close(struct input_dev *dev)
4675{
4676	struct mxt_data *data = input_get_drvdata(dev);
4677
4678	mxt_stop(data);
4679}
4680
4681static void mxt_clear_touch_event(struct mxt_data *data)
4682{
4683	struct input_dev *input_dev = data->input_dev;
4684	int index = data->current_index;
4685	int id, i;
4686
4687	for (id = 0; id < data->num_touchids - 2; id++) {
4688		input_mt_slot(input_dev, id);
4689		input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, false);
4690		data->finger_down[id] = false;
4691	}
4692	for (i = 0; i < data->pdata->config_array[index].key_num; i++)
4693		clear_bit(data->pdata->config_array[index].key_codes[i], input_dev->key);
4694
4695	input_sync(input_dev);
4696}
4697
4698static int mxt_suspend(struct device *dev)
4699{
4700	int ret;
4701	struct i2c_client *client = to_i2c_client(dev);
4702	struct mxt_data *data = i2c_get_clientdata(client);
4703	struct input_dev *input_dev = data->input_dev;
4704
4705	if (data->pdata->cut_off_power) {
4706		/* In the power is cut off with LCD off, wake up gesture can not be used */
4707		mutex_lock(&input_dev->mutex);
4708
4709		if (data->is_stopped) {
4710			mutex_unlock(&input_dev->mutex);
4711			return 0;
4712		}
4713
4714		mxt_disable_irq(data);
4715		gpio_set_value(data->pdata->reset_gpio, 0);
4716
4717		mxt_clear_touch_event(data);
4718
4719		if (data->regulator_vdd && data->regulator_avdd && data->regulator_vddio) {
4720			ret = regulator_disable(data->regulator_avdd);
4721			if (ret < 0) {
4722				dev_err(dev,
4723				"Atmel regulator disable for avdd failed: %d\n", ret);
4724			}
4725			ret = regulator_disable(data->regulator_vdd);
4726			if (ret < 0) {
4727				dev_err(dev,
4728				"Atmel regulator disable for vdd failed: %d\n", ret);
4729			}
4730
4731			ret = regulator_disable(data->regulator_vddio);
4732			if (ret < 0) {
4733				dev_err(dev,
4734				"Atmel regulator disable for vddio failed: %d\n", ret);
4735			}
4736		}
4737
4738		data->is_stopped = 1;
4739
4740		mutex_unlock(&input_dev->mutex);
4741	} else {
4742		if (!mxt_prevent_sleep())
4743			mxt_disable_irq(data);
4744
4745		mutex_lock(&input_dev->mutex);
4746
4747		if (input_dev->users)
4748			mxt_stop(data);
4749
4750		mutex_unlock(&input_dev->mutex);
4751
4752		mxt_clear_touch_event(data);
4753
4754		if (data->regulator_vdd && data->regulator_avdd && data->regulator_vddio) {
4755			ret = regulator_disable(data->regulator_avdd);
4756			if (ret < 0) {
4757				dev_err(dev,
4758				"Atmel regulator disable for avdd failed: %d\n", ret);
4759			}
4760			ret = regulator_disable(data->regulator_vdd);
4761			if (ret < 0) {
4762				dev_err(dev,
4763				"Atmel regulator disable for vdd failed: %d\n", ret);
4764			}
4765			ret = regulator_disable(data->regulator_vddio);
4766			if (ret < 0) {
4767				dev_err(dev,
4768				"Atmel regulator disable for vddio failed: %d\n", ret);
4769			}
4770		}
4771		data->is_stopped = 1;
4772
4773	}
4774
4775
4776	return 0;
4777}
4778
4779static int mxt_resume(struct device *dev)
4780{
4781	int ret;
4782	struct i2c_client *client = to_i2c_client(dev);
4783	struct mxt_data *data = i2c_get_clientdata(client);
4784	struct input_dev *input_dev = data->input_dev;
4785
4786	if (data->pdata->cut_off_power) {
4787		mutex_lock(&input_dev->mutex);
4788
4789		if (!data->is_stopped) {
4790			mutex_unlock(&input_dev->mutex);
4791			return 0;
4792		}
4793
4794		if (data->regulator_vdd && data->regulator_avdd && data->regulator_vddio) {
4795			ret = regulator_enable(data->regulator_vdd);
4796			if (ret < 0) {
4797				dev_err(dev,
4798				"Atmel regulator enable for vdd failed: %d\n", ret);
4799			}
4800			ret = regulator_enable(data->regulator_avdd);
4801			if (ret < 0) {
4802				dev_err(dev,
4803				"Atmel regulator enable for avdd failed: %d\n", ret);
4804			}
4805			ret = regulator_enable(data->regulator_vddio);
4806			if (ret < 0) {
4807				dev_err(dev,
4808				"Atmel regulator enable for vddio failed: %d\n", ret);
4809			}
4810		}
4811
4812		mxt_wait_for_chg(data);
4813		mxt_enable_irq(data);
4814		schedule_delayed_work(&data->calibration_delayed_work, msecs_to_jiffies(100));
4815		data->is_stopped = false;
4816
4817		mutex_unlock(&input_dev->mutex);
4818	} else {
4819		mxt_enable_irq(data);
4820
4821		if (data->regulator_vdd && data->regulator_avdd && data->regulator_vddio) {
4822			ret = regulator_enable(data->regulator_vdd);
4823			if (ret < 0) {
4824				dev_err(dev,
4825				"Atmel regulator enable for vdd failed: %d\n", ret);
4826			}
4827			ret = regulator_enable(data->regulator_avdd);
4828			if (ret < 0) {
4829				dev_err(dev,
4830				"Atmel regulator enable for avdd failed: %d\n", ret);
4831			}
4832			ret = regulator_enable(data->regulator_vddio);
4833			if (ret < 0) {
4834				dev_err(dev,
4835				"Atmel regulator enable for vddio failed: %d\n", ret);
4836			}
4837		}
4838
4839		mutex_lock(&input_dev->mutex);
4840
4841		if (input_dev->users)
4842			mxt_start(data);
4843
4844		data->is_stopped = false;
4845		mutex_unlock(&input_dev->mutex);
4846	}
4847	return 0;
4848}
4849
4850static int mxt_input_enable(struct input_dev *in_dev)
4851{
4852	int error = 0;
4853	struct mxt_data *ts = input_get_drvdata(in_dev);
4854
4855	error = mxt_resume(&ts->client->dev);
4856	if (error)
4857		dev_err(&ts->client->dev, "%s: failed\n", __func__);
4858
4859	return error;
4860}
4861
4862static int mxt_input_disable(struct input_dev *in_dev)
4863{
4864	int error = 0;
4865	struct mxt_data *ts = input_get_drvdata(in_dev);
4866
4867	error = mxt_suspend(&ts->client->dev);
4868	if (error)
4869		dev_err(&ts->client->dev, "%s: failed\n", __func__);
4870
4871	return error;
4872}
4873
4874#ifdef CONFIG_FB
4875static int fb_notifier_cb(struct notifier_block *self,
4876			unsigned long event, void *data)
4877{
4878	struct fb_event *evdata = data;
4879	int *blank;
4880	struct mxt_data *mxt_data =
4881		container_of(self, struct mxt_data, fb_notif);
4882
4883	if (evdata && evdata->data && event == FB_EVENT_BLANK && mxt_data) {
4884		blank = evdata->data;
4885		if (*blank == FB_BLANK_UNBLANK) {
4886			dev_info(&mxt_data->client->dev, "##### UNBLANK SCREEN #####\n");
4887			mxt_data->screen_off = false;
4888			mxt_input_enable(mxt_data->input_dev);
4889		} else if (*blank == FB_BLANK_POWERDOWN) {
4890			dev_info(&mxt_data->client->dev, "##### BLANK SCREEN #####\n");
4891			mxt_data->screen_off = true;
4892			mxt_input_disable(mxt_data->input_dev);
4893		}
4894	}
4895
4896	return 0;
4897}
4898
4899static void configure_sleep(struct mxt_data *data)
4900{
4901	int ret;
4902
4903	data->fb_notif.notifier_call = fb_notifier_cb;
4904	ret = fb_register_client(&data->fb_notif);
4905	if (ret) {
4906		dev_err(&data->client->dev,
4907			"Unable to register fb_notifier, err: %d\n", ret);
4908	}
4909}
4910#else
4911static void configure_sleep(struct mxt_data *data)
4912{
4913	/*data->input_dev->enable = mxt_input_enable;
4914	data->input_dev->disable = mxt_input_disable;
4915	data->input_dev->enabled = true;*/
4916}
4917#endif
4918
4919static int mxt_initialize_input_device(struct mxt_data *data)
4920{
4921	struct device *dev = &data->client->dev;
4922	struct input_dev *input_dev;
4923	int ret;
4924	int i;
4925	int index = data->current_index;
4926
4927	/* Initialize input device */
4928	input_dev = input_allocate_device();
4929	if (!input_dev) {
4930		dev_err(dev, "Failed to allocate input device\n");
4931		return -ENOMEM;
4932	}
4933
4934	if (data->pdata->input_name) {
4935		input_dev->name = data->pdata->input_name;
4936	} else {
4937		input_dev->name = "atmel-maxtouch";
4938	}
4939
4940	input_dev->id.bustype = BUS_I2C;
4941	input_dev->dev.parent = dev;
4942	input_dev->open = mxt_input_open;
4943	input_dev->close = mxt_input_close;
4944	input_dev->event = mxt_input_event;
4945
4946	__set_bit(EV_ABS, input_dev->evbit);
4947	__set_bit(EV_KEY, input_dev->evbit);
4948	__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
4949	__set_bit(BTN_TOUCH, input_dev->keybit);
4950
4951	/* For multi touch */
4952	input_mt_init_slots(input_dev,
4953		data->num_touchids + data->num_stylusids, 0);
4954	if (data->t100_tchaux_bits &  MXT_T100_AREA) {
4955		dev_info(dev, "report area\n");
4956		input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
4957				     0, MXT_MAX_AREA, 0, 0);
4958	}
4959	input_set_abs_params(input_dev, ABS_MT_POSITION_X,
4960			     0, data->max_x, 0, 0);
4961	input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
4962			     0, data->max_y, 0, 0);
4963	if (data->t100_tchaux_bits &  MXT_T100_AMPL) {
4964		dev_info(dev, "report pressure\n");
4965		input_set_abs_params(input_dev, ABS_MT_PRESSURE,
4966				     0, 255, 0, 0);
4967	}
4968	if (data->t100_tchaux_bits &  MXT_T100_VECT) {
4969		dev_info(dev, "report vect\n");
4970		input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
4971				     0, 255, 0, 0);
4972	}
4973
4974	/* For T63 active stylus */
4975	if (data->T63_reportid_min) {
4976		__set_bit(BTN_STYLUS, input_dev->keybit);
4977		__set_bit(BTN_STYLUS2, input_dev->keybit);
4978
4979		input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
4980			0, MT_TOOL_MAX, 0, 0);
4981	}
4982
4983	/* For T15 key array */
4984	if (data->pdata->config_array[index].key_codes) {
4985		for (i = 0; i < data->pdata->config_array[index].key_num; i++) {
4986			if (data->pdata->config_array[index].key_codes[i])
4987				input_set_capability(input_dev, EV_KEY,
4988							data->pdata->config_array[index].key_codes[i]);
4989		}
4990	}
4991
4992	input_set_drvdata(input_dev, data);
4993
4994	ret = input_register_device(input_dev);
4995	if (ret) {
4996		dev_err(dev, "Error %d registering input device\n", ret);
4997		input_free_device(input_dev);
4998		return ret;
4999	}
5000
5001	data->input_dev = input_dev;
5002
5003	configure_sleep(data);
5004
5005	return 0;
5006}
5007
5008static struct dentry *debug_base;
5009
5010static int mxt_debugfs_object_show(struct seq_file *m, void *v)
5011{
5012	struct mxt_data *data = m->private;
5013	struct mxt_object *object;
5014	struct device *dev = &data->client->dev;
5015	int i, j, k;
5016	int error;
5017	int obj_size;
5018	u8 val;
5019
5020	seq_printf(m,
5021		  "Family ID: %02X Variant ID: %02X Version: %d.%d Build: 0x%02X"
5022		  "\nObject Num: %dMatrix X Size: %d Matrix Y Size: %d\n",
5023		   data->info.family_id, data->info.variant_id,
5024		   data->info.version >> 4, data->info.version & 0xf,
5025		   data->info.build, data->info.object_num,
5026		   data->info.matrix_xsize, data->info.matrix_ysize);
5027
5028	for (i = 0; i < data->info.object_num; i++) {
5029		object = data->object_table + i;
5030		obj_size = object->size + 1;
5031
5032		for (j = 0; j < object->instances; j++) {
5033			seq_printf(m, "Type %d NumId %d MaxId %d\n",
5034				   object->type, object->num_report_ids,
5035				   object->max_reportid);
5036
5037			for (k = 0; k < obj_size; k++) {
5038				error = mxt_read_object(data, object->type,
5039							j * obj_size + k, &val);
5040				if (error) {
5041					dev_err(dev,
5042						"Failed to read object %d "
5043						"instance %d at offset %d\n",
5044						object->type, j, k);
5045					return error;
5046				}
5047
5048				seq_printf(m, "%02x ", val);
5049				if (k % 10 == 9 || k + 1 == obj_size)
5050					seq_printf(m, "\n");
5051			}
5052		}
5053	}
5054
5055	return 0;
5056}
5057
5058static ssize_t mxt_debugfs_object_store(struct file *file,
5059			const char __user *buf, size_t count, loff_t *ppos)
5060{
5061	struct seq_file *m = file->private_data;
5062	struct mxt_data *data = m->private;
5063	u8 type, offset, val;
5064	int error;
5065
5066	if (sscanf(buf, "%hhu:%hhu=%hhx", &type, &offset, &val) == 3) {
5067		error = mxt_write_object(data, type, offset, val);
5068		if (error)
5069			count = error;
5070	} else
5071		count = -EINVAL;
5072
5073	return count;
5074}
5075
5076static int mxt_debugfs_object_open(struct inode *inode, struct file *file)
5077{
5078	return single_open(file, mxt_debugfs_object_show, inode->i_private);
5079}
5080
5081static const struct file_operations mxt_object_fops = {
5082	.owner		= THIS_MODULE,
5083	.open		= mxt_debugfs_object_open,
5084	.read		= seq_read,
5085	.write		= mxt_debugfs_object_store,
5086	.release	= single_release,
5087};
5088
5089static void mxt_debugfs_init(struct mxt_data *data)
5090{
5091	debug_base = debugfs_create_dir(MXT_DEBUGFS_DIR, NULL);
5092	if (IS_ERR_OR_NULL(debug_base))
5093		pr_err("atmel_mxt_ts: Failed to create debugfs dir\n");
5094	if (IS_ERR_OR_NULL(debugfs_create_file(MXT_DEBUGFS_FILE,
5095					       0444,
5096					       debug_base,
5097					       data,
5098					       &mxt_object_fops))) {
5099		pr_err("atmel_mxt_ts: Failed to create object file\n");
5100		debugfs_remove_recursive(debug_base);
5101	}
5102}
5103
5104static void mxt_update_fw_by_flag(struct mxt_data *data)
5105{
5106	const struct mxt_platform_data *pdata = data->pdata;
5107	int error;
5108
5109	if (data->update_flag == 0x01) {
5110		error = mxt_update_fw_flag_store(&data->client->dev, NULL, "0", 2);
5111		if (error != 2) {
5112			dev_err(&data->client->dev, "Failed to set T38 flag to 0!\n");
5113			return;
5114		}
5115		else {
5116			error = mxt_update_fw_store(&data->client->dev, NULL,
5117						pdata->mxt_fw_name, strlen(pdata->mxt_fw_name));
5118			if (error) {
5119				dev_err(&data->client->dev, "Unable to update firmware!\n");
5120				return;
5121			}
5122		}
5123	}
5124
5125}
5126
5127static void mxt_dump_value(struct device *dev, struct mxt_platform_data *pdata)
5128{
5129	int i = 0;
5130
5131	dev_info(dev, "reset gpio= %d\n", pdata->reset_gpio);
5132	dev_info(dev, "irq gpio= %d\n", pdata->irq_gpio);
5133	dev_info(dev, "power gpio= %d\n", pdata->power_gpio);
5134	dev_info(dev, "fw name = %s\n", pdata->mxt_fw_name);
5135	dev_info(dev, "config size = %d\n", pdata->config_array_size);
5136	dev_info(dev, "gpio mask = 0x%x\n", pdata->gpio_mask);
5137	dev_info(dev, "cut off power = %d\n", (int)pdata->cut_off_power);
5138
5139	for (i = 0; i < pdata->config_array_size; i++) {
5140		dev_info(dev, "family_id = 0x%x\n", pdata->config_array[i].family_id);
5141		dev_info(dev, "variant_id = 0x%x\n", pdata->config_array[i].variant_id);
5142		dev_info(dev, "version = 0x%x\n", pdata->config_array[i].version);
5143		dev_info(dev, "build = 0x%x\n", pdata->config_array[i].build);
5144		dev_info(dev, "mxt_cfg_name = %s\n", pdata->config_array[i].mxt_cfg_name);
5145		dev_info(dev, "vendor_id = 0x%x\n", pdata->config_array[i].vendor_id);
5146		dev_info(dev, "rev_id = 0x%x\n", pdata->config_array[i].rev_id);
5147		dev_info(dev, "wakeup self adcx = 0x%x\n", pdata->config_array[i].wake_up_self_adcx);
5148	}
5149}
5150
5151#ifdef CONFIG_OF
5152static int mxt_parse_dt(struct device *dev, struct mxt_platform_data *pdata)
5153{
5154	int ret;
5155	struct mxt_config_info *info;
5156	struct device_node *temp, *np = dev->of_node;
5157	u32 temp_val;
5158
5159	/* reset, irq, power gpio info */
5160	pdata->reset_gpio = of_get_named_gpio_flags(np, "atmel,reset-gpio",
5161				0, &pdata->reset_gpio_flags);
5162	pdata->irq_gpio = of_get_named_gpio_flags(np, "atmel,irq-gpio",
5163				0, &pdata->irq_gpio_flags);
5164	if (get_hw_version_major() <= 4)
5165		pdata->power_gpio = of_get_named_gpio_flags(np, "atmel,power-gpio",
5166					0, &pdata->power_gpio_flags);
5167	else
5168		pdata->power_gpio = -EINVAL;
5169
5170	ret = of_property_read_u32(np, "atmel,irqflags", &temp_val);
5171	if (ret) {
5172		dev_err(dev, "Unable to read irqflags id\n");
5173		return ret;
5174	} else
5175		pdata->irqflags = temp_val;
5176
5177	ret = of_property_read_string(np, "atmel,mxt-fw-name",
5178			&pdata->mxt_fw_name);
5179	if (ret && (ret != -EINVAL)) {
5180		dev_err(dev, "Unable to read fw name\n");
5181		return ret;
5182	}
5183
5184	pdata->cut_off_power = of_property_read_bool(np, "atmel,cut-off-power");
5185
5186	ret = of_property_read_u32(np, "atmel,gpio-mask", (u32*)&temp_val);
5187	if (ret)
5188		dev_err(dev, "Unable to read gpio mask\n");
5189	else
5190		pdata->gpio_mask = (u8)temp_val;
5191
5192	ret = of_property_read_u32(np, "atmel,config-array-size", &pdata->config_array_size);
5193	if (ret) {
5194		dev_err(dev, "Unable to get array size\n");
5195		return ret;
5196	}
5197
5198	ret = of_property_read_u32(np, "atmel,default-config", &pdata->default_config);
5199	if (ret) {
5200		dev_err(dev, "Unable to get default config\n");
5201		pdata->default_config = -1;
5202	}
5203
5204	pdata->config_array = devm_kzalloc(dev, pdata->config_array_size *
5205					sizeof(struct mxt_config_info), GFP_KERNEL);
5206	if (!pdata->config_array) {
5207		dev_err(dev, "Unable to allocate memory\n");
5208		return -ENOMEM;
5209	}
5210
5211	info = pdata->config_array;
5212
5213	for_each_child_of_node(np, temp) {
5214		ret = of_property_read_u32(temp, "atmel,family-id", &temp_val);
5215		if (ret) {
5216			dev_err(dev, "Unable to read family id\n");
5217			return ret;
5218		} else
5219			info->family_id = (u8)temp_val;
5220		ret = of_property_read_u32(temp, "atmel,variant-id", &temp_val);
5221		if (ret) {
5222			dev_err(dev, "Unable to read variant id\n");
5223			return ret;
5224		} else
5225			info->variant_id = (u8)temp_val;
5226		ret = of_property_read_u32(temp, "atmel,version", &temp_val);
5227		if (ret) {
5228			dev_err(dev, "Unable to read version\n");
5229			return ret;
5230		} else
5231			info->version = (u8)temp_val;
5232		ret = of_property_read_u32(temp, "atmel,build", &temp_val);
5233		if (ret) {
5234			dev_err(dev, "Unable to read build\n");
5235			return ret;
5236		} else
5237			info->build = (u8)temp_val;
5238		ret = of_property_read_string(temp, "atmel,mxt-cfg-name",
5239			&info->mxt_cfg_name);
5240		if (ret && (ret != -EINVAL)) {
5241			dev_err(dev, "Unable to read cfg name\n");
5242			return ret;
5243		}
5244		ret = of_property_read_u32(temp, "atmel,vendor-id", &temp_val);
5245		if (ret) {
5246			dev_err(dev, "Unable to read vendor id\n");
5247			return ret;
5248		} else
5249			info->vendor_id = (u8)temp_val;
5250		if (get_hw_version_major() == 3) {
5251			ret = of_property_read_u32(temp, "atmel,lcd-id", &temp_val);
5252			if (ret) {
5253				dev_err(dev, "Unable to read lcd id\n");
5254				return ret;
5255			} else
5256				info->lcd_id = (int)temp_val;
5257		} else if (get_hw_version_major() == 4) {
5258			ret = of_property_read_u32(temp, "atmel,rev-id", &temp_val);
5259			if (ret) {
5260				dev_err(dev, "Unable to read rev id\n");
5261				return ret;
5262			} else
5263				info->rev_id = (u8)temp_val;
5264		}
5265		ret = of_property_read_u32(temp, "atmel,key-num", &temp_val);
5266		if (ret) {
5267			dev_err(dev, "Unable to read key num id\n");
5268			return ret;
5269		} else
5270			info->key_num = temp_val;
5271		if (info->key_num != 0) {
5272			info->key_codes = devm_kzalloc(dev,
5273						sizeof(int) * info->key_num, GFP_KERNEL);
5274			if (!info->key_codes)
5275				return -ENOMEM;
5276			ret = of_property_read_u32_array(temp, "atmel,key-codes",
5277							info->key_codes, info->key_num);
5278			if (ret) {
5279				dev_err(dev, "Unable to read key codes\n");
5280				return ret;
5281			}
5282		}
5283
5284		ret = of_property_read_u32(temp, "atmel,selfintthr-stylus", &temp_val);
5285		if (ret) {
5286			dev_err(dev, "Unable to read selfintthr-stylus\n");
5287			return ret;
5288		} else
5289			info->selfintthr_stylus = temp_val;
5290		ret = of_property_read_u32(temp, "atmel,t71-tchthr-pos", &temp_val);
5291		if (ret) {
5292			dev_err(dev, "Unable to read t71-glove-ctrl-reg\n");
5293			return ret;
5294		} else
5295			info->t71_tchthr_pos = temp_val;
5296		ret = of_property_read_u32(temp, "atmel,self-chgtime-min", &temp_val);
5297		if (ret) {
5298			dev_err(dev, "Unable to read self-chgtime-min\n");
5299			return ret;
5300		} else
5301			info->self_chgtime_min = temp_val;
5302		ret = of_property_read_u32(temp, "atmel,self-chgtime-max", &temp_val);
5303		if (ret) {
5304			dev_err(dev, "Unable to read self-chgtime-max\n");
5305			return ret;
5306		} else
5307			info->self_chgtime_max = temp_val;
5308		ret = of_property_read_u32(temp, "atmel,mult-intthr-sensitive", &temp_val);
5309		if (ret) {
5310			dev_err(dev, "Unable to read mult-intthr-sensitive\n");
5311			return ret;
5312		} else
5313			info->mult_intthr_sensitive = temp_val;
5314		ret = of_property_read_u32(temp, "atmel,mult-intthr-not-sensitive", &temp_val);
5315		if (ret) {
5316			dev_err(dev, "Unable to read mult-intthr-not-sensitive\n");
5317			return ret;
5318		} else
5319			info->mult_intthr_not_sensitive = temp_val;
5320		ret = of_property_read_u32(temp, "atmel,atchthr-sensitive", &temp_val);
5321		if (ret) {
5322			dev_err(dev, "Unable to read mult-intthr-not-sensitive\n");
5323			return ret;
5324		} else
5325			info->atchthr_sensitive = temp_val;
5326		ret = of_property_read_u32(temp, "atmel,mult-tchthr-sensitive", &temp_val);
5327		if (ret) {
5328			dev_err(dev, "Unable to read mult-tchthr-sensitive\n");
5329			return ret;
5330		} else
5331			info->mult_tchthr_sensitive = temp_val;
5332		ret = of_property_read_u32(temp, "atmel,mult-tchthr-not-sensitive", &temp_val);
5333		if (ret) {
5334			dev_err(dev, "Unable to read mult-tchthr-not-sensitive\n");
5335			return ret;
5336		} else
5337			info->mult_tchthr_not_sensitive = temp_val;
5338
5339		ret = of_property_read_u32(temp, "atmel,wake-up-self-adcx", &temp_val);
5340		if (ret) {
5341			dev_err(dev, "Unable to read wake-up-self-adcx\n");
5342			info->wake_up_self_adcx = 0;
5343		} else
5344			info->wake_up_self_adcx = (u8)temp_val;
5345
5346
5347		info++;
5348	}
5349
5350	mxt_dump_value(dev, pdata);
5351
5352	return 0;
5353}
5354#else
5355static int mxt_parse_dt(struct device *dev, struct mxt_platform_data *pdata)
5356{
5357	return -ENODEV;
5358}
5359#endif
5360
5361static int mxt_probe(struct i2c_client *client,
5362		const struct i2c_device_id *id)
5363{
5364	struct mxt_platform_data *pdata;
5365	struct mxt_data *data;
5366	int error;
5367	struct gpiomux_setting old_rst_setting, old_int_setting;
5368
5369//	if (get_hw_version_major() < 4)
5370//		return -ENODEV;
5371
5372	if (client->dev.of_node) {
5373		pdata = devm_kzalloc(&client->dev,
5374			sizeof(struct mxt_platform_data), GFP_KERNEL);
5375		if (!pdata) {
5376			dev_err(&client->dev, "Failed to allocate memory\n");
5377			return -ENOMEM;
5378		}
5379
5380		error = mxt_parse_dt(&client->dev, pdata);
5381		if (error)
5382			return error;
5383	} else
5384		pdata = client->dev.platform_data;
5385
5386	if (!pdata)
5387		return -EINVAL;
5388
5389	data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
5390	if (!data) {
5391		dev_err(&client->dev, "Failed to allocate memory\n");
5392		return -ENOMEM;
5393	}
5394
5395	data->state = INIT;
5396
5397	data->client = client;
5398	data->pdata = pdata;
5399	data->irq = client->irq;
5400
5401	/* In X5 platform, we do not need to control touchscreen power,
5402	   which is enabled by LCD */
5403	if (get_hw_version_major() <= 4) {
5404		/* In X4 platform, we need to control power gpio by ourselves */
5405		if (gpio_is_valid(pdata->power_gpio)) {
5406			error = gpio_request(pdata->power_gpio, "mxt_gpio_power");
5407			if (!error) {
5408				error = gpio_direction_output(pdata->power_gpio, 1);
5409				if (error) {
5410					pr_err("%s: unable to set direction gpio %d\n",
5411						__func__, pdata->power_gpio);
5412					goto err_disable_regulator;
5413				}
5414			} else {
5415				pr_err("%s: unable to request power gpio %d\n",
5416					__func__, pdata->power_gpio);
5417				goto err_free_data;
5418			}
5419		}
5420	} else {
5421		/* In X5 platform, if we need to cut off power when lcd is off,
5422		 * we should also control the power regulator */
5423		if (pdata->cut_off_power)
5424			mxt_initialize_regulator(data);
5425	}
5426
5427	if (gpio_is_valid(pdata->irq_gpio)) {
5428		/* configure touchscreen irq gpio */
5429		error = gpio_request(pdata->irq_gpio, "mxt_irq_gpio");
5430		if (error) {
5431			pr_err("%s: unable to request gpio [%d]\n", __func__,
5432						pdata->irq_gpio);
5433			goto err_disable_regulator;
5434		}
5435		error = gpio_direction_input(pdata->irq_gpio);
5436		if (error) {
5437			pr_err("%s: unable to set_direction for gpio [%d]\n",
5438					__func__, pdata->irq_gpio);
5439			goto err_irq_gpio_req;
5440		}
5441	}
5442
5443	if (gpio_is_valid(pdata->reset_gpio)) {
5444		/* configure touchscreen reset out gpio */
5445		error = gpio_request(pdata->reset_gpio, "mxt_reset_gpio");
5446		if (error) {
5447			pr_err("%s: unable to request reset gpio %d\n",
5448				__func__, pdata->reset_gpio);
5449			goto err_irq_gpio_req;
5450		}
5451
5452		error = gpio_direction_output(pdata->reset_gpio, 1);
5453		if (error) {
5454			pr_err("%s: unable to set direction for gpio %d\n",
5455				__func__, pdata->reset_gpio);
5456			goto err_reset_gpio_req;
5457		}
5458	}
5459
5460	i2c_set_clientdata(data->client, data);
5461	mdelay(10);
5462	mxt_wait_for_chg(data);
5463	INIT_WORK(&data->self_tuning_work, mxt_self_tuning_work);
5464	INIT_WORK(&data->hover_loading_work, mxt_hover_loading_work);
5465	INIT_DELAYED_WORK(&data->calibration_delayed_work,
5466				mxt_calibration_delayed_work);
5467	/* Initialize i2c device */
5468retry:
5469	error = mxt_initialize(data);
5470	if (error)
5471	{
5472		if (gpio_is_valid(pdata->power_gpio))
5473			pr_err("power gpio = %d\n", (int)gpio_get_value(pdata->power_gpio));
5474		pr_err("reset gpio = %d\n", (int)gpio_get_value(pdata->reset_gpio));
5475		pr_err("chg gpio = %d\n", (int)gpio_get_value(pdata->irq_gpio));
5476
5477		if (error != -ENOENT) {
5478			if (client->addr == 0x4a)
5479				goto err_reset_gpio_req;
5480			else {
5481				client->addr = 0x4a;
5482				goto retry;
5483			}
5484		}
5485		else {
5486			error = mxt_update_firmware(&client->dev, NULL,
5487				pdata->mxt_fw_name, strlen(pdata->mxt_fw_name), &data->firmware_updated);
5488			if (error != strlen(pdata->mxt_fw_name))
5489			{
5490				dev_err(&client->dev, "Error when update firmware!\n");
5491				goto err_reset_gpio_req;
5492			}
5493		}
5494	}
5495
5496	/*
5497	 * In X5 platform, since we will cut off lcd power when display is off.
5498	 * To avoid a powerup issue, we will set RST pin to HI-Z and disable
5499	 * internal pull-up resistor on INT pin
5500	 */
5501	if (get_hw_version_major() == 5 && pdata->cut_off_power) {
5502		if (msm_gpiomux_write(pdata->reset_gpio, GPIOMUX_ACTIVE,
5503				&mxt_rst_cutoff_pwr_cfg, &old_rst_setting)) {
5504			dev_err(&client->dev, "Failed to set RESET pinmux setting\n");
5505			goto err_free_object;
5506		}
5507
5508		if (msm_gpiomux_write(pdata->irq_gpio, GPIOMUX_ACTIVE,
5509				&mxt_int_cutoff_pwr_cfg, &old_int_setting)) {
5510			dev_err(&client->dev, "Failed to set INT pinmux setting\n");
5511			goto err_restore_rst_gpio_setting;
5512		}
5513
5514		if (gpio_direction_input(pdata->reset_gpio)) {
5515			dev_err(&client->dev, "Failed to set RESET pin to input\n");
5516			goto err_restore_int_gpio_setting;
5517		}
5518		mdelay(10);
5519		mxt_wait_for_chg(data);
5520	}
5521
5522	if (0)
5523		mxt_update_fw_by_flag(data);
5524
5525	error = mxt_initialize_input_device(data);
5526	if (error)
5527		goto err_restore_int_gpio_setting;
5528
5529	error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
5530			pdata->irqflags, client->dev.driver->name, data);
5531	if (error) {
5532		dev_err(&client->dev, "Error %d registering irq\n", error);
5533		goto err_free_input_device;
5534	}
5535	data->irq_enabled = true;
5536	data->screen_off = false;
5537
5538	device_init_wakeup(&client->dev, 1);
5539
5540	error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
5541	if (error) {
5542		dev_err(&client->dev, "Failure %d creating sysfs group\n",
5543			error);
5544		goto err_free_irq;
5545	}
5546
5547
5548	sysfs_bin_attr_init(&data->mem_access_attr);
5549	data->mem_access_attr.attr.name = "mem_access";
5550	data->mem_access_attr.attr.mode = S_IRUGO | S_IWUSR;
5551	data->mem_access_attr.read = mxt_mem_access_read;
5552	data->mem_access_attr.write = mxt_mem_access_write;
5553	data->mem_access_attr.size = data->mem_size;
5554
5555	if (sysfs_create_bin_file(&client->dev.kobj,
5556				  &data->mem_access_attr) < 0) {
5557		dev_err(&client->dev, "Failed to create %s\n",
5558			data->mem_access_attr.attr.name);
5559		goto err_remove_sysfs_group;
5560	}
5561
5562	mxt_debugfs_init(data);
5563	schedule_work(&data->hover_loading_work);
5564
5565	return 0;
5566
5567err_remove_sysfs_group:
5568	sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
5569err_free_irq:
5570	free_irq(client->irq, data);
5571err_free_input_device:
5572	input_unregister_device(data->input_dev);
5573err_free_object:
5574	kfree(data->msg_buf);
5575	kfree(data->object_table);
5576err_restore_int_gpio_setting:
5577	if (get_hw_version_major() == 5 && pdata->cut_off_power)
5578		msm_gpiomux_write(pdata->irq_gpio, GPIOMUX_ACTIVE,
5579				&old_int_setting, NULL);
5580err_restore_rst_gpio_setting:
5581	if (get_hw_version_major() == 5 && pdata->cut_off_power)
5582		msm_gpiomux_write(pdata->reset_gpio, GPIOMUX_ACTIVE,
5583				&old_rst_setting, NULL);
5584err_reset_gpio_req:
5585	if (gpio_is_valid(pdata->reset_gpio))
5586		gpio_free(pdata->reset_gpio);
5587err_irq_gpio_req:
5588	if (gpio_is_valid(pdata->irq_gpio))
5589		gpio_free(pdata->irq_gpio);
5590err_disable_regulator:
5591	if (gpio_is_valid(pdata->power_gpio)) {
5592		gpio_set_value_cansleep(pdata->power_gpio, 0);
5593		gpio_free(pdata->power_gpio);
5594	}
5595	if (data->regulator_vdd)
5596		regulator_disable(data->regulator_vdd);
5597	if (data->regulator_avdd)
5598		regulator_disable(data->regulator_avdd);
5599	if (data->regulator_vddio)
5600		regulator_disable(data->regulator_vddio);
5601err_free_data:
5602	kfree(data);
5603	return error;
5604}
5605
5606static int mxt_remove(struct i2c_client *client)
5607{
5608	struct mxt_data *data = i2c_get_clientdata(client);
5609	const struct mxt_platform_data *pdata = data->pdata;
5610
5611	sysfs_remove_bin_file(&client->dev.kobj, &data->mem_access_attr);
5612	sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
5613	free_irq(data->irq, data);
5614	input_unregister_device(data->input_dev);
5615	kfree(data->msg_buf);
5616	data->msg_buf = NULL;
5617	kfree(data->object_table);
5618	data->object_table = NULL;
5619	if (gpio_is_valid(pdata->power_gpio)) {
5620		gpio_set_value_cansleep(pdata->power_gpio, 0);
5621		gpio_free(pdata->power_gpio);
5622	}
5623	if (data->regulator_vdd)
5624		regulator_disable(data->regulator_vdd);
5625	if (data->regulator_avdd)
5626		regulator_disable(data->regulator_avdd);
5627	if (data->regulator_vddio)
5628		regulator_disable(data->regulator_vddio);
5629
5630	if (gpio_is_valid(pdata->irq_gpio))
5631		gpio_free (pdata->irq_gpio);
5632
5633	if (gpio_is_valid(pdata->reset_gpio))
5634		gpio_free(pdata->reset_gpio);
5635
5636	kfree(data);
5637	data = NULL;
5638
5639	return 0;
5640}
5641
5642static void mxt_shutdown(struct i2c_client *client)
5643{
5644	struct mxt_data *data = i2c_get_clientdata(client);
5645
5646	mxt_disable_irq(data);
5647	data->state = SHUTDOWN;
5648}
5649
5650#ifdef CONFIG_PM
5651static int mxt_ts_suspend(struct device *dev)
5652{
5653	struct mxt_data *data =  dev_get_drvdata(dev);
5654
5655	if (device_may_wakeup(dev) &&
5656			mxt_prevent_sleep()) {
5657		dev_info(dev, "touch enable irq wake\n");
5658		mxt_disable_irq(data);
5659		enable_irq_wake(data->client->irq);
5660	}
5661
5662	return 0;
5663}
5664
5665static int mxt_ts_resume(struct device *dev)
5666{
5667	struct mxt_data *data =  dev_get_drvdata(dev);
5668
5669	if (device_may_wakeup(dev) &&
5670			mxt_prevent_sleep()) {
5671		dev_info(dev, "touch disable irq wake\n");
5672		disable_irq_wake(data->client->irq);
5673		mxt_enable_irq(data);
5674	}
5675
5676	return 0;
5677}
5678
5679static SIMPLE_DEV_PM_OPS(mxt_touchscreen_pm_ops, mxt_ts_suspend, mxt_ts_resume);
5680#endif
5681
5682static const struct i2c_device_id mxt_id[] = {
5683	{ "qt602240_ts", 0 },
5684	{ "atmel_mxt_ts_640t", 0 },
5685	{ "atmel_mxt_ts", 0},
5686	{ "mXT224", 0 },
5687	{ }
5688};
5689MODULE_DEVICE_TABLE(i2c, mxt_id);
5690
5691#ifdef CONFIG_OF
5692static struct of_device_id mxt_match_table[] = {
5693	{ .compatible = "atmel,mxt-ts-640t",},
5694	{ .compatible = "atmel,mxt-ts", },
5695	{}
5696};
5697#else
5698#define mxt_match_table NULL
5699#endif
5700
5701static struct i2c_driver mxt_driver = {
5702	.driver = {
5703		.name	= "atmel_mxt_ts",
5704		.owner	= THIS_MODULE,
5705		.of_match_table = mxt_match_table,
5706#ifdef CONFIG_PM
5707		.pm = &mxt_touchscreen_pm_ops,
5708#endif
5709	},
5710	.probe		= mxt_probe,
5711	.remove		= mxt_remove,
5712	.shutdown	= mxt_shutdown,
5713	.id_table	= mxt_id,
5714};
5715
5716static int __init mxt_init(void)
5717{
5718	return i2c_add_driver(&mxt_driver);
5719}
5720
5721static void __exit mxt_exit(void)
5722{
5723	i2c_del_driver(&mxt_driver);
5724}
5725
5726late_initcall(mxt_init);
5727module_exit(mxt_exit);
5728
5729/* Module information */
5730MODULE_AUTHOR("Lionel Zhang <zhangbo_a@xiaomi.com>");
5731MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
5732MODULE_LICENSE("GPL");