2 * Atmel maXTouch Touchscreen driver
4 * Copyright (C) 2010 Samsung Electronics Co.Ltd
5 * Copyright (C) 2011-2014 Atmel Corporation
6 * Copyright (C) 2012 Google, Inc.
8 * Author: Joonyoung Shim <jy0922.shim@samsung.com>
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
17 #include <linux/acpi.h>
18 #include <linux/dmi.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/completion.h>
22 #include <linux/delay.h>
23 #include <linux/firmware.h>
24 #include <linux/i2c.h>
25 #include <linux/platform_data/atmel_mxt_ts.h>
26 #include <linux/input/mt.h>
27 #include <linux/interrupt.h>
29 #include <linux/slab.h>
30 #include <asm/unaligned.h>
31 #include <media/v4l2-device.h>
32 #include <media/v4l2-ioctl.h>
33 #include <media/videobuf2-v4l2.h>
34 #include <media/videobuf2-vmalloc.h>
37 #define MXT_FW_NAME "maxtouch.fw"
38 #define MXT_CFG_NAME "maxtouch.cfg"
39 #define MXT_CFG_MAGIC "OBP_RAW V1"
42 #define MXT_OBJECT_START 0x07
43 #define MXT_OBJECT_SIZE 6
44 #define MXT_INFO_CHECKSUM_SIZE 3
45 #define MXT_MAX_BLOCK_WRITE 256
48 #define MXT_DEBUG_DIAGNOSTIC_T37 37
49 #define MXT_GEN_MESSAGE_T5 5
50 #define MXT_GEN_COMMAND_T6 6
51 #define MXT_GEN_POWER_T7 7
52 #define MXT_GEN_ACQUIRE_T8 8
53 #define MXT_GEN_DATASOURCE_T53 53
54 #define MXT_TOUCH_MULTI_T9 9
55 #define MXT_TOUCH_KEYARRAY_T15 15
56 #define MXT_TOUCH_PROXIMITY_T23 23
57 #define MXT_TOUCH_PROXKEY_T52 52
58 #define MXT_PROCI_GRIPFACE_T20 20
59 #define MXT_PROCG_NOISE_T22 22
60 #define MXT_PROCI_ONETOUCH_T24 24
61 #define MXT_PROCI_TWOTOUCH_T27 27
62 #define MXT_PROCI_GRIP_T40 40
63 #define MXT_PROCI_PALM_T41 41
64 #define MXT_PROCI_TOUCHSUPPRESSION_T42 42
65 #define MXT_PROCI_STYLUS_T47 47
66 #define MXT_PROCG_NOISESUPPRESSION_T48 48
67 #define MXT_SPT_COMMSCONFIG_T18 18
68 #define MXT_SPT_GPIOPWM_T19 19
69 #define MXT_SPT_SELFTEST_T25 25
70 #define MXT_SPT_CTECONFIG_T28 28
71 #define MXT_SPT_USERDATA_T38 38
72 #define MXT_SPT_DIGITIZER_T43 43
73 #define MXT_SPT_MESSAGECOUNT_T44 44
74 #define MXT_SPT_CTECONFIG_T46 46
75 #define MXT_TOUCH_MULTITOUCHSCREEN_T100 100
77 /* MXT_GEN_MESSAGE_T5 object */
78 #define MXT_RPTID_NOMSG 0xff
80 /* MXT_GEN_COMMAND_T6 field */
81 #define MXT_COMMAND_RESET 0
82 #define MXT_COMMAND_BACKUPNV 1
83 #define MXT_COMMAND_CALIBRATE 2
84 #define MXT_COMMAND_REPORTALL 3
85 #define MXT_COMMAND_DIAGNOSTIC 5
87 /* Define for T6 status byte */
88 #define MXT_T6_STATUS_RESET (1 << 7)
89 #define MXT_T6_STATUS_OFL (1 << 6)
90 #define MXT_T6_STATUS_SIGERR (1 << 5)
91 #define MXT_T6_STATUS_CAL (1 << 4)
92 #define MXT_T6_STATUS_CFGERR (1 << 3)
93 #define MXT_T6_STATUS_COMSERR (1 << 2)
95 /* MXT_GEN_POWER_T7 field */
101 #define MXT_POWER_CFG_RUN 0
102 #define MXT_POWER_CFG_DEEPSLEEP 1
104 /* MXT_TOUCH_MULTI_T9 field */
105 #define MXT_T9_CTRL 0
106 #define MXT_T9_XSIZE 3
107 #define MXT_T9_YSIZE 4
108 #define MXT_T9_ORIENT 9
109 #define MXT_T9_RANGE 18
111 /* MXT_TOUCH_MULTI_T9 status */
112 #define MXT_T9_UNGRIP (1 << 0)
113 #define MXT_T9_SUPPRESS (1 << 1)
114 #define MXT_T9_AMP (1 << 2)
115 #define MXT_T9_VECTOR (1 << 3)
116 #define MXT_T9_MOVE (1 << 4)
117 #define MXT_T9_RELEASE (1 << 5)
118 #define MXT_T9_PRESS (1 << 6)
119 #define MXT_T9_DETECT (1 << 7)
126 /* MXT_TOUCH_MULTI_T9 orient */
127 #define MXT_T9_ORIENT_SWITCH (1 << 0)
128 #define MXT_T9_ORIENT_INVERTX (1 << 1)
129 #define MXT_T9_ORIENT_INVERTY (1 << 2)
131 /* MXT_SPT_COMMSCONFIG_T18 */
132 #define MXT_COMMS_CTRL 0
133 #define MXT_COMMS_CMD 1
135 /* MXT_DEBUG_DIAGNOSTIC_T37 */
136 #define MXT_DIAGNOSTIC_PAGEUP 0x01
137 #define MXT_DIAGNOSTIC_DELTAS 0x10
138 #define MXT_DIAGNOSTIC_SIZE 128
140 #define MXT_FAMILY_1386 160
141 #define MXT1386_COLUMNS 3
142 #define MXT1386_PAGES_PER_COLUMN 8
145 #ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
148 u8 data
[MXT_DIAGNOSTIC_SIZE
];
152 /* Define for MXT_GEN_COMMAND_T6 */
153 #define MXT_BOOT_VALUE 0xa5
154 #define MXT_RESET_VALUE 0x01
155 #define MXT_BACKUP_VALUE 0x55
157 /* T100 Multiple Touch Touchscreen */
158 #define MXT_T100_CTRL 0
159 #define MXT_T100_CFG1 1
160 #define MXT_T100_TCHAUX 3
161 #define MXT_T100_XSIZE 9
162 #define MXT_T100_XRANGE 13
163 #define MXT_T100_YSIZE 20
164 #define MXT_T100_YRANGE 24
166 #define MXT_T100_CFG_SWITCHXY BIT(5)
167 #define MXT_T100_CFG_INVERTY BIT(6)
168 #define MXT_T100_CFG_INVERTX BIT(7)
170 #define MXT_T100_TCHAUX_VECT BIT(0)
171 #define MXT_T100_TCHAUX_AMPL BIT(1)
172 #define MXT_T100_TCHAUX_AREA BIT(2)
174 #define MXT_T100_DETECT BIT(7)
175 #define MXT_T100_TYPE_MASK 0x70
178 MXT_T100_TYPE_FINGER
= 1,
179 MXT_T100_TYPE_PASSIVE_STYLUS
= 2,
180 MXT_T100_TYPE_HOVERING_FINGER
= 4,
181 MXT_T100_TYPE_GLOVE
= 5,
182 MXT_T100_TYPE_LARGE_TOUCH
= 6,
185 #define MXT_DISTANCE_ACTIVE_TOUCH 0
186 #define MXT_DISTANCE_HOVERING 1
188 #define MXT_TOUCH_MAJOR_DEFAULT 1
189 #define MXT_PRESSURE_DEFAULT 1
192 #define MXT_BACKUP_TIME 50 /* msec */
193 #define MXT_RESET_TIME 200 /* msec */
194 #define MXT_RESET_TIMEOUT 3000 /* msec */
195 #define MXT_CRC_TIMEOUT 1000 /* msec */
196 #define MXT_FW_RESET_TIME 3000 /* msec */
197 #define MXT_FW_CHG_TIMEOUT 300 /* msec */
199 /* Command to unlock bootloader */
200 #define MXT_UNLOCK_CMD_MSB 0xaa
201 #define MXT_UNLOCK_CMD_LSB 0xdc
203 /* Bootloader mode status */
204 #define MXT_WAITING_BOOTLOAD_CMD 0xc0 /* valid 7 6 bit only */
205 #define MXT_WAITING_FRAME_DATA 0x80 /* valid 7 6 bit only */
206 #define MXT_FRAME_CRC_CHECK 0x02
207 #define MXT_FRAME_CRC_FAIL 0x03
208 #define MXT_FRAME_CRC_PASS 0x04
209 #define MXT_APP_CRC_FAIL 0x40 /* valid 7 8 bit only */
210 #define MXT_BOOT_STATUS_MASK 0x3f
211 #define MXT_BOOT_EXTENDED_ID (1 << 5)
212 #define MXT_BOOT_ID_MASK 0x1f
214 /* Touchscreen absolute values */
215 #define MXT_MAX_AREA 0xff
217 #define MXT_PIXELS_PER_MM 20
233 u8 instances_minus_one
;
239 u16 diag_cmd_address
;
240 struct t37_debug
*t37_buf
;
241 unsigned int t37_pages
;
242 unsigned int t37_nodes
;
244 struct v4l2_device v4l2
;
245 struct v4l2_pix_format format
;
246 struct video_device vdev
;
247 struct vb2_queue queue
;
252 static const struct v4l2_file_operations mxt_video_fops
= {
253 .owner
= THIS_MODULE
,
254 .open
= v4l2_fh_open
,
255 .release
= vb2_fop_release
,
256 .unlocked_ioctl
= video_ioctl2
,
257 .read
= vb2_fop_read
,
258 .mmap
= vb2_fop_mmap
,
259 .poll
= vb2_fop_poll
,
262 /* Each client has this additional data */
264 struct i2c_client
*client
;
265 struct input_dev
*input_dev
;
266 char phys
[64]; /* device physical location */
267 const struct mxt_platform_data
*pdata
;
268 struct mxt_object
*object_table
;
269 struct mxt_info info
;
290 u8 last_message_count
;
293 struct t7_config t7_cfg
;
296 /* Cached parameters from object table */
306 u8 T100_reportid_min
;
307 u8 T100_reportid_max
;
309 /* for fw update in bootloader */
310 struct completion bl_completion
;
312 /* for reset handling */
313 struct completion reset_completion
;
315 /* for config update handling */
316 struct completion crc_completion
;
319 struct mxt_vb2_buffer
{
320 struct vb2_buffer vb
;
321 struct list_head list
;
324 static size_t mxt_obj_size(const struct mxt_object
*obj
)
326 return obj
->size_minus_one
+ 1;
329 static size_t mxt_obj_instances(const struct mxt_object
*obj
)
331 return obj
->instances_minus_one
+ 1;
334 static bool mxt_object_readable(unsigned int type
)
337 case MXT_GEN_COMMAND_T6
:
338 case MXT_GEN_POWER_T7
:
339 case MXT_GEN_ACQUIRE_T8
:
340 case MXT_GEN_DATASOURCE_T53
:
341 case MXT_TOUCH_MULTI_T9
:
342 case MXT_TOUCH_KEYARRAY_T15
:
343 case MXT_TOUCH_PROXIMITY_T23
:
344 case MXT_TOUCH_PROXKEY_T52
:
345 case MXT_PROCI_GRIPFACE_T20
:
346 case MXT_PROCG_NOISE_T22
:
347 case MXT_PROCI_ONETOUCH_T24
:
348 case MXT_PROCI_TWOTOUCH_T27
:
349 case MXT_PROCI_GRIP_T40
:
350 case MXT_PROCI_PALM_T41
:
351 case MXT_PROCI_TOUCHSUPPRESSION_T42
:
352 case MXT_PROCI_STYLUS_T47
:
353 case MXT_PROCG_NOISESUPPRESSION_T48
:
354 case MXT_SPT_COMMSCONFIG_T18
:
355 case MXT_SPT_GPIOPWM_T19
:
356 case MXT_SPT_SELFTEST_T25
:
357 case MXT_SPT_CTECONFIG_T28
:
358 case MXT_SPT_USERDATA_T38
:
359 case MXT_SPT_DIGITIZER_T43
:
360 case MXT_SPT_CTECONFIG_T46
:
367 static void mxt_dump_message(struct mxt_data
*data
, u8
*message
)
369 dev_dbg(&data
->client
->dev
, "message: %*ph\n",
370 data
->T5_msg_size
, message
);
373 static int mxt_wait_for_completion(struct mxt_data
*data
,
374 struct completion
*comp
,
375 unsigned int timeout_ms
)
377 struct device
*dev
= &data
->client
->dev
;
378 unsigned long timeout
= msecs_to_jiffies(timeout_ms
);
381 ret
= wait_for_completion_interruptible_timeout(comp
, timeout
);
384 } else if (ret
== 0) {
385 dev_err(dev
, "Wait for completion timed out.\n");
391 static int mxt_bootloader_read(struct mxt_data
*data
,
392 u8
*val
, unsigned int count
)
397 msg
.addr
= data
->bootloader_addr
;
398 msg
.flags
= data
->client
->flags
& I2C_M_TEN
;
399 msg
.flags
|= I2C_M_RD
;
403 ret
= i2c_transfer(data
->client
->adapter
, &msg
, 1);
407 ret
= ret
< 0 ? ret
: -EIO
;
408 dev_err(&data
->client
->dev
, "%s: i2c recv failed (%d)\n",
415 static int mxt_bootloader_write(struct mxt_data
*data
,
416 const u8
* const val
, unsigned int count
)
421 msg
.addr
= data
->bootloader_addr
;
422 msg
.flags
= data
->client
->flags
& I2C_M_TEN
;
426 ret
= i2c_transfer(data
->client
->adapter
, &msg
, 1);
430 ret
= ret
< 0 ? ret
: -EIO
;
431 dev_err(&data
->client
->dev
, "%s: i2c send failed (%d)\n",
438 static int mxt_lookup_bootloader_address(struct mxt_data
*data
, bool retry
)
440 u8 appmode
= data
->client
->addr
;
446 /* Chips after 1664S use different scheme */
447 if (retry
|| data
->info
.family_id
>= 0xa2) {
448 bootloader
= appmode
- 0x24;
451 /* Fall through for normal case */
456 bootloader
= appmode
- 0x26;
460 dev_err(&data
->client
->dev
,
461 "Appmode i2c address 0x%02x not found\n",
466 data
->bootloader_addr
= bootloader
;
470 static int mxt_probe_bootloader(struct mxt_data
*data
, bool alt_address
)
472 struct device
*dev
= &data
->client
->dev
;
477 error
= mxt_lookup_bootloader_address(data
, alt_address
);
481 error
= mxt_bootloader_read(data
, &val
, 1);
485 /* Check app crc fail mode */
486 crc_failure
= (val
& ~MXT_BOOT_STATUS_MASK
) == MXT_APP_CRC_FAIL
;
488 dev_err(dev
, "Detected bootloader, status:%02X%s\n",
489 val
, crc_failure
? ", APP_CRC_FAIL" : "");
494 static u8
mxt_get_bootloader_version(struct mxt_data
*data
, u8 val
)
496 struct device
*dev
= &data
->client
->dev
;
499 if (val
& MXT_BOOT_EXTENDED_ID
) {
500 if (mxt_bootloader_read(data
, &buf
[0], 3) != 0) {
501 dev_err(dev
, "%s: i2c failure\n", __func__
);
505 dev_dbg(dev
, "Bootloader ID:%d Version:%d\n", buf
[1], buf
[2]);
509 dev_dbg(dev
, "Bootloader ID:%d\n", val
& MXT_BOOT_ID_MASK
);
515 static int mxt_check_bootloader(struct mxt_data
*data
, unsigned int state
,
518 struct device
*dev
= &data
->client
->dev
;
525 * In application update mode, the interrupt
526 * line signals state transitions. We must wait for the
527 * CHG assertion before reading the status byte.
528 * Once the status byte has been read, the line is deasserted.
530 ret
= mxt_wait_for_completion(data
, &data
->bl_completion
,
534 * TODO: handle -ERESTARTSYS better by terminating
535 * fw update process before returning to userspace
536 * by writing length 0x000 to device (iff we are in
537 * WAITING_FRAME_DATA state).
539 dev_err(dev
, "Update wait error %d\n", ret
);
544 ret
= mxt_bootloader_read(data
, &val
, 1);
548 if (state
== MXT_WAITING_BOOTLOAD_CMD
)
549 val
= mxt_get_bootloader_version(data
, val
);
552 case MXT_WAITING_BOOTLOAD_CMD
:
553 case MXT_WAITING_FRAME_DATA
:
554 case MXT_APP_CRC_FAIL
:
555 val
&= ~MXT_BOOT_STATUS_MASK
;
557 case MXT_FRAME_CRC_PASS
:
558 if (val
== MXT_FRAME_CRC_CHECK
) {
560 } else if (val
== MXT_FRAME_CRC_FAIL
) {
561 dev_err(dev
, "Bootloader CRC fail\n");
570 dev_err(dev
, "Invalid bootloader state %02X != %02X\n",
578 static int mxt_send_bootloader_cmd(struct mxt_data
*data
, bool unlock
)
584 buf
[0] = MXT_UNLOCK_CMD_LSB
;
585 buf
[1] = MXT_UNLOCK_CMD_MSB
;
591 ret
= mxt_bootloader_write(data
, buf
, 2);
598 static int __mxt_read_reg(struct i2c_client
*client
,
599 u16 reg
, u16 len
, void *val
)
601 struct i2c_msg xfer
[2];
606 buf
[1] = (reg
>> 8) & 0xff;
609 xfer
[0].addr
= client
->addr
;
615 xfer
[1].addr
= client
->addr
;
616 xfer
[1].flags
= I2C_M_RD
;
620 ret
= i2c_transfer(client
->adapter
, xfer
, 2);
626 dev_err(&client
->dev
, "%s: i2c transfer failed (%d)\n",
633 static int __mxt_write_reg(struct i2c_client
*client
, u16 reg
, u16 len
,
641 buf
= kmalloc(count
, GFP_KERNEL
);
646 buf
[1] = (reg
>> 8) & 0xff;
647 memcpy(&buf
[2], val
, len
);
649 ret
= i2c_master_send(client
, buf
, count
);
655 dev_err(&client
->dev
, "%s: i2c send failed (%d)\n",
663 static int mxt_write_reg(struct i2c_client
*client
, u16 reg
, u8 val
)
665 return __mxt_write_reg(client
, reg
, 1, &val
);
668 static struct mxt_object
*
669 mxt_get_object(struct mxt_data
*data
, u8 type
)
671 struct mxt_object
*object
;
674 for (i
= 0; i
< data
->info
.object_num
; i
++) {
675 object
= data
->object_table
+ i
;
676 if (object
->type
== type
)
680 dev_warn(&data
->client
->dev
, "Invalid object type T%u\n", type
);
684 static void mxt_proc_t6_messages(struct mxt_data
*data
, u8
*msg
)
686 struct device
*dev
= &data
->client
->dev
;
688 u32 crc
= msg
[2] | (msg
[3] << 8) | (msg
[4] << 16);
690 complete(&data
->crc_completion
);
692 if (crc
!= data
->config_crc
) {
693 data
->config_crc
= crc
;
694 dev_dbg(dev
, "T6 Config Checksum: 0x%06X\n", crc
);
698 if (status
& MXT_T6_STATUS_RESET
)
699 complete(&data
->reset_completion
);
701 /* Output debug if status has changed */
702 if (status
!= data
->t6_status
)
703 dev_dbg(dev
, "T6 Status 0x%02X%s%s%s%s%s%s%s\n",
705 status
== 0 ? " OK" : "",
706 status
& MXT_T6_STATUS_RESET
? " RESET" : "",
707 status
& MXT_T6_STATUS_OFL
? " OFL" : "",
708 status
& MXT_T6_STATUS_SIGERR
? " SIGERR" : "",
709 status
& MXT_T6_STATUS_CAL
? " CAL" : "",
710 status
& MXT_T6_STATUS_CFGERR
? " CFGERR" : "",
711 status
& MXT_T6_STATUS_COMSERR
? " COMSERR" : "");
713 /* Save current status */
714 data
->t6_status
= status
;
717 static int mxt_write_object(struct mxt_data
*data
,
718 u8 type
, u8 offset
, u8 val
)
720 struct mxt_object
*object
;
723 object
= mxt_get_object(data
, type
);
724 if (!object
|| offset
>= mxt_obj_size(object
))
727 reg
= object
->start_address
;
728 return mxt_write_reg(data
->client
, reg
+ offset
, val
);
731 static void mxt_input_button(struct mxt_data
*data
, u8
*message
)
733 struct input_dev
*input
= data
->input_dev
;
734 const struct mxt_platform_data
*pdata
= data
->pdata
;
737 for (i
= 0; i
< pdata
->t19_num_keys
; i
++) {
738 if (pdata
->t19_keymap
[i
] == KEY_RESERVED
)
741 /* Active-low switch */
742 input_report_key(input
, pdata
->t19_keymap
[i
],
743 !(message
[1] & BIT(i
)));
747 static void mxt_input_sync(struct mxt_data
*data
)
749 input_mt_report_pointer_emulation(data
->input_dev
,
750 data
->pdata
->t19_num_keys
);
751 input_sync(data
->input_dev
);
754 static void mxt_proc_t9_message(struct mxt_data
*data
, u8
*message
)
756 struct device
*dev
= &data
->client
->dev
;
757 struct input_dev
*input_dev
= data
->input_dev
;
765 id
= message
[0] - data
->T9_reportid_min
;
767 x
= (message
[2] << 4) | ((message
[4] >> 4) & 0xf);
768 y
= (message
[3] << 4) | ((message
[4] & 0xf));
770 /* Handle 10/12 bit switching */
771 if (data
->max_x
< 1024)
773 if (data
->max_y
< 1024)
777 amplitude
= message
[6];
780 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
782 (status
& MXT_T9_DETECT
) ? 'D' : '.',
783 (status
& MXT_T9_PRESS
) ? 'P' : '.',
784 (status
& MXT_T9_RELEASE
) ? 'R' : '.',
785 (status
& MXT_T9_MOVE
) ? 'M' : '.',
786 (status
& MXT_T9_VECTOR
) ? 'V' : '.',
787 (status
& MXT_T9_AMP
) ? 'A' : '.',
788 (status
& MXT_T9_SUPPRESS
) ? 'S' : '.',
789 (status
& MXT_T9_UNGRIP
) ? 'U' : '.',
790 x
, y
, area
, amplitude
);
792 input_mt_slot(input_dev
, id
);
794 if (status
& MXT_T9_DETECT
) {
796 * Multiple bits may be set if the host is slow to read
797 * the status messages, indicating all the events that
800 if (status
& MXT_T9_RELEASE
) {
801 input_mt_report_slot_state(input_dev
,
803 mxt_input_sync(data
);
807 input_mt_report_slot_state(input_dev
, MT_TOOL_FINGER
, 1);
808 input_report_abs(input_dev
, ABS_MT_POSITION_X
, x
);
809 input_report_abs(input_dev
, ABS_MT_POSITION_Y
, y
);
810 input_report_abs(input_dev
, ABS_MT_PRESSURE
, amplitude
);
811 input_report_abs(input_dev
, ABS_MT_TOUCH_MAJOR
, area
);
813 /* Touch no longer active, close out slot */
814 input_mt_report_slot_state(input_dev
, MT_TOOL_FINGER
, 0);
817 data
->update_input
= true;
820 static void mxt_proc_t100_message(struct mxt_data
*data
, u8
*message
)
822 struct device
*dev
= &data
->client
->dev
;
823 struct input_dev
*input_dev
= data
->input_dev
;
835 id
= message
[0] - data
->T100_reportid_min
- 2;
837 /* ignore SCRSTATUS events */
842 x
= get_unaligned_le16(&message
[2]);
843 y
= get_unaligned_le16(&message
[4]);
845 if (status
& MXT_T100_DETECT
) {
846 type
= (status
& MXT_T100_TYPE_MASK
) >> 4;
849 case MXT_T100_TYPE_HOVERING_FINGER
:
850 tool
= MT_TOOL_FINGER
;
851 distance
= MXT_DISTANCE_HOVERING
;
853 if (data
->t100_aux_vect
)
854 orientation
= message
[data
->t100_aux_vect
];
858 case MXT_T100_TYPE_FINGER
:
859 case MXT_T100_TYPE_GLOVE
:
860 tool
= MT_TOOL_FINGER
;
861 distance
= MXT_DISTANCE_ACTIVE_TOUCH
;
863 if (data
->t100_aux_area
)
864 major
= message
[data
->t100_aux_area
];
866 if (data
->t100_aux_ampl
)
867 pressure
= message
[data
->t100_aux_ampl
];
869 if (data
->t100_aux_vect
)
870 orientation
= message
[data
->t100_aux_vect
];
874 case MXT_T100_TYPE_PASSIVE_STYLUS
:
878 * Passive stylus is reported with size zero so
881 major
= MXT_TOUCH_MAJOR_DEFAULT
;
883 if (data
->t100_aux_ampl
)
884 pressure
= message
[data
->t100_aux_ampl
];
888 case MXT_T100_TYPE_LARGE_TOUCH
:
889 /* Ignore suppressed touch */
893 dev_dbg(dev
, "Unexpected T100 type\n");
899 * Values reported should be non-zero if tool is touching the
902 if (!pressure
&& type
!= MXT_T100_TYPE_HOVERING_FINGER
)
903 pressure
= MXT_PRESSURE_DEFAULT
;
905 input_mt_slot(input_dev
, id
);
907 if (status
& MXT_T100_DETECT
) {
908 dev_dbg(dev
, "[%u] type:%u x:%u y:%u a:%02X p:%02X v:%02X\n",
909 id
, type
, x
, y
, major
, pressure
, orientation
);
911 input_mt_report_slot_state(input_dev
, tool
, 1);
912 input_report_abs(input_dev
, ABS_MT_POSITION_X
, x
);
913 input_report_abs(input_dev
, ABS_MT_POSITION_Y
, y
);
914 input_report_abs(input_dev
, ABS_MT_TOUCH_MAJOR
, major
);
915 input_report_abs(input_dev
, ABS_MT_PRESSURE
, pressure
);
916 input_report_abs(input_dev
, ABS_MT_DISTANCE
, distance
);
917 input_report_abs(input_dev
, ABS_MT_ORIENTATION
, orientation
);
919 dev_dbg(dev
, "[%u] release\n", id
);
922 input_mt_report_slot_state(input_dev
, 0, 0);
925 data
->update_input
= true;
928 static int mxt_proc_message(struct mxt_data
*data
, u8
*message
)
930 u8 report_id
= message
[0];
932 if (report_id
== MXT_RPTID_NOMSG
)
935 if (report_id
== data
->T6_reportid
) {
936 mxt_proc_t6_messages(data
, message
);
937 } else if (!data
->input_dev
) {
939 * Do not report events if input device
940 * is not yet registered.
942 mxt_dump_message(data
, message
);
943 } else if (report_id
>= data
->T9_reportid_min
&&
944 report_id
<= data
->T9_reportid_max
) {
945 mxt_proc_t9_message(data
, message
);
946 } else if (report_id
>= data
->T100_reportid_min
&&
947 report_id
<= data
->T100_reportid_max
) {
948 mxt_proc_t100_message(data
, message
);
949 } else if (report_id
== data
->T19_reportid
) {
950 mxt_input_button(data
, message
);
951 data
->update_input
= true;
953 mxt_dump_message(data
, message
);
959 static int mxt_read_and_process_messages(struct mxt_data
*data
, u8 count
)
961 struct device
*dev
= &data
->client
->dev
;
966 /* Safety check for msg_buf */
967 if (count
> data
->max_reportid
)
970 /* Process remaining messages if necessary */
971 ret
= __mxt_read_reg(data
->client
, data
->T5_address
,
972 data
->T5_msg_size
* count
, data
->msg_buf
);
974 dev_err(dev
, "Failed to read %u messages (%d)\n", count
, ret
);
978 for (i
= 0; i
< count
; i
++) {
979 ret
= mxt_proc_message(data
,
980 data
->msg_buf
+ data
->T5_msg_size
* i
);
986 /* return number of messages read */
990 static irqreturn_t
mxt_process_messages_t44(struct mxt_data
*data
)
992 struct device
*dev
= &data
->client
->dev
;
996 /* Read T44 and T5 together */
997 ret
= __mxt_read_reg(data
->client
, data
->T44_address
,
998 data
->T5_msg_size
+ 1, data
->msg_buf
);
1000 dev_err(dev
, "Failed to read T44 and T5 (%d)\n", ret
);
1004 count
= data
->msg_buf
[0];
1007 * This condition may be caused by the CHG line being configured in
1008 * Mode 0. It results in unnecessary I2C operations but it is benign.
1013 if (count
> data
->max_reportid
) {
1014 dev_warn(dev
, "T44 count %d exceeded max report id\n", count
);
1015 count
= data
->max_reportid
;
1018 /* Process first message */
1019 ret
= mxt_proc_message(data
, data
->msg_buf
+ 1);
1021 dev_warn(dev
, "Unexpected invalid message\n");
1025 num_left
= count
- 1;
1027 /* Process remaining messages if necessary */
1029 ret
= mxt_read_and_process_messages(data
, num_left
);
1032 else if (ret
!= num_left
)
1033 dev_warn(dev
, "Unexpected invalid message\n");
1037 if (data
->update_input
) {
1038 mxt_input_sync(data
);
1039 data
->update_input
= false;
1045 static int mxt_process_messages_until_invalid(struct mxt_data
*data
)
1047 struct device
*dev
= &data
->client
->dev
;
1051 count
= data
->max_reportid
;
1053 /* Read messages until we force an invalid */
1055 read
= mxt_read_and_process_messages(data
, count
);
1060 if (data
->update_input
) {
1061 mxt_input_sync(data
);
1062 data
->update_input
= false;
1065 dev_err(dev
, "CHG pin isn't cleared\n");
1069 static irqreturn_t
mxt_process_messages(struct mxt_data
*data
)
1071 int total_handled
, num_handled
;
1072 u8 count
= data
->last_message_count
;
1074 if (count
< 1 || count
> data
->max_reportid
)
1077 /* include final invalid message */
1078 total_handled
= mxt_read_and_process_messages(data
, count
+ 1);
1079 if (total_handled
< 0)
1081 /* if there were invalid messages, then we are done */
1082 else if (total_handled
<= count
)
1085 /* keep reading two msgs until one is invalid or reportid limit */
1087 num_handled
= mxt_read_and_process_messages(data
, 2);
1088 if (num_handled
< 0)
1091 total_handled
+= num_handled
;
1093 if (num_handled
< 2)
1095 } while (total_handled
< data
->num_touchids
);
1098 data
->last_message_count
= total_handled
;
1100 if (data
->update_input
) {
1101 mxt_input_sync(data
);
1102 data
->update_input
= false;
1108 static irqreturn_t
mxt_interrupt(int irq
, void *dev_id
)
1110 struct mxt_data
*data
= dev_id
;
1112 if (data
->in_bootloader
) {
1113 /* bootloader state transition completion */
1114 complete(&data
->bl_completion
);
1118 if (!data
->object_table
)
1121 if (data
->T44_address
) {
1122 return mxt_process_messages_t44(data
);
1124 return mxt_process_messages(data
);
1128 static int mxt_t6_command(struct mxt_data
*data
, u16 cmd_offset
,
1129 u8 value
, bool wait
)
1132 u8 command_register
;
1133 int timeout_counter
= 0;
1136 reg
= data
->T6_address
+ cmd_offset
;
1138 ret
= mxt_write_reg(data
->client
, reg
, value
);
1147 ret
= __mxt_read_reg(data
->client
, reg
, 1, &command_register
);
1150 } while (command_register
!= 0 && timeout_counter
++ <= 100);
1152 if (timeout_counter
> 100) {
1153 dev_err(&data
->client
->dev
, "Command failed!\n");
1160 static int mxt_acquire_irq(struct mxt_data
*data
)
1164 enable_irq(data
->irq
);
1166 error
= mxt_process_messages_until_invalid(data
);
1173 static int mxt_soft_reset(struct mxt_data
*data
)
1175 struct device
*dev
= &data
->client
->dev
;
1178 dev_info(dev
, "Resetting device\n");
1180 disable_irq(data
->irq
);
1182 reinit_completion(&data
->reset_completion
);
1184 ret
= mxt_t6_command(data
, MXT_COMMAND_RESET
, MXT_RESET_VALUE
, false);
1188 /* Ignore CHG line for 100ms after reset */
1191 mxt_acquire_irq(data
);
1193 ret
= mxt_wait_for_completion(data
, &data
->reset_completion
,
1201 static void mxt_update_crc(struct mxt_data
*data
, u8 cmd
, u8 value
)
1204 * On failure, CRC is set to 0 and config will always be
1207 data
->config_crc
= 0;
1208 reinit_completion(&data
->crc_completion
);
1210 mxt_t6_command(data
, cmd
, value
, true);
1213 * Wait for crc message. On failure, CRC is set to 0 and config will
1214 * always be downloaded.
1216 mxt_wait_for_completion(data
, &data
->crc_completion
, MXT_CRC_TIMEOUT
);
1219 static void mxt_calc_crc24(u32
*crc
, u8 firstbyte
, u8 secondbyte
)
1221 static const unsigned int crcpoly
= 0x80001B;
1225 data_word
= (secondbyte
<< 8) | firstbyte
;
1226 result
= ((*crc
<< 1) ^ data_word
);
1228 if (result
& 0x1000000)
1234 static u32
mxt_calculate_crc(u8
*base
, off_t start_off
, off_t end_off
)
1237 u8
*ptr
= base
+ start_off
;
1238 u8
*last_val
= base
+ end_off
- 1;
1240 if (end_off
< start_off
)
1243 while (ptr
< last_val
) {
1244 mxt_calc_crc24(&crc
, *ptr
, *(ptr
+ 1));
1248 /* if len is odd, fill the last byte with 0 */
1249 if (ptr
== last_val
)
1250 mxt_calc_crc24(&crc
, *ptr
, 0);
1252 /* Mask to 24-bit */
1258 static int mxt_prepare_cfg_mem(struct mxt_data
*data
,
1259 const struct firmware
*cfg
,
1260 unsigned int data_pos
,
1261 unsigned int cfg_start_ofs
,
1263 size_t config_mem_size
)
1265 struct device
*dev
= &data
->client
->dev
;
1266 struct mxt_object
*object
;
1267 unsigned int type
, instance
, size
, byte_offset
;
1274 while (data_pos
< cfg
->size
) {
1275 /* Read type, instance, length */
1276 ret
= sscanf(cfg
->data
+ data_pos
, "%x %x %x%n",
1277 &type
, &instance
, &size
, &offset
);
1281 } else if (ret
!= 3) {
1282 dev_err(dev
, "Bad format: failed to parse object\n");
1287 object
= mxt_get_object(data
, type
);
1290 for (i
= 0; i
< size
; i
++) {
1291 ret
= sscanf(cfg
->data
+ data_pos
, "%hhx%n",
1294 dev_err(dev
, "Bad format in T%d at %d\n",
1303 if (size
> mxt_obj_size(object
)) {
1305 * Either we are in fallback mode due to wrong
1306 * config or config from a later fw version,
1307 * or the file is corrupt or hand-edited.
1309 dev_warn(dev
, "Discarding %zu byte(s) in T%u\n",
1310 size
- mxt_obj_size(object
), type
);
1311 } else if (mxt_obj_size(object
) > size
) {
1313 * If firmware is upgraded, new bytes may be added to
1314 * end of objects. It is generally forward compatible
1315 * to zero these bytes - previous behaviour will be
1316 * retained. However this does invalidate the CRC and
1317 * will force fallback mode until the configuration is
1318 * updated. We warn here but do nothing else - the
1319 * malloc has zeroed the entire configuration.
1321 dev_warn(dev
, "Zeroing %zu byte(s) in T%d\n",
1322 mxt_obj_size(object
) - size
, type
);
1325 if (instance
>= mxt_obj_instances(object
)) {
1326 dev_err(dev
, "Object instances exceeded!\n");
1330 reg
= object
->start_address
+ mxt_obj_size(object
) * instance
;
1332 for (i
= 0; i
< size
; i
++) {
1333 ret
= sscanf(cfg
->data
+ data_pos
, "%hhx%n",
1337 dev_err(dev
, "Bad format in T%d at %d\n",
1343 if (i
> mxt_obj_size(object
))
1346 byte_offset
= reg
+ i
- cfg_start_ofs
;
1348 if (byte_offset
>= 0 && byte_offset
< config_mem_size
) {
1349 *(config_mem
+ byte_offset
) = val
;
1351 dev_err(dev
, "Bad object: reg:%d, T%d, ofs=%d\n",
1352 reg
, object
->type
, byte_offset
);
1361 static int mxt_upload_cfg_mem(struct mxt_data
*data
, unsigned int cfg_start
,
1362 u8
*config_mem
, size_t config_mem_size
)
1364 unsigned int byte_offset
= 0;
1367 /* Write configuration as blocks */
1368 while (byte_offset
< config_mem_size
) {
1369 unsigned int size
= config_mem_size
- byte_offset
;
1371 if (size
> MXT_MAX_BLOCK_WRITE
)
1372 size
= MXT_MAX_BLOCK_WRITE
;
1374 error
= __mxt_write_reg(data
->client
,
1375 cfg_start
+ byte_offset
,
1376 size
, config_mem
+ byte_offset
);
1378 dev_err(&data
->client
->dev
,
1379 "Config write error, ret=%d\n", error
);
1383 byte_offset
+= size
;
1389 static int mxt_init_t7_power_cfg(struct mxt_data
*data
);
1392 * mxt_update_cfg - download configuration to chip
1394 * Atmel Raw Config File Format
1396 * The first four lines of the raw config file contain:
1398 * 2) Chip ID Information (first 7 bytes of device memory)
1399 * 3) Chip Information Block 24-bit CRC Checksum
1400 * 4) Chip Configuration 24-bit CRC Checksum
1402 * The rest of the file consists of one line per object instance:
1403 * <TYPE> <INSTANCE> <SIZE> <CONTENTS>
1405 * <TYPE> - 2-byte object type as hex
1406 * <INSTANCE> - 2-byte object instance number as hex
1407 * <SIZE> - 2-byte object size as hex
1408 * <CONTENTS> - array of <SIZE> 1-byte hex values
1410 static int mxt_update_cfg(struct mxt_data
*data
, const struct firmware
*cfg
)
1412 struct device
*dev
= &data
->client
->dev
;
1413 struct mxt_info cfg_info
;
1419 u32 info_crc
, config_crc
, calculated_crc
;
1421 size_t config_mem_size
;
1423 mxt_update_crc(data
, MXT_COMMAND_REPORTALL
, 1);
1425 if (strncmp(cfg
->data
, MXT_CFG_MAGIC
, strlen(MXT_CFG_MAGIC
))) {
1426 dev_err(dev
, "Unrecognised config file\n");
1430 data_pos
= strlen(MXT_CFG_MAGIC
);
1432 /* Load information block and check */
1433 for (i
= 0; i
< sizeof(struct mxt_info
); i
++) {
1434 ret
= sscanf(cfg
->data
+ data_pos
, "%hhx%n",
1435 (unsigned char *)&cfg_info
+ i
,
1438 dev_err(dev
, "Bad format\n");
1445 if (cfg_info
.family_id
!= data
->info
.family_id
) {
1446 dev_err(dev
, "Family ID mismatch!\n");
1450 if (cfg_info
.variant_id
!= data
->info
.variant_id
) {
1451 dev_err(dev
, "Variant ID mismatch!\n");
1456 ret
= sscanf(cfg
->data
+ data_pos
, "%x%n", &info_crc
, &offset
);
1458 dev_err(dev
, "Bad format: failed to parse Info CRC\n");
1463 ret
= sscanf(cfg
->data
+ data_pos
, "%x%n", &config_crc
, &offset
);
1465 dev_err(dev
, "Bad format: failed to parse Config CRC\n");
1471 * The Info Block CRC is calculated over mxt_info and the object
1472 * table. If it does not match then we are trying to load the
1473 * configuration from a different chip or firmware version, so
1474 * the configuration CRC is invalid anyway.
1476 if (info_crc
== data
->info_crc
) {
1477 if (config_crc
== 0 || data
->config_crc
== 0) {
1478 dev_info(dev
, "CRC zero, attempting to apply config\n");
1479 } else if (config_crc
== data
->config_crc
) {
1480 dev_dbg(dev
, "Config CRC 0x%06X: OK\n",
1484 dev_info(dev
, "Config CRC 0x%06X: does not match file 0x%06X\n",
1485 data
->config_crc
, config_crc
);
1489 "Warning: Info CRC error - device=0x%06X file=0x%06X\n",
1490 data
->info_crc
, info_crc
);
1493 /* Malloc memory to store configuration */
1494 cfg_start_ofs
= MXT_OBJECT_START
+
1495 data
->info
.object_num
* sizeof(struct mxt_object
) +
1496 MXT_INFO_CHECKSUM_SIZE
;
1497 config_mem_size
= data
->mem_size
- cfg_start_ofs
;
1498 config_mem
= kzalloc(config_mem_size
, GFP_KERNEL
);
1500 dev_err(dev
, "Failed to allocate memory\n");
1504 ret
= mxt_prepare_cfg_mem(data
, cfg
, data_pos
, cfg_start_ofs
,
1505 config_mem
, config_mem_size
);
1509 /* Calculate crc of the received configs (not the raw config file) */
1510 if (data
->T7_address
< cfg_start_ofs
) {
1511 dev_err(dev
, "Bad T7 address, T7addr = %x, config offset %x\n",
1512 data
->T7_address
, cfg_start_ofs
);
1517 calculated_crc
= mxt_calculate_crc(config_mem
,
1518 data
->T7_address
- cfg_start_ofs
,
1521 if (config_crc
> 0 && config_crc
!= calculated_crc
)
1522 dev_warn(dev
, "Config CRC error, calculated=%06X, file=%06X\n",
1523 calculated_crc
, config_crc
);
1525 ret
= mxt_upload_cfg_mem(data
, cfg_start_ofs
,
1526 config_mem
, config_mem_size
);
1530 mxt_update_crc(data
, MXT_COMMAND_BACKUPNV
, MXT_BACKUP_VALUE
);
1532 ret
= mxt_soft_reset(data
);
1536 dev_info(dev
, "Config successfully updated\n");
1538 /* T7 config may have changed */
1539 mxt_init_t7_power_cfg(data
);
1546 static int mxt_get_info(struct mxt_data
*data
)
1548 struct i2c_client
*client
= data
->client
;
1549 struct mxt_info
*info
= &data
->info
;
1552 /* Read 7-byte info block starting at address 0 */
1553 error
= __mxt_read_reg(client
, 0, sizeof(*info
), info
);
1560 static void mxt_free_input_device(struct mxt_data
*data
)
1562 if (data
->input_dev
) {
1563 input_unregister_device(data
->input_dev
);
1564 data
->input_dev
= NULL
;
1568 static void mxt_free_object_table(struct mxt_data
*data
)
1570 #ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
1571 video_unregister_device(&data
->dbg
.vdev
);
1572 v4l2_device_unregister(&data
->dbg
.v4l2
);
1575 kfree(data
->object_table
);
1576 data
->object_table
= NULL
;
1577 kfree(data
->msg_buf
);
1578 data
->msg_buf
= NULL
;
1579 data
->T5_address
= 0;
1580 data
->T5_msg_size
= 0;
1581 data
->T6_reportid
= 0;
1582 data
->T7_address
= 0;
1583 data
->T9_reportid_min
= 0;
1584 data
->T9_reportid_max
= 0;
1585 data
->T19_reportid
= 0;
1586 data
->T44_address
= 0;
1587 data
->T100_reportid_min
= 0;
1588 data
->T100_reportid_max
= 0;
1589 data
->max_reportid
= 0;
1592 static int mxt_get_object_table(struct mxt_data
*data
)
1594 struct i2c_client
*client
= data
->client
;
1596 struct mxt_object
*object_table
;
1602 table_size
= data
->info
.object_num
* sizeof(struct mxt_object
);
1603 object_table
= kzalloc(table_size
, GFP_KERNEL
);
1604 if (!object_table
) {
1605 dev_err(&data
->client
->dev
, "Failed to allocate memory\n");
1609 error
= __mxt_read_reg(client
, MXT_OBJECT_START
, table_size
,
1612 kfree(object_table
);
1616 /* Valid Report IDs start counting from 1 */
1619 for (i
= 0; i
< data
->info
.object_num
; i
++) {
1620 struct mxt_object
*object
= object_table
+ i
;
1623 le16_to_cpus(&object
->start_address
);
1625 if (object
->num_report_ids
) {
1627 reportid
+= object
->num_report_ids
*
1628 mxt_obj_instances(object
);
1629 max_id
= reportid
- 1;
1635 dev_dbg(&data
->client
->dev
,
1636 "T%u Start:%u Size:%zu Instances:%zu Report IDs:%u-%u\n",
1637 object
->type
, object
->start_address
,
1638 mxt_obj_size(object
), mxt_obj_instances(object
),
1641 switch (object
->type
) {
1642 case MXT_GEN_MESSAGE_T5
:
1643 if (data
->info
.family_id
== 0x80 &&
1644 data
->info
.version
< 0x20) {
1646 * On mXT224 firmware versions prior to V2.0
1647 * read and discard unused CRC byte otherwise
1648 * DMA reads are misaligned.
1650 data
->T5_msg_size
= mxt_obj_size(object
);
1652 /* CRC not enabled, so skip last byte */
1653 data
->T5_msg_size
= mxt_obj_size(object
) - 1;
1655 data
->T5_address
= object
->start_address
;
1657 case MXT_GEN_COMMAND_T6
:
1658 data
->T6_reportid
= min_id
;
1659 data
->T6_address
= object
->start_address
;
1661 case MXT_GEN_POWER_T7
:
1662 data
->T7_address
= object
->start_address
;
1664 case MXT_TOUCH_MULTI_T9
:
1665 data
->multitouch
= MXT_TOUCH_MULTI_T9
;
1666 data
->T9_reportid_min
= min_id
;
1667 data
->T9_reportid_max
= max_id
;
1668 data
->num_touchids
= object
->num_report_ids
1669 * mxt_obj_instances(object
);
1671 case MXT_SPT_MESSAGECOUNT_T44
:
1672 data
->T44_address
= object
->start_address
;
1674 case MXT_SPT_GPIOPWM_T19
:
1675 data
->T19_reportid
= min_id
;
1677 case MXT_TOUCH_MULTITOUCHSCREEN_T100
:
1678 data
->multitouch
= MXT_TOUCH_MULTITOUCHSCREEN_T100
;
1679 data
->T100_reportid_min
= min_id
;
1680 data
->T100_reportid_max
= max_id
;
1681 /* first two report IDs reserved */
1682 data
->num_touchids
= object
->num_report_ids
- 2;
1686 end_address
= object
->start_address
1687 + mxt_obj_size(object
) * mxt_obj_instances(object
) - 1;
1689 if (end_address
>= data
->mem_size
)
1690 data
->mem_size
= end_address
+ 1;
1693 /* Store maximum reportid */
1694 data
->max_reportid
= reportid
;
1696 /* If T44 exists, T5 position has to be directly after */
1697 if (data
->T44_address
&& (data
->T5_address
!= data
->T44_address
+ 1)) {
1698 dev_err(&client
->dev
, "Invalid T44 position\n");
1700 goto free_object_table
;
1703 data
->msg_buf
= kcalloc(data
->max_reportid
,
1704 data
->T5_msg_size
, GFP_KERNEL
);
1705 if (!data
->msg_buf
) {
1706 dev_err(&client
->dev
, "Failed to allocate message buffer\n");
1708 goto free_object_table
;
1711 data
->object_table
= object_table
;
1716 mxt_free_object_table(data
);
1720 static int mxt_read_t9_resolution(struct mxt_data
*data
)
1722 struct i2c_client
*client
= data
->client
;
1724 struct t9_range range
;
1725 unsigned char orient
;
1726 struct mxt_object
*object
;
1728 object
= mxt_get_object(data
, MXT_TOUCH_MULTI_T9
);
1732 error
= __mxt_read_reg(client
,
1733 object
->start_address
+ MXT_T9_XSIZE
,
1734 sizeof(data
->xsize
), &data
->xsize
);
1738 error
= __mxt_read_reg(client
,
1739 object
->start_address
+ MXT_T9_YSIZE
,
1740 sizeof(data
->ysize
), &data
->ysize
);
1744 error
= __mxt_read_reg(client
,
1745 object
->start_address
+ MXT_T9_RANGE
,
1746 sizeof(range
), &range
);
1750 data
->max_x
= get_unaligned_le16(&range
.x
);
1751 data
->max_y
= get_unaligned_le16(&range
.y
);
1753 error
= __mxt_read_reg(client
,
1754 object
->start_address
+ MXT_T9_ORIENT
,
1759 data
->xy_switch
= orient
& MXT_T9_ORIENT_SWITCH
;
1760 data
->invertx
= orient
& MXT_T9_ORIENT_INVERTX
;
1761 data
->inverty
= orient
& MXT_T9_ORIENT_INVERTY
;
1766 static int mxt_read_t100_config(struct mxt_data
*data
)
1768 struct i2c_client
*client
= data
->client
;
1770 struct mxt_object
*object
;
1771 u16 range_x
, range_y
;
1775 object
= mxt_get_object(data
, MXT_TOUCH_MULTITOUCHSCREEN_T100
);
1779 /* read touchscreen dimensions */
1780 error
= __mxt_read_reg(client
,
1781 object
->start_address
+ MXT_T100_XRANGE
,
1782 sizeof(range_x
), &range_x
);
1786 data
->max_x
= get_unaligned_le16(&range_x
);
1788 error
= __mxt_read_reg(client
,
1789 object
->start_address
+ MXT_T100_YRANGE
,
1790 sizeof(range_y
), &range_y
);
1794 data
->max_y
= get_unaligned_le16(&range_y
);
1796 error
= __mxt_read_reg(client
,
1797 object
->start_address
+ MXT_T100_XSIZE
,
1798 sizeof(data
->xsize
), &data
->xsize
);
1802 error
= __mxt_read_reg(client
,
1803 object
->start_address
+ MXT_T100_YSIZE
,
1804 sizeof(data
->ysize
), &data
->ysize
);
1808 /* read orientation config */
1809 error
= __mxt_read_reg(client
,
1810 object
->start_address
+ MXT_T100_CFG1
,
1815 data
->xy_switch
= cfg
& MXT_T100_CFG_SWITCHXY
;
1816 data
->invertx
= cfg
& MXT_T100_CFG_INVERTX
;
1817 data
->inverty
= cfg
& MXT_T100_CFG_INVERTY
;
1819 /* allocate aux bytes */
1820 error
= __mxt_read_reg(client
,
1821 object
->start_address
+ MXT_T100_TCHAUX
,
1828 if (tchaux
& MXT_T100_TCHAUX_VECT
)
1829 data
->t100_aux_vect
= aux
++;
1831 if (tchaux
& MXT_T100_TCHAUX_AMPL
)
1832 data
->t100_aux_ampl
= aux
++;
1834 if (tchaux
& MXT_T100_TCHAUX_AREA
)
1835 data
->t100_aux_area
= aux
++;
1837 dev_dbg(&client
->dev
,
1838 "T100 aux mappings vect:%u ampl:%u area:%u\n",
1839 data
->t100_aux_vect
, data
->t100_aux_ampl
, data
->t100_aux_area
);
1844 static int mxt_input_open(struct input_dev
*dev
);
1845 static void mxt_input_close(struct input_dev
*dev
);
1847 static void mxt_set_up_as_touchpad(struct input_dev
*input_dev
,
1848 struct mxt_data
*data
)
1850 const struct mxt_platform_data
*pdata
= data
->pdata
;
1853 input_dev
->name
= "Atmel maXTouch Touchpad";
1855 __set_bit(INPUT_PROP_BUTTONPAD
, input_dev
->propbit
);
1857 input_abs_set_res(input_dev
, ABS_X
, MXT_PIXELS_PER_MM
);
1858 input_abs_set_res(input_dev
, ABS_Y
, MXT_PIXELS_PER_MM
);
1859 input_abs_set_res(input_dev
, ABS_MT_POSITION_X
,
1861 input_abs_set_res(input_dev
, ABS_MT_POSITION_Y
,
1864 for (i
= 0; i
< pdata
->t19_num_keys
; i
++)
1865 if (pdata
->t19_keymap
[i
] != KEY_RESERVED
)
1866 input_set_capability(input_dev
, EV_KEY
,
1867 pdata
->t19_keymap
[i
]);
1870 static int mxt_initialize_input_device(struct mxt_data
*data
)
1872 const struct mxt_platform_data
*pdata
= data
->pdata
;
1873 struct device
*dev
= &data
->client
->dev
;
1874 struct input_dev
*input_dev
;
1876 unsigned int num_mt_slots
;
1877 unsigned int mt_flags
= 0;
1879 switch (data
->multitouch
) {
1880 case MXT_TOUCH_MULTI_T9
:
1881 num_mt_slots
= data
->T9_reportid_max
- data
->T9_reportid_min
+ 1;
1882 error
= mxt_read_t9_resolution(data
);
1884 dev_warn(dev
, "Failed to initialize T9 resolution\n");
1887 case MXT_TOUCH_MULTITOUCHSCREEN_T100
:
1888 num_mt_slots
= data
->num_touchids
;
1889 error
= mxt_read_t100_config(data
);
1891 dev_warn(dev
, "Failed to read T100 config\n");
1895 dev_err(dev
, "Invalid multitouch object\n");
1899 /* Handle default values and orientation switch */
1900 if (data
->max_x
== 0)
1903 if (data
->max_y
== 0)
1906 if (data
->xy_switch
)
1907 swap(data
->max_x
, data
->max_y
);
1909 dev_info(dev
, "Touchscreen size X%uY%u\n", data
->max_x
, data
->max_y
);
1911 /* Register input device */
1912 input_dev
= input_allocate_device();
1914 dev_err(dev
, "Failed to allocate memory\n");
1918 input_dev
->name
= "Atmel maXTouch Touchscreen";
1919 input_dev
->phys
= data
->phys
;
1920 input_dev
->id
.bustype
= BUS_I2C
;
1921 input_dev
->dev
.parent
= dev
;
1922 input_dev
->open
= mxt_input_open
;
1923 input_dev
->close
= mxt_input_close
;
1925 input_set_capability(input_dev
, EV_KEY
, BTN_TOUCH
);
1927 /* For single touch */
1928 input_set_abs_params(input_dev
, ABS_X
, 0, data
->max_x
, 0, 0);
1929 input_set_abs_params(input_dev
, ABS_Y
, 0, data
->max_y
, 0, 0);
1931 if (data
->multitouch
== MXT_TOUCH_MULTI_T9
||
1932 (data
->multitouch
== MXT_TOUCH_MULTITOUCHSCREEN_T100
&&
1933 data
->t100_aux_ampl
)) {
1934 input_set_abs_params(input_dev
, ABS_PRESSURE
, 0, 255, 0, 0);
1937 /* If device has buttons we assume it is a touchpad */
1938 if (pdata
->t19_num_keys
) {
1939 mxt_set_up_as_touchpad(input_dev
, data
);
1940 mt_flags
|= INPUT_MT_POINTER
;
1942 mt_flags
|= INPUT_MT_DIRECT
;
1945 /* For multi touch */
1946 error
= input_mt_init_slots(input_dev
, num_mt_slots
, mt_flags
);
1948 dev_err(dev
, "Error %d initialising slots\n", error
);
1952 if (data
->multitouch
== MXT_TOUCH_MULTITOUCHSCREEN_T100
) {
1953 input_set_abs_params(input_dev
, ABS_MT_TOOL_TYPE
,
1954 0, MT_TOOL_MAX
, 0, 0);
1955 input_set_abs_params(input_dev
, ABS_MT_DISTANCE
,
1956 MXT_DISTANCE_ACTIVE_TOUCH
,
1957 MXT_DISTANCE_HOVERING
,
1961 input_set_abs_params(input_dev
, ABS_MT_POSITION_X
,
1962 0, data
->max_x
, 0, 0);
1963 input_set_abs_params(input_dev
, ABS_MT_POSITION_Y
,
1964 0, data
->max_y
, 0, 0);
1966 if (data
->multitouch
== MXT_TOUCH_MULTI_T9
||
1967 (data
->multitouch
== MXT_TOUCH_MULTITOUCHSCREEN_T100
&&
1968 data
->t100_aux_area
)) {
1969 input_set_abs_params(input_dev
, ABS_MT_TOUCH_MAJOR
,
1970 0, MXT_MAX_AREA
, 0, 0);
1973 if (data
->multitouch
== MXT_TOUCH_MULTI_T9
||
1974 (data
->multitouch
== MXT_TOUCH_MULTITOUCHSCREEN_T100
&&
1975 data
->t100_aux_ampl
)) {
1976 input_set_abs_params(input_dev
, ABS_MT_PRESSURE
,
1980 if (data
->multitouch
== MXT_TOUCH_MULTITOUCHSCREEN_T100
&&
1981 data
->t100_aux_vect
) {
1982 input_set_abs_params(input_dev
, ABS_MT_ORIENTATION
,
1986 if (data
->multitouch
== MXT_TOUCH_MULTITOUCHSCREEN_T100
&&
1987 data
->t100_aux_ampl
) {
1988 input_set_abs_params(input_dev
, ABS_MT_PRESSURE
,
1992 if (data
->multitouch
== MXT_TOUCH_MULTITOUCHSCREEN_T100
&&
1993 data
->t100_aux_vect
) {
1994 input_set_abs_params(input_dev
, ABS_MT_ORIENTATION
,
1998 input_set_drvdata(input_dev
, data
);
2000 error
= input_register_device(input_dev
);
2002 dev_err(dev
, "Error %d registering input device\n", error
);
2006 data
->input_dev
= input_dev
;
2011 input_free_device(input_dev
);
2015 static int mxt_configure_objects(struct mxt_data
*data
,
2016 const struct firmware
*cfg
);
2018 static void mxt_config_cb(const struct firmware
*cfg
, void *ctx
)
2020 mxt_configure_objects(ctx
, cfg
);
2021 release_firmware(cfg
);
2024 static int mxt_initialize(struct mxt_data
*data
)
2026 struct i2c_client
*client
= data
->client
;
2027 int recovery_attempts
= 0;
2031 error
= mxt_get_info(data
);
2035 /* Check bootloader state */
2036 error
= mxt_probe_bootloader(data
, false);
2038 dev_info(&client
->dev
, "Trying alternate bootloader address\n");
2039 error
= mxt_probe_bootloader(data
, true);
2041 /* Chip is not in appmode or bootloader mode */
2046 /* OK, we are in bootloader, see if we can recover */
2047 if (++recovery_attempts
> 1) {
2048 dev_err(&client
->dev
, "Could not recover from bootloader mode\n");
2050 * We can reflash from this state, so do not
2051 * abort initialization.
2053 data
->in_bootloader
= true;
2057 /* Attempt to exit bootloader into app mode */
2058 mxt_send_bootloader_cmd(data
, false);
2059 msleep(MXT_FW_RESET_TIME
);
2062 /* Get object table information */
2063 error
= mxt_get_object_table(data
);
2065 dev_err(&client
->dev
, "Error %d reading object table\n", error
);
2069 error
= mxt_acquire_irq(data
);
2071 goto err_free_object_table
;
2073 error
= request_firmware_nowait(THIS_MODULE
, true, MXT_CFG_NAME
,
2074 &client
->dev
, GFP_KERNEL
, data
,
2077 dev_err(&client
->dev
, "Failed to invoke firmware loader: %d\n",
2079 goto err_free_object_table
;
2084 err_free_object_table
:
2085 mxt_free_object_table(data
);
2089 static int mxt_set_t7_power_cfg(struct mxt_data
*data
, u8 sleep
)
2091 struct device
*dev
= &data
->client
->dev
;
2093 struct t7_config
*new_config
;
2094 struct t7_config deepsleep
= { .active
= 0, .idle
= 0 };
2096 if (sleep
== MXT_POWER_CFG_DEEPSLEEP
)
2097 new_config
= &deepsleep
;
2099 new_config
= &data
->t7_cfg
;
2101 error
= __mxt_write_reg(data
->client
, data
->T7_address
,
2102 sizeof(data
->t7_cfg
), new_config
);
2106 dev_dbg(dev
, "Set T7 ACTV:%d IDLE:%d\n",
2107 new_config
->active
, new_config
->idle
);
2112 static int mxt_init_t7_power_cfg(struct mxt_data
*data
)
2114 struct device
*dev
= &data
->client
->dev
;
2119 error
= __mxt_read_reg(data
->client
, data
->T7_address
,
2120 sizeof(data
->t7_cfg
), &data
->t7_cfg
);
2124 if (data
->t7_cfg
.active
== 0 || data
->t7_cfg
.idle
== 0) {
2126 dev_dbg(dev
, "T7 cfg zero, resetting\n");
2127 mxt_soft_reset(data
);
2131 dev_dbg(dev
, "T7 cfg zero after reset, overriding\n");
2132 data
->t7_cfg
.active
= 20;
2133 data
->t7_cfg
.idle
= 100;
2134 return mxt_set_t7_power_cfg(data
, MXT_POWER_CFG_RUN
);
2138 dev_dbg(dev
, "Initialized power cfg: ACTV %d, IDLE %d\n",
2139 data
->t7_cfg
.active
, data
->t7_cfg
.idle
);
2143 #ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
2144 static u16
mxt_get_debug_value(struct mxt_data
*data
, unsigned int x
,
2147 struct mxt_info
*info
= &data
->info
;
2148 struct mxt_dbg
*dbg
= &data
->dbg
;
2149 unsigned int ofs
, page
;
2150 unsigned int col
= 0;
2151 unsigned int col_width
;
2153 if (info
->family_id
== MXT_FAMILY_1386
) {
2154 col_width
= info
->matrix_ysize
/ MXT1386_COLUMNS
;
2155 col
= y
/ col_width
;
2158 col_width
= info
->matrix_ysize
;
2161 ofs
= (y
+ (x
* col_width
)) * sizeof(u16
);
2162 page
= ofs
/ MXT_DIAGNOSTIC_SIZE
;
2163 ofs
%= MXT_DIAGNOSTIC_SIZE
;
2165 if (info
->family_id
== MXT_FAMILY_1386
)
2166 page
+= col
* MXT1386_PAGES_PER_COLUMN
;
2168 return get_unaligned_le16(&dbg
->t37_buf
[page
].data
[ofs
]);
2171 static int mxt_convert_debug_pages(struct mxt_data
*data
, u16
*outbuf
)
2173 struct mxt_dbg
*dbg
= &data
->dbg
;
2176 unsigned int i
, rx
, ry
;
2178 for (i
= 0; i
< dbg
->t37_nodes
; i
++) {
2179 /* Handle orientation */
2180 rx
= data
->xy_switch
? y
: x
;
2181 ry
= data
->xy_switch
? x
: y
;
2182 rx
= data
->invertx
? (data
->xsize
- 1 - rx
) : rx
;
2183 ry
= data
->inverty
? (data
->ysize
- 1 - ry
) : ry
;
2185 outbuf
[i
] = mxt_get_debug_value(data
, rx
, ry
);
2188 if (++x
>= (data
->xy_switch
? data
->ysize
: data
->xsize
)) {
2197 static int mxt_read_diagnostic_debug(struct mxt_data
*data
, u8 mode
,
2200 struct mxt_dbg
*dbg
= &data
->dbg
;
2205 struct t37_debug
*p
;
2208 for (page
= 0; page
< dbg
->t37_pages
; page
++) {
2209 p
= dbg
->t37_buf
+ page
;
2211 ret
= mxt_write_reg(data
->client
, dbg
->diag_cmd_address
,
2219 /* Read back command byte */
2220 ret
= __mxt_read_reg(data
->client
, dbg
->diag_cmd_address
,
2221 sizeof(cmd_poll
), &cmd_poll
);
2225 /* Field is cleared once the command has been processed */
2227 if (retries
++ > 100)
2235 ret
= __mxt_read_reg(data
->client
, dbg
->t37_address
,
2236 sizeof(struct t37_debug
), p
);
2240 if (p
->mode
!= mode
|| p
->page
!= page
) {
2241 dev_err(&data
->client
->dev
, "T37 page mismatch\n");
2245 dev_dbg(&data
->client
->dev
, "%s page:%d retries:%d\n",
2246 __func__
, page
, retries
);
2248 /* For remaining pages, write PAGEUP rather than mode */
2249 cmd
= MXT_DIAGNOSTIC_PAGEUP
;
2252 return mxt_convert_debug_pages(data
, outbuf
);
2255 static int mxt_queue_setup(struct vb2_queue
*q
,
2256 unsigned int *nbuffers
, unsigned int *nplanes
,
2257 unsigned int sizes
[], struct device
*alloc_devs
[])
2259 struct mxt_data
*data
= q
->drv_priv
;
2260 size_t size
= data
->dbg
.t37_nodes
* sizeof(u16
);
2263 return sizes
[0] < size
? -EINVAL
: 0;
2271 static void mxt_buffer_queue(struct vb2_buffer
*vb
)
2273 struct mxt_data
*data
= vb2_get_drv_priv(vb
->vb2_queue
);
2277 ptr
= vb2_plane_vaddr(vb
, 0);
2279 dev_err(&data
->client
->dev
, "Error acquiring frame ptr\n");
2283 ret
= mxt_read_diagnostic_debug(data
, MXT_DIAGNOSTIC_DELTAS
, ptr
);
2287 vb2_set_plane_payload(vb
, 0, data
->dbg
.t37_nodes
* sizeof(u16
));
2288 vb2_buffer_done(vb
, VB2_BUF_STATE_DONE
);
2292 vb2_buffer_done(vb
, VB2_BUF_STATE_ERROR
);
2295 /* V4L2 structures */
2296 static const struct vb2_ops mxt_queue_ops
= {
2297 .queue_setup
= mxt_queue_setup
,
2298 .buf_queue
= mxt_buffer_queue
,
2299 .wait_prepare
= vb2_ops_wait_prepare
,
2300 .wait_finish
= vb2_ops_wait_finish
,
2303 static const struct vb2_queue mxt_queue
= {
2304 .type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
,
2305 .io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
| VB2_READ
,
2306 .buf_struct_size
= sizeof(struct mxt_vb2_buffer
),
2307 .ops
= &mxt_queue_ops
,
2308 .mem_ops
= &vb2_vmalloc_memops
,
2309 .timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
,
2310 .min_buffers_needed
= 1,
2313 static int mxt_vidioc_querycap(struct file
*file
, void *priv
,
2314 struct v4l2_capability
*cap
)
2316 struct mxt_data
*data
= video_drvdata(file
);
2318 strlcpy(cap
->driver
, "atmel_mxt_ts", sizeof(cap
->driver
));
2319 strlcpy(cap
->card
, "atmel_mxt_ts touch", sizeof(cap
->card
));
2320 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
),
2321 "I2C:%s", dev_name(&data
->client
->dev
));
2325 static int mxt_vidioc_enum_input(struct file
*file
, void *priv
,
2326 struct v4l2_input
*i
)
2331 i
->type
= V4L2_INPUT_TYPE_TOUCH
;
2332 strlcpy(i
->name
, "Mutual Capacitance Deltas", sizeof(i
->name
));
2336 static int mxt_set_input(struct mxt_data
*data
, unsigned int i
)
2338 struct v4l2_pix_format
*f
= &data
->dbg
.format
;
2343 f
->width
= data
->xy_switch
? data
->ysize
: data
->xsize
;
2344 f
->height
= data
->xy_switch
? data
->xsize
: data
->ysize
;
2345 f
->pixelformat
= V4L2_TCH_FMT_DELTA_TD16
;
2346 f
->field
= V4L2_FIELD_NONE
;
2347 f
->colorspace
= V4L2_COLORSPACE_RAW
;
2348 f
->bytesperline
= f
->width
* sizeof(u16
);
2349 f
->sizeimage
= f
->width
* f
->height
* sizeof(u16
);
2351 data
->dbg
.input
= i
;
2356 static int mxt_vidioc_s_input(struct file
*file
, void *priv
, unsigned int i
)
2358 return mxt_set_input(video_drvdata(file
), i
);
2361 static int mxt_vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
2363 struct mxt_data
*data
= video_drvdata(file
);
2365 *i
= data
->dbg
.input
;
2370 static int mxt_vidioc_fmt(struct file
*file
, void *priv
, struct v4l2_format
*f
)
2372 struct mxt_data
*data
= video_drvdata(file
);
2374 f
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2375 f
->fmt
.pix
= data
->dbg
.format
;
2380 static int mxt_vidioc_enum_fmt(struct file
*file
, void *priv
,
2381 struct v4l2_fmtdesc
*fmt
)
2383 if (fmt
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
2386 fmt
->pixelformat
= V4L2_TCH_FMT_DELTA_TD16
;
2390 static int mxt_vidioc_g_parm(struct file
*file
, void *fh
,
2391 struct v4l2_streamparm
*a
)
2393 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
2396 a
->parm
.capture
.readbuffers
= 1;
2397 a
->parm
.capture
.timeperframe
.numerator
= 1;
2398 a
->parm
.capture
.timeperframe
.denominator
= 10;
2402 static const struct v4l2_ioctl_ops mxt_video_ioctl_ops
= {
2403 .vidioc_querycap
= mxt_vidioc_querycap
,
2405 .vidioc_enum_fmt_vid_cap
= mxt_vidioc_enum_fmt
,
2406 .vidioc_s_fmt_vid_cap
= mxt_vidioc_fmt
,
2407 .vidioc_g_fmt_vid_cap
= mxt_vidioc_fmt
,
2408 .vidioc_try_fmt_vid_cap
= mxt_vidioc_fmt
,
2409 .vidioc_g_parm
= mxt_vidioc_g_parm
,
2411 .vidioc_enum_input
= mxt_vidioc_enum_input
,
2412 .vidioc_g_input
= mxt_vidioc_g_input
,
2413 .vidioc_s_input
= mxt_vidioc_s_input
,
2415 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
2416 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
2417 .vidioc_querybuf
= vb2_ioctl_querybuf
,
2418 .vidioc_qbuf
= vb2_ioctl_qbuf
,
2419 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
2420 .vidioc_expbuf
= vb2_ioctl_expbuf
,
2422 .vidioc_streamon
= vb2_ioctl_streamon
,
2423 .vidioc_streamoff
= vb2_ioctl_streamoff
,
2426 static const struct video_device mxt_video_device
= {
2427 .name
= "Atmel maxTouch",
2428 .fops
= &mxt_video_fops
,
2429 .ioctl_ops
= &mxt_video_ioctl_ops
,
2430 .release
= video_device_release_empty
,
2431 .device_caps
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_TOUCH
|
2432 V4L2_CAP_READWRITE
| V4L2_CAP_STREAMING
,
2435 static void mxt_debug_init(struct mxt_data
*data
)
2437 struct mxt_info
*info
= &data
->info
;
2438 struct mxt_dbg
*dbg
= &data
->dbg
;
2439 struct mxt_object
*object
;
2442 object
= mxt_get_object(data
, MXT_GEN_COMMAND_T6
);
2446 dbg
->diag_cmd_address
= object
->start_address
+ MXT_COMMAND_DIAGNOSTIC
;
2448 object
= mxt_get_object(data
, MXT_DEBUG_DIAGNOSTIC_T37
);
2452 if (mxt_obj_size(object
) != sizeof(struct t37_debug
)) {
2453 dev_warn(&data
->client
->dev
, "Bad T37 size");
2457 dbg
->t37_address
= object
->start_address
;
2459 /* Calculate size of data and allocate buffer */
2460 dbg
->t37_nodes
= data
->xsize
* data
->ysize
;
2462 if (info
->family_id
== MXT_FAMILY_1386
)
2463 dbg
->t37_pages
= MXT1386_COLUMNS
* MXT1386_PAGES_PER_COLUMN
;
2465 dbg
->t37_pages
= DIV_ROUND_UP(data
->xsize
*
2466 data
->info
.matrix_ysize
*
2468 sizeof(dbg
->t37_buf
->data
));
2470 dbg
->t37_buf
= devm_kmalloc_array(&data
->client
->dev
, dbg
->t37_pages
,
2471 sizeof(struct t37_debug
), GFP_KERNEL
);
2475 /* init channel to zero */
2476 mxt_set_input(data
, 0);
2478 /* register video device */
2479 snprintf(dbg
->v4l2
.name
, sizeof(dbg
->v4l2
.name
), "%s", "atmel_mxt_ts");
2480 error
= v4l2_device_register(&data
->client
->dev
, &dbg
->v4l2
);
2484 /* initialize the queue */
2485 mutex_init(&dbg
->lock
);
2486 dbg
->queue
= mxt_queue
;
2487 dbg
->queue
.drv_priv
= data
;
2488 dbg
->queue
.lock
= &dbg
->lock
;
2489 dbg
->queue
.dev
= &data
->client
->dev
;
2491 error
= vb2_queue_init(&dbg
->queue
);
2493 goto error_unreg_v4l2
;
2495 dbg
->vdev
= mxt_video_device
;
2496 dbg
->vdev
.v4l2_dev
= &dbg
->v4l2
;
2497 dbg
->vdev
.lock
= &dbg
->lock
;
2498 dbg
->vdev
.vfl_dir
= VFL_DIR_RX
;
2499 dbg
->vdev
.queue
= &dbg
->queue
;
2500 video_set_drvdata(&dbg
->vdev
, data
);
2502 error
= video_register_device(&dbg
->vdev
, VFL_TYPE_TOUCH
, -1);
2504 goto error_unreg_v4l2
;
2509 v4l2_device_unregister(&dbg
->v4l2
);
2511 dev_warn(&data
->client
->dev
, "Error initializing T37\n");
2514 static void mxt_debug_init(struct mxt_data
*data
)
2519 static int mxt_configure_objects(struct mxt_data
*data
,
2520 const struct firmware
*cfg
)
2522 struct device
*dev
= &data
->client
->dev
;
2523 struct mxt_info
*info
= &data
->info
;
2526 error
= mxt_init_t7_power_cfg(data
);
2528 dev_err(dev
, "Failed to initialize power cfg\n");
2533 error
= mxt_update_cfg(data
, cfg
);
2535 dev_warn(dev
, "Error %d updating config\n", error
);
2538 if (data
->multitouch
) {
2539 error
= mxt_initialize_input_device(data
);
2543 dev_warn(dev
, "No touch object detected\n");
2546 mxt_debug_init(data
);
2549 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
2550 info
->family_id
, info
->variant_id
, info
->version
>> 4,
2551 info
->version
& 0xf, info
->build
, info
->object_num
);
2556 /* Firmware Version is returned as Major.Minor.Build */
2557 static ssize_t
mxt_fw_version_show(struct device
*dev
,
2558 struct device_attribute
*attr
, char *buf
)
2560 struct mxt_data
*data
= dev_get_drvdata(dev
);
2561 struct mxt_info
*info
= &data
->info
;
2562 return scnprintf(buf
, PAGE_SIZE
, "%u.%u.%02X\n",
2563 info
->version
>> 4, info
->version
& 0xf, info
->build
);
2566 /* Hardware Version is returned as FamilyID.VariantID */
2567 static ssize_t
mxt_hw_version_show(struct device
*dev
,
2568 struct device_attribute
*attr
, char *buf
)
2570 struct mxt_data
*data
= dev_get_drvdata(dev
);
2571 struct mxt_info
*info
= &data
->info
;
2572 return scnprintf(buf
, PAGE_SIZE
, "%u.%u\n",
2573 info
->family_id
, info
->variant_id
);
2576 static ssize_t
mxt_show_instance(char *buf
, int count
,
2577 struct mxt_object
*object
, int instance
,
2582 if (mxt_obj_instances(object
) > 1)
2583 count
+= scnprintf(buf
+ count
, PAGE_SIZE
- count
,
2584 "Instance %u\n", instance
);
2586 for (i
= 0; i
< mxt_obj_size(object
); i
++)
2587 count
+= scnprintf(buf
+ count
, PAGE_SIZE
- count
,
2588 "\t[%2u]: %02x (%d)\n", i
, val
[i
], val
[i
]);
2589 count
+= scnprintf(buf
+ count
, PAGE_SIZE
- count
, "\n");
2594 static ssize_t
mxt_object_show(struct device
*dev
,
2595 struct device_attribute
*attr
, char *buf
)
2597 struct mxt_data
*data
= dev_get_drvdata(dev
);
2598 struct mxt_object
*object
;
2604 /* Pre-allocate buffer large enough to hold max sized object. */
2605 obuf
= kmalloc(256, GFP_KERNEL
);
2610 for (i
= 0; i
< data
->info
.object_num
; i
++) {
2611 object
= data
->object_table
+ i
;
2613 if (!mxt_object_readable(object
->type
))
2616 count
+= scnprintf(buf
+ count
, PAGE_SIZE
- count
,
2617 "T%u:\n", object
->type
);
2619 for (j
= 0; j
< mxt_obj_instances(object
); j
++) {
2620 u16 size
= mxt_obj_size(object
);
2621 u16 addr
= object
->start_address
+ j
* size
;
2623 error
= __mxt_read_reg(data
->client
, addr
, size
, obuf
);
2627 count
= mxt_show_instance(buf
, count
, object
, j
, obuf
);
2633 return error
?: count
;
2636 static int mxt_check_firmware_format(struct device
*dev
,
2637 const struct firmware
*fw
)
2639 unsigned int pos
= 0;
2642 while (pos
< fw
->size
) {
2643 c
= *(fw
->data
+ pos
);
2645 if (c
< '0' || (c
> '9' && c
< 'A') || c
> 'F')
2652 * To convert file try:
2653 * xxd -r -p mXTXXX__APP_VX-X-XX.enc > maxtouch.fw
2655 dev_err(dev
, "Aborting: firmware file must be in binary format\n");
2660 static int mxt_load_fw(struct device
*dev
, const char *fn
)
2662 struct mxt_data
*data
= dev_get_drvdata(dev
);
2663 const struct firmware
*fw
= NULL
;
2664 unsigned int frame_size
;
2665 unsigned int pos
= 0;
2666 unsigned int retry
= 0;
2667 unsigned int frame
= 0;
2670 ret
= request_firmware(&fw
, fn
, dev
);
2672 dev_err(dev
, "Unable to open firmware %s\n", fn
);
2676 /* Check for incorrect enc file */
2677 ret
= mxt_check_firmware_format(dev
, fw
);
2679 goto release_firmware
;
2681 if (!data
->in_bootloader
) {
2682 /* Change to the bootloader mode */
2683 data
->in_bootloader
= true;
2685 ret
= mxt_t6_command(data
, MXT_COMMAND_RESET
,
2686 MXT_BOOT_VALUE
, false);
2688 goto release_firmware
;
2690 msleep(MXT_RESET_TIME
);
2692 /* Do not need to scan since we know family ID */
2693 ret
= mxt_lookup_bootloader_address(data
, 0);
2695 goto release_firmware
;
2697 mxt_free_input_device(data
);
2698 mxt_free_object_table(data
);
2700 enable_irq(data
->irq
);
2703 reinit_completion(&data
->bl_completion
);
2705 ret
= mxt_check_bootloader(data
, MXT_WAITING_BOOTLOAD_CMD
, false);
2707 /* Bootloader may still be unlocked from previous attempt */
2708 ret
= mxt_check_bootloader(data
, MXT_WAITING_FRAME_DATA
, false);
2712 dev_info(dev
, "Unlocking bootloader\n");
2714 /* Unlock bootloader */
2715 ret
= mxt_send_bootloader_cmd(data
, true);
2720 while (pos
< fw
->size
) {
2721 ret
= mxt_check_bootloader(data
, MXT_WAITING_FRAME_DATA
, true);
2725 frame_size
= ((*(fw
->data
+ pos
) << 8) | *(fw
->data
+ pos
+ 1));
2727 /* Take account of CRC bytes */
2730 /* Write one frame to device */
2731 ret
= mxt_bootloader_write(data
, fw
->data
+ pos
, frame_size
);
2735 ret
= mxt_check_bootloader(data
, MXT_FRAME_CRC_PASS
, true);
2739 /* Back off by 20ms per retry */
2743 dev_err(dev
, "Retry count exceeded\n");
2752 if (frame
% 50 == 0)
2753 dev_dbg(dev
, "Sent %d frames, %d/%zd bytes\n",
2754 frame
, pos
, fw
->size
);
2757 /* Wait for flash. */
2758 ret
= mxt_wait_for_completion(data
, &data
->bl_completion
,
2763 dev_dbg(dev
, "Sent %d frames, %d bytes\n", frame
, pos
);
2766 * Wait for device to reset. Some bootloader versions do not assert
2767 * the CHG line after bootloading has finished, so ignore potential
2770 mxt_wait_for_completion(data
, &data
->bl_completion
, MXT_FW_RESET_TIME
);
2772 data
->in_bootloader
= false;
2775 disable_irq(data
->irq
);
2777 release_firmware(fw
);
2781 static ssize_t
mxt_update_fw_store(struct device
*dev
,
2782 struct device_attribute
*attr
,
2783 const char *buf
, size_t count
)
2785 struct mxt_data
*data
= dev_get_drvdata(dev
);
2788 error
= mxt_load_fw(dev
, MXT_FW_NAME
);
2790 dev_err(dev
, "The firmware update failed(%d)\n", error
);
2793 dev_info(dev
, "The firmware update succeeded\n");
2795 error
= mxt_initialize(data
);
2803 static DEVICE_ATTR(fw_version
, S_IRUGO
, mxt_fw_version_show
, NULL
);
2804 static DEVICE_ATTR(hw_version
, S_IRUGO
, mxt_hw_version_show
, NULL
);
2805 static DEVICE_ATTR(object
, S_IRUGO
, mxt_object_show
, NULL
);
2806 static DEVICE_ATTR(update_fw
, S_IWUSR
, NULL
, mxt_update_fw_store
);
2808 static struct attribute
*mxt_attrs
[] = {
2809 &dev_attr_fw_version
.attr
,
2810 &dev_attr_hw_version
.attr
,
2811 &dev_attr_object
.attr
,
2812 &dev_attr_update_fw
.attr
,
2816 static const struct attribute_group mxt_attr_group
= {
2820 static void mxt_start(struct mxt_data
*data
)
2822 switch (data
->pdata
->suspend_mode
) {
2823 case MXT_SUSPEND_T9_CTRL
:
2824 mxt_soft_reset(data
);
2827 /* 0x83 = SCANEN | RPTEN | ENABLE */
2828 mxt_write_object(data
,
2829 MXT_TOUCH_MULTI_T9
, MXT_T9_CTRL
, 0x83);
2832 case MXT_SUSPEND_DEEP_SLEEP
:
2834 mxt_set_t7_power_cfg(data
, MXT_POWER_CFG_RUN
);
2836 /* Recalibrate since chip has been in deep sleep */
2837 mxt_t6_command(data
, MXT_COMMAND_CALIBRATE
, 1, false);
2843 static void mxt_stop(struct mxt_data
*data
)
2845 switch (data
->pdata
->suspend_mode
) {
2846 case MXT_SUSPEND_T9_CTRL
:
2848 mxt_write_object(data
,
2849 MXT_TOUCH_MULTI_T9
, MXT_T9_CTRL
, 0);
2852 case MXT_SUSPEND_DEEP_SLEEP
:
2854 mxt_set_t7_power_cfg(data
, MXT_POWER_CFG_DEEPSLEEP
);
2859 static int mxt_input_open(struct input_dev
*dev
)
2861 struct mxt_data
*data
= input_get_drvdata(dev
);
2868 static void mxt_input_close(struct input_dev
*dev
)
2870 struct mxt_data
*data
= input_get_drvdata(dev
);
2876 static const struct mxt_platform_data
*mxt_parse_dt(struct i2c_client
*client
)
2878 struct mxt_platform_data
*pdata
;
2879 struct device_node
*np
= client
->dev
.of_node
;
2884 return ERR_PTR(-ENOENT
);
2886 pdata
= devm_kzalloc(&client
->dev
, sizeof(*pdata
), GFP_KERNEL
);
2888 return ERR_PTR(-ENOMEM
);
2890 if (of_find_property(np
, "linux,gpio-keymap", &proplen
)) {
2891 pdata
->t19_num_keys
= proplen
/ sizeof(u32
);
2893 keymap
= devm_kzalloc(&client
->dev
,
2894 pdata
->t19_num_keys
* sizeof(keymap
[0]),
2897 return ERR_PTR(-ENOMEM
);
2899 ret
= of_property_read_u32_array(np
, "linux,gpio-keymap",
2900 keymap
, pdata
->t19_num_keys
);
2902 dev_warn(&client
->dev
,
2903 "Couldn't read linux,gpio-keymap: %d\n", ret
);
2905 pdata
->t19_keymap
= keymap
;
2908 pdata
->suspend_mode
= MXT_SUSPEND_DEEP_SLEEP
;
2913 static const struct mxt_platform_data
*mxt_parse_dt(struct i2c_client
*client
)
2915 return ERR_PTR(-ENOENT
);
2921 struct mxt_acpi_platform_data
{
2923 struct mxt_platform_data pdata
;
2926 static unsigned int samus_touchpad_buttons
[] = {
2933 static struct mxt_acpi_platform_data samus_platform_data
[] = {
2938 .t19_num_keys
= ARRAY_SIZE(samus_touchpad_buttons
),
2939 .t19_keymap
= samus_touchpad_buttons
,
2949 static unsigned int chromebook_tp_buttons
[] = {
2958 static struct mxt_acpi_platform_data chromebook_platform_data
[] = {
2963 .t19_num_keys
= ARRAY_SIZE(chromebook_tp_buttons
),
2964 .t19_keymap
= chromebook_tp_buttons
,
2974 static const struct dmi_system_id mxt_dmi_table
[] = {
2976 /* 2015 Google Pixel */
2977 .ident
= "Chromebook Pixel 2",
2979 DMI_MATCH(DMI_SYS_VENDOR
, "GOOGLE"),
2980 DMI_MATCH(DMI_PRODUCT_NAME
, "Samus"),
2982 .driver_data
= samus_platform_data
,
2985 /* Other Google Chromebooks */
2986 .ident
= "Chromebook",
2988 DMI_MATCH(DMI_SYS_VENDOR
, "GOOGLE"),
2990 .driver_data
= chromebook_platform_data
,
2995 static const struct mxt_platform_data
*mxt_parse_acpi(struct i2c_client
*client
)
2997 struct acpi_device
*adev
;
2998 const struct dmi_system_id
*system_id
;
2999 const struct mxt_acpi_platform_data
*acpi_pdata
;
3002 * Ignore ACPI devices representing bootloader mode.
3004 * This is a bit of a hack: Google Chromebook BIOS creates ACPI
3005 * devices for both application and bootloader modes, but we are
3006 * interested in application mode only (if device is in bootloader
3007 * mode we'll end up switching into application anyway). So far
3008 * application mode addresses were all above 0x40, so we'll use it
3011 if (client
->addr
< 0x40)
3012 return ERR_PTR(-ENXIO
);
3014 adev
= ACPI_COMPANION(&client
->dev
);
3016 return ERR_PTR(-ENOENT
);
3018 system_id
= dmi_first_match(mxt_dmi_table
);
3020 return ERR_PTR(-ENOENT
);
3022 acpi_pdata
= system_id
->driver_data
;
3024 return ERR_PTR(-ENOENT
);
3026 while (acpi_pdata
->hid
) {
3027 if (!strcmp(acpi_device_hid(adev
), acpi_pdata
->hid
))
3028 return &acpi_pdata
->pdata
;
3033 return ERR_PTR(-ENOENT
);
3036 static const struct mxt_platform_data
*mxt_parse_acpi(struct i2c_client
*client
)
3038 return ERR_PTR(-ENOENT
);
3042 static const struct mxt_platform_data
*
3043 mxt_get_platform_data(struct i2c_client
*client
)
3045 const struct mxt_platform_data
*pdata
;
3047 pdata
= dev_get_platdata(&client
->dev
);
3051 pdata
= mxt_parse_dt(client
);
3052 if (!IS_ERR(pdata
) || PTR_ERR(pdata
) != -ENOENT
)
3055 pdata
= mxt_parse_acpi(client
);
3056 if (!IS_ERR(pdata
) || PTR_ERR(pdata
) != -ENOENT
)
3059 dev_err(&client
->dev
, "No platform data specified\n");
3060 return ERR_PTR(-EINVAL
);
3063 static int mxt_probe(struct i2c_client
*client
, const struct i2c_device_id
*id
)
3065 struct mxt_data
*data
;
3066 const struct mxt_platform_data
*pdata
;
3069 pdata
= mxt_get_platform_data(client
);
3071 return PTR_ERR(pdata
);
3073 data
= kzalloc(sizeof(struct mxt_data
), GFP_KERNEL
);
3075 dev_err(&client
->dev
, "Failed to allocate memory\n");
3079 snprintf(data
->phys
, sizeof(data
->phys
), "i2c-%u-%04x/input0",
3080 client
->adapter
->nr
, client
->addr
);
3082 data
->client
= client
;
3083 data
->pdata
= pdata
;
3084 data
->irq
= client
->irq
;
3085 i2c_set_clientdata(client
, data
);
3087 init_completion(&data
->bl_completion
);
3088 init_completion(&data
->reset_completion
);
3089 init_completion(&data
->crc_completion
);
3091 error
= request_threaded_irq(client
->irq
, NULL
, mxt_interrupt
,
3092 pdata
->irqflags
| IRQF_ONESHOT
,
3093 client
->name
, data
);
3095 dev_err(&client
->dev
, "Failed to register interrupt\n");
3099 disable_irq(client
->irq
);
3101 error
= mxt_initialize(data
);
3105 error
= sysfs_create_group(&client
->dev
.kobj
, &mxt_attr_group
);
3107 dev_err(&client
->dev
, "Failure %d creating sysfs group\n",
3109 goto err_free_object
;
3115 mxt_free_input_device(data
);
3116 mxt_free_object_table(data
);
3118 free_irq(client
->irq
, data
);
3124 static int mxt_remove(struct i2c_client
*client
)
3126 struct mxt_data
*data
= i2c_get_clientdata(client
);
3128 sysfs_remove_group(&client
->dev
.kobj
, &mxt_attr_group
);
3129 free_irq(data
->irq
, data
);
3130 mxt_free_input_device(data
);
3131 mxt_free_object_table(data
);
3137 static int __maybe_unused
mxt_suspend(struct device
*dev
)
3139 struct i2c_client
*client
= to_i2c_client(dev
);
3140 struct mxt_data
*data
= i2c_get_clientdata(client
);
3141 struct input_dev
*input_dev
= data
->input_dev
;
3146 mutex_lock(&input_dev
->mutex
);
3148 if (input_dev
->users
)
3151 mutex_unlock(&input_dev
->mutex
);
3156 static int __maybe_unused
mxt_resume(struct device
*dev
)
3158 struct i2c_client
*client
= to_i2c_client(dev
);
3159 struct mxt_data
*data
= i2c_get_clientdata(client
);
3160 struct input_dev
*input_dev
= data
->input_dev
;
3165 mutex_lock(&input_dev
->mutex
);
3167 if (input_dev
->users
)
3170 mutex_unlock(&input_dev
->mutex
);
3175 static SIMPLE_DEV_PM_OPS(mxt_pm_ops
, mxt_suspend
, mxt_resume
);
3177 static const struct of_device_id mxt_of_match
[] = {
3178 { .compatible
= "atmel,maxtouch", },
3181 MODULE_DEVICE_TABLE(of
, mxt_of_match
);
3184 static const struct acpi_device_id mxt_acpi_id
[] = {
3185 { "ATML0000", 0 }, /* Touchpad */
3186 { "ATML0001", 0 }, /* Touchscreen */
3189 MODULE_DEVICE_TABLE(acpi
, mxt_acpi_id
);
3192 static const struct i2c_device_id mxt_id
[] = {
3193 { "qt602240_ts", 0 },
3194 { "atmel_mxt_ts", 0 },
3195 { "atmel_mxt_tp", 0 },
3200 MODULE_DEVICE_TABLE(i2c
, mxt_id
);
3202 static struct i2c_driver mxt_driver
= {
3204 .name
= "atmel_mxt_ts",
3205 .of_match_table
= of_match_ptr(mxt_of_match
),
3206 .acpi_match_table
= ACPI_PTR(mxt_acpi_id
),
3210 .remove
= mxt_remove
,
3214 module_i2c_driver(mxt_driver
);
3216 /* Module information */
3217 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
3218 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
3219 MODULE_LICENSE("GPL");