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/module.h>
18 #include <linux/init.h>
19 #include <linux/completion.h>
20 #include <linux/delay.h>
21 #include <linux/firmware.h>
22 #include <linux/i2c.h>
23 #include <linux/i2c/atmel_mxt_ts.h>
24 #include <linux/input/mt.h>
25 #include <linux/interrupt.h>
27 #include <linux/slab.h>
28 #include <asm/unaligned.h>
36 #define MXT_FW_NAME "maxtouch.fw"
37 #define MXT_CFG_NAME "maxtouch.cfg"
38 #define MXT_CFG_MAGIC "OBP_RAW V1"
42 #define MXT_FAMILY_ID 0x00
43 #define MXT_VARIANT_ID 0x01
44 #define MXT_VERSION 0x02
45 #define MXT_BUILD 0x03
46 #define MXT_MATRIX_X_SIZE 0x04
47 #define MXT_MATRIX_Y_SIZE 0x05
48 #define MXT_OBJECT_NUM 0x06
49 #define MXT_OBJECT_START 0x07
51 #define MXT_OBJECT_SIZE 6
52 #define MXT_INFO_CHECKSUM_SIZE 3
53 #define MXT_MAX_BLOCK_WRITE 256
56 #define MXT_DEBUG_DIAGNOSTIC_T37 37
57 #define MXT_GEN_MESSAGE_T5 5
58 #define MXT_GEN_COMMAND_T6 6
59 #define MXT_GEN_POWER_T7 7
60 #define MXT_GEN_ACQUIRE_T8 8
61 #define MXT_GEN_DATASOURCE_T53 53
62 #define MXT_TOUCH_MULTI_T9 9
63 #define MXT_TOUCH_KEYARRAY_T15 15
64 #define MXT_TOUCH_PROXIMITY_T23 23
65 #define MXT_TOUCH_PROXKEY_T52 52
66 #define MXT_PROCI_GRIPFACE_T20 20
67 #define MXT_PROCG_NOISE_T22 22
68 #define MXT_PROCI_ONETOUCH_T24 24
69 #define MXT_PROCI_TWOTOUCH_T27 27
70 #define MXT_PROCI_GRIP_T40 40
71 #define MXT_PROCI_PALM_T41 41
72 #define MXT_PROCI_TOUCHSUPPRESSION_T42 42
73 #define MXT_PROCI_STYLUS_T47 47
74 #define MXT_PROCG_NOISESUPPRESSION_T48 48
75 #define MXT_SPT_COMMSCONFIG_T18 18
76 #define MXT_SPT_GPIOPWM_T19 19
77 #define MXT_SPT_SELFTEST_T25 25
78 #define MXT_SPT_CTECONFIG_T28 28
79 #define MXT_SPT_USERDATA_T38 38
80 #define MXT_SPT_DIGITIZER_T43 43
81 #define MXT_SPT_MESSAGECOUNT_T44 44
82 #define MXT_SPT_CTECONFIG_T46 46
83 #define MXT_TOUCH_MULTITOUCHSCREEN_T100 100
85 /* MXT_GEN_MESSAGE_T5 object */
86 #define MXT_RPTID_NOMSG 0xff
88 /* MXT_GEN_COMMAND_T6 field */
89 #define MXT_COMMAND_RESET 0
90 #define MXT_COMMAND_BACKUPNV 1
91 #define MXT_COMMAND_CALIBRATE 2
92 #define MXT_COMMAND_REPORTALL 3
93 #define MXT_COMMAND_DIAGNOSTIC 5
95 /* Define for T6 status byte */
96 #define MXT_T6_STATUS_RESET (1 << 7)
97 #define MXT_T6_STATUS_OFL (1 << 6)
98 #define MXT_T6_STATUS_SIGERR (1 << 5)
99 #define MXT_T6_STATUS_CAL (1 << 4)
100 #define MXT_T6_STATUS_CFGERR (1 << 3)
101 #define MXT_T6_STATUS_COMSERR (1 << 2)
103 /* MXT_GEN_POWER_T7 field */
104 #define MXT_POWER_IDLEACQINT 0
105 #define MXT_POWER_ACTVACQINT 1
106 #define MXT_POWER_ACTV2IDLETO 2
108 /* MXT_GEN_ACQUIRE_T8 field */
109 #define MXT_ACQUIRE_CHRGTIME 0
110 #define MXT_ACQUIRE_TCHDRIFT 2
111 #define MXT_ACQUIRE_DRIFTST 3
112 #define MXT_ACQUIRE_TCHAUTOCAL 4
113 #define MXT_ACQUIRE_SYNC 5
114 #define MXT_ACQUIRE_ATCHCALST 6
115 #define MXT_ACQUIRE_ATCHCALSTHR 7
117 /* MXT_TOUCH_MULTI_T9 field */
118 #define MXT_TOUCH_CTRL 0
119 #define MXT_T9_ORIENT 9
120 #define MXT_T9_RANGE 18
122 /* MXT_TOUCH_MULTI_T9 status */
123 #define MXT_T9_UNGRIP (1 << 0)
124 #define MXT_T9_SUPPRESS (1 << 1)
125 #define MXT_T9_AMP (1 << 2)
126 #define MXT_T9_VECTOR (1 << 3)
127 #define MXT_T9_MOVE (1 << 4)
128 #define MXT_T9_RELEASE (1 << 5)
129 #define MXT_T9_PRESS (1 << 6)
130 #define MXT_T9_DETECT (1 << 7)
137 /* MXT_TOUCH_MULTI_T9 orient */
138 #define MXT_T9_ORIENT_SWITCH (1 << 0)
140 /* MXT_PROCI_GRIPFACE_T20 field */
141 #define MXT_GRIPFACE_CTRL 0
142 #define MXT_GRIPFACE_XLOGRIP 1
143 #define MXT_GRIPFACE_XHIGRIP 2
144 #define MXT_GRIPFACE_YLOGRIP 3
145 #define MXT_GRIPFACE_YHIGRIP 4
146 #define MXT_GRIPFACE_MAXTCHS 5
147 #define MXT_GRIPFACE_SZTHR1 7
148 #define MXT_GRIPFACE_SZTHR2 8
149 #define MXT_GRIPFACE_SHPTHR1 9
150 #define MXT_GRIPFACE_SHPTHR2 10
151 #define MXT_GRIPFACE_SUPEXTTO 11
153 /* MXT_PROCI_NOISE field */
154 #define MXT_NOISE_CTRL 0
155 #define MXT_NOISE_OUTFLEN 1
156 #define MXT_NOISE_GCAFUL_LSB 3
157 #define MXT_NOISE_GCAFUL_MSB 4
158 #define MXT_NOISE_GCAFLL_LSB 5
159 #define MXT_NOISE_GCAFLL_MSB 6
160 #define MXT_NOISE_ACTVGCAFVALID 7
161 #define MXT_NOISE_NOISETHR 8
162 #define MXT_NOISE_FREQHOPSCALE 10
163 #define MXT_NOISE_FREQ0 11
164 #define MXT_NOISE_FREQ1 12
165 #define MXT_NOISE_FREQ2 13
166 #define MXT_NOISE_FREQ3 14
167 #define MXT_NOISE_FREQ4 15
168 #define MXT_NOISE_IDLEGCAFVALID 16
170 /* MXT_SPT_COMMSCONFIG_T18 */
171 #define MXT_COMMS_CTRL 0
172 #define MXT_COMMS_CMD 1
174 /* MXT_SPT_CTECONFIG_T28 field */
175 #define MXT_CTE_CTRL 0
176 #define MXT_CTE_CMD 1
177 #define MXT_CTE_MODE 2
178 #define MXT_CTE_IDLEGCAFDEPTH 3
179 #define MXT_CTE_ACTVGCAFDEPTH 4
180 #define MXT_CTE_VOLTAGE 5
182 #define MXT_VOLTAGE_DEFAULT 2700000
183 #define MXT_VOLTAGE_STEP 10000
185 /* Define for MXT_GEN_COMMAND_T6 */
186 #define MXT_BOOT_VALUE 0xa5
187 #define MXT_RESET_VALUE 0x01
188 #define MXT_BACKUP_VALUE 0x55
190 /* T100 Multiple Touch Touchscreen */
191 #define MXT_T100_CTRL 0
192 #define MXT_T100_CFG1 1
193 #define MXT_T100_TCHAUX 3
194 #define MXT_T100_XRANGE 13
195 #define MXT_T100_YRANGE 24
197 #define MXT_T100_CFG_SWITCHXY BIT(5)
199 #define MXT_T100_TCHAUX_VECT BIT(0)
200 #define MXT_T100_TCHAUX_AMPL BIT(1)
201 #define MXT_T100_TCHAUX_AREA BIT(2)
203 #define MXT_T100_DETECT BIT(7)
204 #define MXT_T100_TYPE_MASK 0x70
207 MXT_T100_TYPE_FINGER = 1,
208 MXT_T100_TYPE_PASSIVE_STYLUS = 2,
209 MXT_T100_TYPE_HOVERING_FINGER = 4,
210 MXT_T100_TYPE_GLOVE = 5,
211 MXT_T100_TYPE_LARGE_TOUCH = 6,
214 #define MXT_DISTANCE_ACTIVE_TOUCH 0
215 #define MXT_DISTANCE_HOVERING 1
217 #define MXT_TOUCH_MAJOR_DEFAULT 1
218 #define MXT_PRESSURE_DEFAULT 1
221 #define MXT_BACKUP_TIME 50 /* msec */
222 #define MXT_RESET_TIME 200 /* msec */
223 #define MXT_RESET_TIMEOUT 3000 /* msec */
224 #define MXT_CRC_TIMEOUT 1000 /* msec */
225 #define MXT_FW_RESET_TIME 3000 /* msec */
226 #define MXT_FW_CHG_TIMEOUT 300 /* msec */
228 /* Command to unlock bootloader */
229 #define MXT_UNLOCK_CMD_MSB 0xaa
230 #define MXT_UNLOCK_CMD_LSB 0xdc
232 /* Bootloader mode status */
233 #define MXT_WAITING_BOOTLOAD_CMD 0xc0 /* valid 7 6 bit only */
234 #define MXT_WAITING_FRAME_DATA 0x80 /* valid 7 6 bit only */
235 #define MXT_FRAME_CRC_CHECK 0x02
236 #define MXT_FRAME_CRC_FAIL 0x03
237 #define MXT_FRAME_CRC_PASS 0x04
238 #define MXT_APP_CRC_FAIL 0x40 /* valid 7 8 bit only */
239 #define MXT_BOOT_STATUS_MASK 0x3f
240 #define MXT_BOOT_EXTENDED_ID (1 << 5)
241 #define MXT_BOOT_ID_MASK 0x1f
243 /* Touchscreen absolute values */
244 #define MXT_MAX_AREA 0xff
246 #define MXT_PIXELS_PER_MM 20
262 u8 instances_minus_one;
266 /* Each client has this additional data */
268 struct i2c_client *client;
269 struct input_dev *input_dev;
270 char phys[64]; /* device physical location */
271 const struct mxt_platform_data *pdata;
272 struct mxt_object *object_table;
273 struct mxt_info info;
289 u8 last_message_count;
293 /* Cached parameters from object table */
303 u8 T100_reportid_min;
304 u8 T100_reportid_max;
306 /* for fw update in bootloader */
307 struct completion bl_completion;
309 /* for reset handling */
310 struct completion reset_completion;
312 /* for config update handling */
313 struct completion crc_completion;
316 static size_t mxt_obj_size(const struct mxt_object *obj)
318 return obj->size_minus_one + 1;
321 static size_t mxt_obj_instances(const struct mxt_object *obj)
323 return obj->instances_minus_one + 1;
326 static bool mxt_object_readable(unsigned int type)
329 case MXT_GEN_COMMAND_T6:
330 case MXT_GEN_POWER_T7:
331 case MXT_GEN_ACQUIRE_T8:
332 case MXT_GEN_DATASOURCE_T53:
333 case MXT_TOUCH_MULTI_T9:
334 case MXT_TOUCH_KEYARRAY_T15:
335 case MXT_TOUCH_PROXIMITY_T23:
336 case MXT_TOUCH_PROXKEY_T52:
337 case MXT_PROCI_GRIPFACE_T20:
338 case MXT_PROCG_NOISE_T22:
339 case MXT_PROCI_ONETOUCH_T24:
340 case MXT_PROCI_TWOTOUCH_T27:
341 case MXT_PROCI_GRIP_T40:
342 case MXT_PROCI_PALM_T41:
343 case MXT_PROCI_TOUCHSUPPRESSION_T42:
344 case MXT_PROCI_STYLUS_T47:
345 case MXT_PROCG_NOISESUPPRESSION_T48:
346 case MXT_SPT_COMMSCONFIG_T18:
347 case MXT_SPT_GPIOPWM_T19:
348 case MXT_SPT_SELFTEST_T25:
349 case MXT_SPT_CTECONFIG_T28:
350 case MXT_SPT_USERDATA_T38:
351 case MXT_SPT_DIGITIZER_T43:
352 case MXT_SPT_CTECONFIG_T46:
359 static void mxt_dump_message(struct mxt_data *data, u8 *message)
361 dev_dbg(&data->client->dev, "message: %*ph\n",
362 data->T5_msg_size, message);
365 static int mxt_wait_for_completion(struct mxt_data *data,
366 struct completion *comp,
367 unsigned int timeout_ms)
369 struct device *dev = &data->client->dev;
370 unsigned long timeout = msecs_to_jiffies(timeout_ms);
373 ret = wait_for_completion_interruptible_timeout(comp, timeout);
376 } else if (ret == 0) {
377 dev_err(dev, "Wait for completion timed out.\n");
383 static int mxt_bootloader_read(struct mxt_data *data,
384 u8 *val, unsigned int count)
389 msg.addr = data->bootloader_addr;
390 msg.flags = data->client->flags & I2C_M_TEN;
391 msg.flags |= I2C_M_RD;
395 ret = i2c_transfer(data->client->adapter, &msg, 1);
399 ret = ret < 0 ? ret : -EIO;
400 dev_err(&data->client->dev, "%s: i2c recv failed (%d)\n",
407 static int mxt_bootloader_write(struct mxt_data *data,
408 const u8 * const val, unsigned int count)
413 msg.addr = data->bootloader_addr;
414 msg.flags = data->client->flags & I2C_M_TEN;
418 ret = i2c_transfer(data->client->adapter, &msg, 1);
422 ret = ret < 0 ? ret : -EIO;
423 dev_err(&data->client->dev, "%s: i2c send failed (%d)\n",
430 static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry)
432 u8 appmode = data->client->addr;
438 /* Chips after 1664S use different scheme */
439 if (retry || data->info.family_id >= 0xa2) {
440 bootloader = appmode - 0x24;
443 /* Fall through for normal case */
448 bootloader = appmode - 0x26;
452 dev_err(&data->client->dev,
453 "Appmode i2c address 0x%02x not found\n",
458 data->bootloader_addr = bootloader;
462 static int mxt_probe_bootloader(struct mxt_data *data, bool alt_address)
464 struct device *dev = &data->client->dev;
469 error = mxt_lookup_bootloader_address(data, alt_address);
473 error = mxt_bootloader_read(data, &val, 1);
477 /* Check app crc fail mode */
478 crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL;
480 dev_err(dev, "Detected bootloader, status:%02X%s\n",
481 val, crc_failure ? ", APP_CRC_FAIL" : "");
486 static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
488 struct device *dev = &data->client->dev;
491 if (val & MXT_BOOT_EXTENDED_ID) {
492 if (mxt_bootloader_read(data, &buf[0], 3) != 0) {
493 dev_err(dev, "%s: i2c failure\n", __func__);
497 dev_dbg(dev, "Bootloader ID:%d Version:%d\n", buf[1], buf[2]);
501 dev_dbg(dev, "Bootloader ID:%d\n", val & MXT_BOOT_ID_MASK);
507 static int mxt_check_bootloader(struct mxt_data *data, unsigned int state,
510 struct device *dev = &data->client->dev;
517 * In application update mode, the interrupt
518 * line signals state transitions. We must wait for the
519 * CHG assertion before reading the status byte.
520 * Once the status byte has been read, the line is deasserted.
522 ret = mxt_wait_for_completion(data, &data->bl_completion,
526 * TODO: handle -ERESTARTSYS better by terminating
527 * fw update process before returning to userspace
528 * by writing length 0x000 to device (iff we are in
529 * WAITING_FRAME_DATA state).
531 dev_err(dev, "Update wait error %d\n", ret);
536 ret = mxt_bootloader_read(data, &val, 1);
540 if (state == MXT_WAITING_BOOTLOAD_CMD)
541 val = mxt_get_bootloader_version(data, val);
544 case MXT_WAITING_BOOTLOAD_CMD:
545 case MXT_WAITING_FRAME_DATA:
546 case MXT_APP_CRC_FAIL:
547 val &= ~MXT_BOOT_STATUS_MASK;
549 case MXT_FRAME_CRC_PASS:
550 if (val == MXT_FRAME_CRC_CHECK) {
552 } else if (val == MXT_FRAME_CRC_FAIL) {
553 dev_err(dev, "Bootloader CRC fail\n");
562 dev_err(dev, "Invalid bootloader state %02X != %02X\n",
570 static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock)
576 buf[0] = MXT_UNLOCK_CMD_LSB;
577 buf[1] = MXT_UNLOCK_CMD_MSB;
583 ret = mxt_bootloader_write(data, buf, 2);
590 static int __mxt_read_reg(struct i2c_client *client,
591 u16 reg, u16 len, void *val)
593 struct i2c_msg xfer[2];
598 buf[1] = (reg >> 8) & 0xff;
601 xfer[0].addr = client->addr;
607 xfer[1].addr = client->addr;
608 xfer[1].flags = I2C_M_RD;
612 ret = i2c_transfer(client->adapter, xfer, 2);
618 dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
625 static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
633 buf = kmalloc(count, GFP_KERNEL);
638 buf[1] = (reg >> 8) & 0xff;
639 memcpy(&buf[2], val, len);
641 ret = i2c_master_send(client, buf, count);
647 dev_err(&client->dev, "%s: i2c send failed (%d)\n",
655 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
657 return __mxt_write_reg(client, reg, 1, &val);
660 static struct mxt_object *
661 mxt_get_object(struct mxt_data *data, u8 type)
663 struct mxt_object *object;
666 for (i = 0; i < data->info.object_num; i++) {
667 object = data->object_table + i;
668 if (object->type == type)
672 dev_warn(&data->client->dev, "Invalid object type T%u\n", type);
676 static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg)
678 struct device *dev = &data->client->dev;
680 u32 crc = msg[2] | (msg[3] << 8) | (msg[4] << 16);
682 complete(&data->crc_completion);
684 if (crc != data->config_crc) {
685 data->config_crc = crc;
686 dev_dbg(dev, "T6 Config Checksum: 0x%06X\n", crc);
690 if (status & MXT_T6_STATUS_RESET)
691 complete(&data->reset_completion);
693 /* Output debug if status has changed */
694 if (status != data->t6_status)
695 dev_dbg(dev, "T6 Status 0x%02X%s%s%s%s%s%s%s\n",
697 status == 0 ? " OK" : "",
698 status & MXT_T6_STATUS_RESET ? " RESET" : "",
699 status & MXT_T6_STATUS_OFL ? " OFL" : "",
700 status & MXT_T6_STATUS_SIGERR ? " SIGERR" : "",
701 status & MXT_T6_STATUS_CAL ? " CAL" : "",
702 status & MXT_T6_STATUS_CFGERR ? " CFGERR" : "",
703 status & MXT_T6_STATUS_COMSERR ? " COMSERR" : "");
705 /* Save current status */
706 data->t6_status = status;
709 static int mxt_write_object(struct mxt_data *data,
710 u8 type, u8 offset, u8 val)
712 struct mxt_object *object;
715 object = mxt_get_object(data, type);
716 if (!object || offset >= mxt_obj_size(object))
719 reg = object->start_address;
720 return mxt_write_reg(data->client, reg + offset, val);
723 static void mxt_input_button(struct mxt_data *data, u8 *message)
725 struct input_dev *input = data->input_dev;
726 const struct mxt_platform_data *pdata = data->pdata;
730 /* Active-low switch */
731 for (i = 0; i < pdata->t19_num_keys; i++) {
732 if (pdata->t19_keymap[i] == KEY_RESERVED)
734 button = !(message[1] & (1 << i));
735 input_report_key(input, pdata->t19_keymap[i], button);
739 static void mxt_input_sync(struct mxt_data *data)
741 input_mt_report_pointer_emulation(data->input_dev,
742 data->pdata->t19_num_keys);
743 input_sync(data->input_dev);
746 static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
748 struct device *dev = &data->client->dev;
749 struct input_dev *input_dev = data->input_dev;
757 id = message[0] - data->T9_reportid_min;
759 x = (message[2] << 4) | ((message[4] >> 4) & 0xf);
760 y = (message[3] << 4) | ((message[4] & 0xf));
762 /* Handle 10/12 bit switching */
763 if (data->max_x < 1024)
765 if (data->max_y < 1024)
769 amplitude = message[6];
772 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
774 (status & MXT_T9_DETECT) ? 'D' : '.',
775 (status & MXT_T9_PRESS) ? 'P' : '.',
776 (status & MXT_T9_RELEASE) ? 'R' : '.',
777 (status & MXT_T9_MOVE) ? 'M' : '.',
778 (status & MXT_T9_VECTOR) ? 'V' : '.',
779 (status & MXT_T9_AMP) ? 'A' : '.',
780 (status & MXT_T9_SUPPRESS) ? 'S' : '.',
781 (status & MXT_T9_UNGRIP) ? 'U' : '.',
782 x, y, area, amplitude);
784 input_mt_slot(input_dev, id);
786 if (status & MXT_T9_DETECT) {
788 * Multiple bits may be set if the host is slow to read
789 * the status messages, indicating all the events that
792 if (status & MXT_T9_RELEASE) {
793 input_mt_report_slot_state(input_dev,
795 mxt_input_sync(data);
799 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1);
800 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
801 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
802 input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
803 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
805 /* Touch no longer active, close out slot */
806 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0);
809 data->update_input = true;
812 static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
814 struct device *dev = &data->client->dev;
815 struct input_dev *input_dev = data->input_dev;
827 id = message[0] - data->T100_reportid_min - 2;
829 /* ignore SCRSTATUS events */
834 x = get_unaligned_le16(&message[2]);
835 y = get_unaligned_le16(&message[4]);
837 if (status & MXT_T100_DETECT) {
838 type = (status & MXT_T100_TYPE_MASK) >> 4;
841 case MXT_T100_TYPE_HOVERING_FINGER:
842 tool = MT_TOOL_FINGER;
843 distance = MXT_DISTANCE_HOVERING;
845 if (data->t100_aux_vect)
846 orientation = message[data->t100_aux_vect];
850 case MXT_T100_TYPE_FINGER:
851 case MXT_T100_TYPE_GLOVE:
852 tool = MT_TOOL_FINGER;
853 distance = MXT_DISTANCE_ACTIVE_TOUCH;
855 if (data->t100_aux_area)
856 major = message[data->t100_aux_area];
858 if (data->t100_aux_ampl)
859 pressure = message[data->t100_aux_ampl];
861 if (data->t100_aux_vect)
862 orientation = message[data->t100_aux_vect];
866 case MXT_T100_TYPE_PASSIVE_STYLUS:
870 * Passive stylus is reported with size zero so
873 major = MXT_TOUCH_MAJOR_DEFAULT;
875 if (data->t100_aux_ampl)
876 pressure = message[data->t100_aux_ampl];
880 case MXT_T100_TYPE_LARGE_TOUCH:
881 /* Ignore suppressed touch */
885 dev_dbg(dev, "Unexpected T100 type\n");
891 * Values reported should be non-zero if tool is touching the
894 if (!pressure && type != MXT_T100_TYPE_HOVERING_FINGER)
895 pressure = MXT_PRESSURE_DEFAULT;
897 input_mt_slot(input_dev, id);
899 if (status & MXT_T100_DETECT) {
900 dev_dbg(dev, "[%u] type:%u x:%u y:%u a:%02X p:%02X v:%02X\n",
901 id, type, x, y, major, pressure, orientation);
903 input_mt_report_slot_state(input_dev, tool, 1);
904 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
905 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
906 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, major);
907 input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
908 input_report_abs(input_dev, ABS_MT_DISTANCE, distance);
909 input_report_abs(input_dev, ABS_MT_ORIENTATION, orientation);
911 dev_dbg(dev, "[%u] release\n", id);
914 input_mt_report_slot_state(input_dev, 0, 0);
917 data->update_input = true;
920 static int mxt_proc_message(struct mxt_data *data, u8 *message)
922 u8 report_id = message[0];
924 if (report_id == MXT_RPTID_NOMSG)
927 if (report_id == data->T6_reportid) {
928 mxt_proc_t6_messages(data, message);
929 } else if (!data->input_dev) {
931 * Do not report events if input device
932 * is not yet registered.
934 mxt_dump_message(data, message);
935 } else if (report_id >= data->T9_reportid_min &&
936 report_id <= data->T9_reportid_max) {
937 mxt_proc_t9_message(data, message);
938 } else if (report_id >= data->T100_reportid_min &&
939 report_id <= data->T100_reportid_max) {
940 mxt_proc_t100_message(data, message);
941 } else if (report_id == data->T19_reportid) {
942 mxt_input_button(data, message);
943 data->update_input = true;
945 mxt_dump_message(data, message);
951 static int mxt_read_and_process_messages(struct mxt_data *data, u8 count)
953 struct device *dev = &data->client->dev;
958 /* Safety check for msg_buf */
959 if (count > data->max_reportid)
962 /* Process remaining messages if necessary */
963 ret = __mxt_read_reg(data->client, data->T5_address,
964 data->T5_msg_size * count, data->msg_buf);
966 dev_err(dev, "Failed to read %u messages (%d)\n", count, ret);
970 for (i = 0; i < count; i++) {
971 ret = mxt_proc_message(data,
972 data->msg_buf + data->T5_msg_size * i);
978 /* return number of messages read */
982 static irqreturn_t mxt_process_messages_t44(struct mxt_data *data)
984 struct device *dev = &data->client->dev;
988 /* Read T44 and T5 together */
989 ret = __mxt_read_reg(data->client, data->T44_address,
990 data->T5_msg_size + 1, data->msg_buf);
992 dev_err(dev, "Failed to read T44 and T5 (%d)\n", ret);
996 count = data->msg_buf[0];
1000 * This condition is caused by the CHG line being configured
1001 * in Mode 0. It results in unnecessary I2C operations but it
1004 dev_dbg(dev, "Interrupt triggered but zero messages\n");
1006 } else if (count > data->max_reportid) {
1007 dev_err(dev, "T44 count %d exceeded max report id\n", count);
1008 count = data->max_reportid;
1011 /* Process first message */
1012 ret = mxt_proc_message(data, data->msg_buf + 1);
1014 dev_warn(dev, "Unexpected invalid message\n");
1018 num_left = count - 1;
1020 /* Process remaining messages if necessary */
1022 ret = mxt_read_and_process_messages(data, num_left);
1025 else if (ret != num_left)
1026 dev_warn(dev, "Unexpected invalid message\n");
1030 if (data->update_input) {
1031 mxt_input_sync(data);
1032 data->update_input = false;
1038 static int mxt_process_messages_until_invalid(struct mxt_data *data)
1040 struct device *dev = &data->client->dev;
1044 count = data->max_reportid;
1046 /* Read messages until we force an invalid */
1048 read = mxt_read_and_process_messages(data, count);
1053 if (data->update_input) {
1054 mxt_input_sync(data);
1055 data->update_input = false;
1058 dev_err(dev, "CHG pin isn't cleared\n");
1062 static irqreturn_t mxt_process_messages(struct mxt_data *data)
1064 int total_handled, num_handled;
1065 u8 count = data->last_message_count;
1067 if (count < 1 || count > data->max_reportid)
1070 /* include final invalid message */
1071 total_handled = mxt_read_and_process_messages(data, count + 1);
1072 if (total_handled < 0)
1074 /* if there were invalid messages, then we are done */
1075 else if (total_handled <= count)
1078 /* keep reading two msgs until one is invalid or reportid limit */
1080 num_handled = mxt_read_and_process_messages(data, 2);
1081 if (num_handled < 0)
1084 total_handled += num_handled;
1086 if (num_handled < 2)
1088 } while (total_handled < data->num_touchids);
1091 data->last_message_count = total_handled;
1093 if (data->update_input) {
1094 mxt_input_sync(data);
1095 data->update_input = false;
1101 static irqreturn_t mxt_interrupt(int irq, void *dev_id)
1103 struct mxt_data *data = dev_id;
1105 if (data->in_bootloader) {
1106 /* bootloader state transition completion */
1107 complete(&data->bl_completion);
1111 if (!data->object_table)
1114 if (data->T44_address) {
1115 return mxt_process_messages_t44(data);
1117 return mxt_process_messages(data);
1121 static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset,
1122 u8 value, bool wait)
1125 u8 command_register;
1126 int timeout_counter = 0;
1129 reg = data->T6_address + cmd_offset;
1131 ret = mxt_write_reg(data->client, reg, value);
1140 ret = __mxt_read_reg(data->client, reg, 1, &command_register);
1143 } while (command_register != 0 && timeout_counter++ <= 100);
1145 if (timeout_counter > 100) {
1146 dev_err(&data->client->dev, "Command failed!\n");
1153 static int mxt_soft_reset(struct mxt_data *data)
1155 struct device *dev = &data->client->dev;
1158 dev_info(dev, "Resetting chip\n");
1160 reinit_completion(&data->reset_completion);
1162 ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_RESET_VALUE, false);
1166 ret = mxt_wait_for_completion(data, &data->reset_completion,
1174 static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value)
1177 * On failure, CRC is set to 0 and config will always be
1180 data->config_crc = 0;
1181 reinit_completion(&data->crc_completion);
1183 mxt_t6_command(data, cmd, value, true);
1186 * Wait for crc message. On failure, CRC is set to 0 and config will
1187 * always be downloaded.
1189 mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT);
1192 static void mxt_calc_crc24(u32 *crc, u8 firstbyte, u8 secondbyte)
1194 static const unsigned int crcpoly = 0x80001B;
1198 data_word = (secondbyte << 8) | firstbyte;
1199 result = ((*crc << 1) ^ data_word);
1201 if (result & 0x1000000)
1207 static u32 mxt_calculate_crc(u8 *base, off_t start_off, off_t end_off)
1210 u8 *ptr = base + start_off;
1211 u8 *last_val = base + end_off - 1;
1213 if (end_off < start_off)
1216 while (ptr < last_val) {
1217 mxt_calc_crc24(&crc, *ptr, *(ptr + 1));
1221 /* if len is odd, fill the last byte with 0 */
1222 if (ptr == last_val)
1223 mxt_calc_crc24(&crc, *ptr, 0);
1225 /* Mask to 24-bit */
1231 static int mxt_prepare_cfg_mem(struct mxt_data *data,
1232 const struct firmware *cfg,
1233 unsigned int data_pos,
1234 unsigned int cfg_start_ofs,
1236 size_t config_mem_size)
1238 struct device *dev = &data->client->dev;
1239 struct mxt_object *object;
1240 unsigned int type, instance, size, byte_offset;
1247 while (data_pos < cfg->size) {
1248 /* Read type, instance, length */
1249 ret = sscanf(cfg->data + data_pos, "%x %x %x%n",
1250 &type, &instance, &size, &offset);
1254 } else if (ret != 3) {
1255 dev_err(dev, "Bad format: failed to parse object\n");
1260 object = mxt_get_object(data, type);
1263 for (i = 0; i < size; i++) {
1264 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1267 dev_err(dev, "Bad format in T%d at %d\n",
1276 if (size > mxt_obj_size(object)) {
1278 * Either we are in fallback mode due to wrong
1279 * config or config from a later fw version,
1280 * or the file is corrupt or hand-edited.
1282 dev_warn(dev, "Discarding %zu byte(s) in T%u\n",
1283 size - mxt_obj_size(object), type);
1284 } else if (mxt_obj_size(object) > size) {
1286 * If firmware is upgraded, new bytes may be added to
1287 * end of objects. It is generally forward compatible
1288 * to zero these bytes - previous behaviour will be
1289 * retained. However this does invalidate the CRC and
1290 * will force fallback mode until the configuration is
1291 * updated. We warn here but do nothing else - the
1292 * malloc has zeroed the entire configuration.
1294 dev_warn(dev, "Zeroing %zu byte(s) in T%d\n",
1295 mxt_obj_size(object) - size, type);
1298 if (instance >= mxt_obj_instances(object)) {
1299 dev_err(dev, "Object instances exceeded!\n");
1303 reg = object->start_address + mxt_obj_size(object) * instance;
1305 for (i = 0; i < size; i++) {
1306 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1310 dev_err(dev, "Bad format in T%d at %d\n",
1316 if (i > mxt_obj_size(object))
1319 byte_offset = reg + i - cfg_start_ofs;
1321 if (byte_offset >= 0 && byte_offset < config_mem_size) {
1322 *(config_mem + byte_offset) = val;
1324 dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n",
1325 reg, object->type, byte_offset);
1334 static int mxt_upload_cfg_mem(struct mxt_data *data, unsigned int cfg_start,
1335 u8 *config_mem, size_t config_mem_size)
1337 unsigned int byte_offset = 0;
1340 /* Write configuration as blocks */
1341 while (byte_offset < config_mem_size) {
1342 unsigned int size = config_mem_size - byte_offset;
1344 if (size > MXT_MAX_BLOCK_WRITE)
1345 size = MXT_MAX_BLOCK_WRITE;
1347 error = __mxt_write_reg(data->client,
1348 cfg_start + byte_offset,
1349 size, config_mem + byte_offset);
1351 dev_err(&data->client->dev,
1352 "Config write error, ret=%d\n", error);
1356 byte_offset += size;
1363 * mxt_update_cfg - download configuration to chip
1365 * Atmel Raw Config File Format
1367 * The first four lines of the raw config file contain:
1369 * 2) Chip ID Information (first 7 bytes of device memory)
1370 * 3) Chip Information Block 24-bit CRC Checksum
1371 * 4) Chip Configuration 24-bit CRC Checksum
1373 * The rest of the file consists of one line per object instance:
1374 * <TYPE> <INSTANCE> <SIZE> <CONTENTS>
1376 * <TYPE> - 2-byte object type as hex
1377 * <INSTANCE> - 2-byte object instance number as hex
1378 * <SIZE> - 2-byte object size as hex
1379 * <CONTENTS> - array of <SIZE> 1-byte hex values
1381 static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg)
1383 struct device *dev = &data->client->dev;
1384 struct mxt_info cfg_info;
1390 u32 info_crc, config_crc, calculated_crc;
1392 size_t config_mem_size;
1394 mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1);
1396 if (strncmp(cfg->data, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
1397 dev_err(dev, "Unrecognised config file\n");
1401 data_pos = strlen(MXT_CFG_MAGIC);
1403 /* Load information block and check */
1404 for (i = 0; i < sizeof(struct mxt_info); i++) {
1405 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1406 (unsigned char *)&cfg_info + i,
1409 dev_err(dev, "Bad format\n");
1416 if (cfg_info.family_id != data->info.family_id) {
1417 dev_err(dev, "Family ID mismatch!\n");
1421 if (cfg_info.variant_id != data->info.variant_id) {
1422 dev_err(dev, "Variant ID mismatch!\n");
1427 ret = sscanf(cfg->data + data_pos, "%x%n", &info_crc, &offset);
1429 dev_err(dev, "Bad format: failed to parse Info CRC\n");
1434 ret = sscanf(cfg->data + data_pos, "%x%n", &config_crc, &offset);
1436 dev_err(dev, "Bad format: failed to parse Config CRC\n");
1442 * The Info Block CRC is calculated over mxt_info and the object
1443 * table. If it does not match then we are trying to load the
1444 * configuration from a different chip or firmware version, so
1445 * the configuration CRC is invalid anyway.
1447 if (info_crc == data->info_crc) {
1448 if (config_crc == 0 || data->config_crc == 0) {
1449 dev_info(dev, "CRC zero, attempting to apply config\n");
1450 } else if (config_crc == data->config_crc) {
1451 dev_dbg(dev, "Config CRC 0x%06X: OK\n",
1455 dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n",
1456 data->config_crc, config_crc);
1460 "Warning: Info CRC error - device=0x%06X file=0x%06X\n",
1461 data->info_crc, info_crc);
1464 /* Malloc memory to store configuration */
1465 cfg_start_ofs = MXT_OBJECT_START +
1466 data->info.object_num * sizeof(struct mxt_object) +
1467 MXT_INFO_CHECKSUM_SIZE;
1468 config_mem_size = data->mem_size - cfg_start_ofs;
1469 config_mem = kzalloc(config_mem_size, GFP_KERNEL);
1471 dev_err(dev, "Failed to allocate memory\n");
1475 ret = mxt_prepare_cfg_mem(data, cfg, data_pos, cfg_start_ofs,
1476 config_mem, config_mem_size);
1480 /* Calculate crc of the received configs (not the raw config file) */
1481 if (data->T7_address < cfg_start_ofs) {
1482 dev_err(dev, "Bad T7 address, T7addr = %x, config offset %x\n",
1483 data->T7_address, cfg_start_ofs);
1488 calculated_crc = mxt_calculate_crc(config_mem,
1489 data->T7_address - cfg_start_ofs,
1492 if (config_crc > 0 && config_crc != calculated_crc)
1493 dev_warn(dev, "Config CRC error, calculated=%06X, file=%06X\n",
1494 calculated_crc, config_crc);
1496 ret = mxt_upload_cfg_mem(data, cfg_start_ofs,
1497 config_mem, config_mem_size);
1501 mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
1503 ret = mxt_soft_reset(data);
1507 dev_info(dev, "Config successfully updated\n");
1514 static int mxt_acquire_irq(struct mxt_data *data)
1518 enable_irq(data->irq);
1520 error = mxt_process_messages_until_invalid(data);
1527 static int mxt_get_info(struct mxt_data *data)
1529 struct i2c_client *client = data->client;
1530 struct mxt_info *info = &data->info;
1533 /* Read 7-byte info block starting at address 0 */
1534 error = __mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
1541 static void mxt_free_input_device(struct mxt_data *data)
1543 if (data->input_dev) {
1544 input_unregister_device(data->input_dev);
1545 data->input_dev = NULL;
1549 static void mxt_free_object_table(struct mxt_data *data)
1551 kfree(data->object_table);
1552 data->object_table = NULL;
1553 kfree(data->msg_buf);
1554 data->msg_buf = NULL;
1555 data->T5_address = 0;
1556 data->T5_msg_size = 0;
1557 data->T6_reportid = 0;
1558 data->T7_address = 0;
1559 data->T9_reportid_min = 0;
1560 data->T9_reportid_max = 0;
1561 data->T19_reportid = 0;
1562 data->T44_address = 0;
1563 data->T100_reportid_min = 0;
1564 data->T100_reportid_max = 0;
1565 data->max_reportid = 0;
1568 static int mxt_get_object_table(struct mxt_data *data)
1570 struct i2c_client *client = data->client;
1572 struct mxt_object *object_table;
1578 table_size = data->info.object_num * sizeof(struct mxt_object);
1579 object_table = kzalloc(table_size, GFP_KERNEL);
1580 if (!object_table) {
1581 dev_err(&data->client->dev, "Failed to allocate memory\n");
1585 error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
1588 kfree(object_table);
1592 /* Valid Report IDs start counting from 1 */
1595 for (i = 0; i < data->info.object_num; i++) {
1596 struct mxt_object *object = object_table + i;
1599 le16_to_cpus(&object->start_address);
1601 if (object->num_report_ids) {
1603 reportid += object->num_report_ids *
1604 mxt_obj_instances(object);
1605 max_id = reportid - 1;
1611 dev_dbg(&data->client->dev,
1612 "T%u Start:%u Size:%zu Instances:%zu Report IDs:%u-%u\n",
1613 object->type, object->start_address,
1614 mxt_obj_size(object), mxt_obj_instances(object),
1617 switch (object->type) {
1618 case MXT_GEN_MESSAGE_T5:
1619 if (data->info.family_id == 0x80 &&
1620 data->info.version < 0x20) {
1622 * On mXT224 firmware versions prior to V2.0
1623 * read and discard unused CRC byte otherwise
1624 * DMA reads are misaligned.
1626 data->T5_msg_size = mxt_obj_size(object);
1628 /* CRC not enabled, so skip last byte */
1629 data->T5_msg_size = mxt_obj_size(object) - 1;
1631 data->T5_address = object->start_address;
1633 case MXT_GEN_COMMAND_T6:
1634 data->T6_reportid = min_id;
1635 data->T6_address = object->start_address;
1637 case MXT_GEN_POWER_T7:
1638 data->T7_address = object->start_address;
1640 case MXT_TOUCH_MULTI_T9:
1641 data->multitouch = MXT_TOUCH_MULTI_T9;
1642 data->T9_reportid_min = min_id;
1643 data->T9_reportid_max = max_id;
1644 data->num_touchids = object->num_report_ids
1645 * mxt_obj_instances(object);
1647 case MXT_SPT_MESSAGECOUNT_T44:
1648 data->T44_address = object->start_address;
1650 case MXT_SPT_GPIOPWM_T19:
1651 data->T19_reportid = min_id;
1653 case MXT_TOUCH_MULTITOUCHSCREEN_T100:
1654 data->multitouch = MXT_TOUCH_MULTITOUCHSCREEN_T100;
1655 data->T100_reportid_min = min_id;
1656 data->T100_reportid_max = max_id;
1657 /* first two report IDs reserved */
1658 data->num_touchids = object->num_report_ids - 2;
1662 end_address = object->start_address
1663 + mxt_obj_size(object) * mxt_obj_instances(object) - 1;
1665 if (end_address >= data->mem_size)
1666 data->mem_size = end_address + 1;
1669 /* Store maximum reportid */
1670 data->max_reportid = reportid;
1672 /* If T44 exists, T5 position has to be directly after */
1673 if (data->T44_address && (data->T5_address != data->T44_address + 1)) {
1674 dev_err(&client->dev, "Invalid T44 position\n");
1676 goto free_object_table;
1679 data->msg_buf = kcalloc(data->max_reportid,
1680 data->T5_msg_size, GFP_KERNEL);
1681 if (!data->msg_buf) {
1682 dev_err(&client->dev, "Failed to allocate message buffer\n");
1684 goto free_object_table;
1687 data->object_table = object_table;
1692 mxt_free_object_table(data);
1696 static int mxt_read_t9_resolution(struct mxt_data *data)
1698 struct i2c_client *client = data->client;
1700 struct t9_range range;
1701 unsigned char orient;
1702 struct mxt_object *object;
1704 object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
1708 error = __mxt_read_reg(client,
1709 object->start_address + MXT_T9_RANGE,
1710 sizeof(range), &range);
1714 le16_to_cpus(&range.x);
1715 le16_to_cpus(&range.y);
1717 error = __mxt_read_reg(client,
1718 object->start_address + MXT_T9_ORIENT,
1723 /* Handle default values */
1730 if (orient & MXT_T9_ORIENT_SWITCH) {
1731 data->max_x = range.y;
1732 data->max_y = range.x;
1734 data->max_x = range.x;
1735 data->max_y = range.y;
1738 dev_dbg(&client->dev,
1739 "Touchscreen size X%uY%u\n", data->max_x, data->max_y);
1744 static int mxt_read_t100_config(struct mxt_data *data)
1746 struct i2c_client *client = data->client;
1748 struct mxt_object *object;
1749 u16 range_x, range_y;
1753 object = mxt_get_object(data, MXT_TOUCH_MULTITOUCHSCREEN_T100);
1757 error = __mxt_read_reg(client,
1758 object->start_address + MXT_T100_XRANGE,
1759 sizeof(range_x), &range_x);
1763 le16_to_cpus(&range_x);
1765 error = __mxt_read_reg(client,
1766 object->start_address + MXT_T100_YRANGE,
1767 sizeof(range_y), &range_y);
1771 le16_to_cpus(&range_y);
1773 error = __mxt_read_reg(client,
1774 object->start_address + MXT_T100_CFG1,
1779 error = __mxt_read_reg(client,
1780 object->start_address + MXT_T100_TCHAUX,
1785 /* Handle default values */
1792 if (cfg & MXT_T100_CFG_SWITCHXY) {
1793 data->max_x = range_y;
1794 data->max_y = range_x;
1796 data->max_x = range_x;
1797 data->max_y = range_y;
1800 /* allocate aux bytes */
1803 if (tchaux & MXT_T100_TCHAUX_VECT)
1804 data->t100_aux_vect = aux++;
1806 if (tchaux & MXT_T100_TCHAUX_AMPL)
1807 data->t100_aux_ampl = aux++;
1809 if (tchaux & MXT_T100_TCHAUX_AREA)
1810 data->t100_aux_area = aux++;
1812 dev_dbg(&client->dev,
1813 "T100 aux mappings vect:%u ampl:%u area:%u\n",
1814 data->t100_aux_vect, data->t100_aux_ampl, data->t100_aux_area);
1816 dev_info(&client->dev,
1817 "T100 Touchscreen size X%uY%u\n", data->max_x, data->max_y);
1822 static int mxt_input_open(struct input_dev *dev);
1823 static void mxt_input_close(struct input_dev *dev);
1825 static void mxt_set_up_as_touchpad(struct input_dev *input_dev,
1826 struct mxt_data *data)
1828 const struct mxt_platform_data *pdata = data->pdata;
1831 input_dev->name = "Atmel maXTouch Touchpad";
1833 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
1835 input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
1836 input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
1837 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
1839 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
1842 for (i = 0; i < pdata->t19_num_keys; i++)
1843 if (pdata->t19_keymap[i] != KEY_RESERVED)
1844 input_set_capability(input_dev, EV_KEY,
1845 pdata->t19_keymap[i]);
1848 static int mxt_initialize_input_device(struct mxt_data *data)
1850 const struct mxt_platform_data *pdata = data->pdata;
1851 struct device *dev = &data->client->dev;
1852 struct input_dev *input_dev;
1854 unsigned int num_mt_slots;
1855 unsigned int mt_flags = 0;
1857 switch (data->multitouch) {
1858 case MXT_TOUCH_MULTI_T9:
1859 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
1860 error = mxt_read_t9_resolution(data);
1862 dev_warn(dev, "Failed to initialize T9 resolution\n");
1865 case MXT_TOUCH_MULTITOUCHSCREEN_T100:
1866 num_mt_slots = data->num_touchids;
1867 error = mxt_read_t100_config(data);
1869 dev_warn(dev, "Failed to read T100 config\n");
1873 dev_err(dev, "Invalid multitouch object\n");
1877 input_dev = input_allocate_device();
1879 dev_err(dev, "Failed to allocate memory\n");
1883 input_dev->name = "Atmel maXTouch Touchscreen";
1884 input_dev->phys = data->phys;
1885 input_dev->id.bustype = BUS_I2C;
1886 input_dev->dev.parent = dev;
1887 input_dev->open = mxt_input_open;
1888 input_dev->close = mxt_input_close;
1890 input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
1892 /* For single touch */
1893 input_set_abs_params(input_dev, ABS_X, 0, data->max_x, 0, 0);
1894 input_set_abs_params(input_dev, ABS_Y, 0, data->max_y, 0, 0);
1896 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1897 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1898 data->t100_aux_ampl)) {
1899 input_set_abs_params(input_dev, ABS_PRESSURE, 0, 255, 0, 0);
1902 /* If device has buttons we assume it is a touchpad */
1903 if (pdata->t19_num_keys) {
1904 mxt_set_up_as_touchpad(input_dev, data);
1905 mt_flags |= INPUT_MT_POINTER;
1908 /* For multi touch */
1909 error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags);
1911 dev_err(dev, "Error %d initialising slots\n", error);
1915 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100) {
1916 input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
1917 0, MT_TOOL_MAX, 0, 0);
1918 input_set_abs_params(input_dev, ABS_MT_DISTANCE,
1919 MXT_DISTANCE_ACTIVE_TOUCH,
1920 MXT_DISTANCE_HOVERING,
1924 input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1925 0, data->max_x, 0, 0);
1926 input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1927 0, data->max_y, 0, 0);
1929 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1930 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1931 data->t100_aux_area)) {
1932 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1933 0, MXT_MAX_AREA, 0, 0);
1936 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1937 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1938 data->t100_aux_ampl)) {
1939 input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1943 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1944 data->t100_aux_vect) {
1945 input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
1949 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1950 data->t100_aux_ampl) {
1951 input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1955 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1956 data->t100_aux_vect) {
1957 input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
1961 input_set_drvdata(input_dev, data);
1963 error = input_register_device(input_dev);
1965 dev_err(dev, "Error %d registering input device\n", error);
1969 data->input_dev = input_dev;
1974 input_free_device(input_dev);
1978 static int mxt_configure_objects(struct mxt_data *data,
1979 const struct firmware *cfg);
1981 static void mxt_config_cb(const struct firmware *cfg, void *ctx)
1983 mxt_configure_objects(ctx, cfg);
1984 release_firmware(cfg);
1987 static int mxt_initialize(struct mxt_data *data)
1989 struct i2c_client *client = data->client;
1990 int recovery_attempts = 0;
1994 error = mxt_get_info(data);
1998 /* Check bootloader state */
1999 error = mxt_probe_bootloader(data, false);
2001 dev_info(&client->dev, "Trying alternate bootloader address\n");
2002 error = mxt_probe_bootloader(data, true);
2004 /* Chip is not in appmode or bootloader mode */
2009 /* OK, we are in bootloader, see if we can recover */
2010 if (++recovery_attempts > 1) {
2011 dev_err(&client->dev, "Could not recover from bootloader mode\n");
2013 * We can reflash from this state, so do not
2014 * abort initialization.
2016 data->in_bootloader = true;
2020 /* Attempt to exit bootloader into app mode */
2021 mxt_send_bootloader_cmd(data, false);
2022 msleep(MXT_FW_RESET_TIME);
2025 /* Get object table information */
2026 error = mxt_get_object_table(data);
2028 dev_err(&client->dev, "Error %d reading object table\n", error);
2032 error = mxt_acquire_irq(data);
2034 goto err_free_object_table;
2036 error = request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
2037 &client->dev, GFP_KERNEL, data,
2040 dev_err(&client->dev, "Failed to invoke firmware loader: %d\n",
2042 goto err_free_object_table;
2047 err_free_object_table:
2048 mxt_free_object_table(data);
2052 static int mxt_configure_objects(struct mxt_data *data,
2053 const struct firmware *cfg)
2055 struct device *dev = &data->client->dev;
2056 struct mxt_info *info = &data->info;
2060 error = mxt_update_cfg(data, cfg);
2062 dev_warn(dev, "Error %d updating config\n", error);
2065 if (data->multitouch) {
2066 error = mxt_initialize_input_device(data);
2070 dev_warn(dev, "No touch object detected\n");
2074 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
2075 info->family_id, info->variant_id, info->version >> 4,
2076 info->version & 0xf, info->build, info->object_num);
2081 /* Firmware Version is returned as Major.Minor.Build */
2082 static ssize_t mxt_fw_version_show(struct device *dev,
2083 struct device_attribute *attr, char *buf)
2085 struct mxt_data *data = dev_get_drvdata(dev);
2086 struct mxt_info *info = &data->info;
2087 return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
2088 info->version >> 4, info->version & 0xf, info->build);
2091 /* Hardware Version is returned as FamilyID.VariantID */
2092 static ssize_t mxt_hw_version_show(struct device *dev,
2093 struct device_attribute *attr, char *buf)
2095 struct mxt_data *data = dev_get_drvdata(dev);
2096 struct mxt_info *info = &data->info;
2097 return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
2098 info->family_id, info->variant_id);
2101 static ssize_t mxt_show_instance(char *buf, int count,
2102 struct mxt_object *object, int instance,
2107 if (mxt_obj_instances(object) > 1)
2108 count += scnprintf(buf + count, PAGE_SIZE - count,
2109 "Instance %u\n", instance);
2111 for (i = 0; i < mxt_obj_size(object); i++)
2112 count += scnprintf(buf + count, PAGE_SIZE - count,
2113 "\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
2114 count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
2119 static ssize_t mxt_object_show(struct device *dev,
2120 struct device_attribute *attr, char *buf)
2122 struct mxt_data *data = dev_get_drvdata(dev);
2123 struct mxt_object *object;
2129 /* Pre-allocate buffer large enough to hold max sized object. */
2130 obuf = kmalloc(256, GFP_KERNEL);
2135 for (i = 0; i < data->info.object_num; i++) {
2136 object = data->object_table + i;
2138 if (!mxt_object_readable(object->type))
2141 count += scnprintf(buf + count, PAGE_SIZE - count,
2142 "T%u:\n", object->type);
2144 for (j = 0; j < mxt_obj_instances(object); j++) {
2145 u16 size = mxt_obj_size(object);
2146 u16 addr = object->start_address + j * size;
2148 error = __mxt_read_reg(data->client, addr, size, obuf);
2152 count = mxt_show_instance(buf, count, object, j, obuf);
2158 return error ?: count;
2161 static int mxt_check_firmware_format(struct device *dev,
2162 const struct firmware *fw)
2164 unsigned int pos = 0;
2167 while (pos < fw->size) {
2168 c = *(fw->data + pos);
2170 if (c < '0' || (c > '9' && c < 'A') || c > 'F')
2177 * To convert file try:
2178 * xxd -r -p mXTXXX__APP_VX-X-XX.enc > maxtouch.fw
2180 dev_err(dev, "Aborting: firmware file must be in binary format\n");
2185 static int mxt_load_fw(struct device *dev, const char *fn)
2187 struct mxt_data *data = dev_get_drvdata(dev);
2188 const struct firmware *fw = NULL;
2189 unsigned int frame_size;
2190 unsigned int pos = 0;
2191 unsigned int retry = 0;
2192 unsigned int frame = 0;
2195 ret = request_firmware(&fw, fn, dev);
2197 dev_err(dev, "Unable to open firmware %s\n", fn);
2201 /* Check for incorrect enc file */
2202 ret = mxt_check_firmware_format(dev, fw);
2204 goto release_firmware;
2206 if (!data->in_bootloader) {
2207 /* Change to the bootloader mode */
2208 data->in_bootloader = true;
2210 ret = mxt_t6_command(data, MXT_COMMAND_RESET,
2211 MXT_BOOT_VALUE, false);
2213 goto release_firmware;
2215 msleep(MXT_RESET_TIME);
2217 /* Do not need to scan since we know family ID */
2218 ret = mxt_lookup_bootloader_address(data, 0);
2220 goto release_firmware;
2222 mxt_free_input_device(data);
2223 mxt_free_object_table(data);
2225 enable_irq(data->irq);
2228 reinit_completion(&data->bl_completion);
2230 ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false);
2232 /* Bootloader may still be unlocked from previous attempt */
2233 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, false);
2237 dev_info(dev, "Unlocking bootloader\n");
2239 /* Unlock bootloader */
2240 ret = mxt_send_bootloader_cmd(data, true);
2245 while (pos < fw->size) {
2246 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, true);
2250 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
2252 /* Take account of CRC bytes */
2255 /* Write one frame to device */
2256 ret = mxt_bootloader_write(data, fw->data + pos, frame_size);
2260 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true);
2264 /* Back off by 20ms per retry */
2268 dev_err(dev, "Retry count exceeded\n");
2277 if (frame % 50 == 0)
2278 dev_dbg(dev, "Sent %d frames, %d/%zd bytes\n",
2279 frame, pos, fw->size);
2282 /* Wait for flash. */
2283 ret = mxt_wait_for_completion(data, &data->bl_completion,
2288 dev_dbg(dev, "Sent %d frames, %d bytes\n", frame, pos);
2291 * Wait for device to reset. Some bootloader versions do not assert
2292 * the CHG line after bootloading has finished, so ignore potential
2295 mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME);
2297 data->in_bootloader = false;
2300 disable_irq(data->irq);
2302 release_firmware(fw);
2306 static ssize_t mxt_update_fw_store(struct device *dev,
2307 struct device_attribute *attr,
2308 const char *buf, size_t count)
2310 struct mxt_data *data = dev_get_drvdata(dev);
2313 error = mxt_load_fw(dev, MXT_FW_NAME);
2315 dev_err(dev, "The firmware update failed(%d)\n", error);
2318 dev_info(dev, "The firmware update succeeded\n");
2320 error = mxt_initialize(data);
2328 static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
2329 static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
2330 static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
2331 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
2333 static struct attribute *mxt_attrs[] = {
2334 &dev_attr_fw_version.attr,
2335 &dev_attr_hw_version.attr,
2336 &dev_attr_object.attr,
2337 &dev_attr_update_fw.attr,
2341 static const struct attribute_group mxt_attr_group = {
2345 static void mxt_start(struct mxt_data *data)
2348 mxt_write_object(data, data->multitouch, MXT_TOUCH_CTRL, 0x83);
2351 static void mxt_stop(struct mxt_data *data)
2354 mxt_write_object(data, data->multitouch, MXT_TOUCH_CTRL, 0);
2357 static int mxt_input_open(struct input_dev *dev)
2359 struct mxt_data *data = input_get_drvdata(dev);
2366 static void mxt_input_close(struct input_dev *dev)
2368 struct mxt_data *data = input_get_drvdata(dev);
2374 static struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
2376 struct mxt_platform_data *pdata;
2379 int proplen, i, ret;
2381 if (!client->dev.of_node)
2382 return ERR_PTR(-ENODEV);
2384 pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
2386 return ERR_PTR(-ENOMEM);
2388 if (of_find_property(client->dev.of_node, "linux,gpio-keymap",
2390 pdata->t19_num_keys = proplen / sizeof(u32);
2392 keymap = devm_kzalloc(&client->dev,
2393 pdata->t19_num_keys * sizeof(keymap[0]),
2396 return ERR_PTR(-ENOMEM);
2398 for (i = 0; i < pdata->t19_num_keys; i++) {
2399 ret = of_property_read_u32_index(client->dev.of_node,
2400 "linux,gpio-keymap", i, &keycode);
2402 keycode = KEY_RESERVED;
2404 keymap[i] = keycode;
2407 pdata->t19_keymap = keymap;
2413 static struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
2415 dev_dbg(&client->dev, "No platform data specified\n");
2416 return ERR_PTR(-EINVAL);
2420 static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
2422 struct mxt_data *data;
2423 const struct mxt_platform_data *pdata;
2426 pdata = dev_get_platdata(&client->dev);
2428 pdata = mxt_parse_dt(client);
2430 return PTR_ERR(pdata);
2433 data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
2435 dev_err(&client->dev, "Failed to allocate memory\n");
2439 snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
2440 client->adapter->nr, client->addr);
2442 data->client = client;
2443 data->pdata = pdata;
2444 data->irq = client->irq;
2445 i2c_set_clientdata(client, data);
2447 init_completion(&data->bl_completion);
2448 init_completion(&data->reset_completion);
2449 init_completion(&data->crc_completion);
2451 error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
2452 pdata->irqflags | IRQF_ONESHOT,
2453 client->name, data);
2455 dev_err(&client->dev, "Failed to register interrupt\n");
2459 disable_irq(client->irq);
2461 error = mxt_initialize(data);
2465 error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
2467 dev_err(&client->dev, "Failure %d creating sysfs group\n",
2469 goto err_free_object;
2475 mxt_free_input_device(data);
2476 mxt_free_object_table(data);
2478 free_irq(client->irq, data);
2484 static int mxt_remove(struct i2c_client *client)
2486 struct mxt_data *data = i2c_get_clientdata(client);
2488 sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
2489 free_irq(data->irq, data);
2490 mxt_free_input_device(data);
2491 mxt_free_object_table(data);
2497 static int __maybe_unused mxt_suspend(struct device *dev)
2499 struct i2c_client *client = to_i2c_client(dev);
2500 struct mxt_data *data = i2c_get_clientdata(client);
2501 struct input_dev *input_dev = data->input_dev;
2503 mutex_lock(&input_dev->mutex);
2505 if (input_dev->users)
2508 mutex_unlock(&input_dev->mutex);
2513 static int __maybe_unused mxt_resume(struct device *dev)
2515 struct i2c_client *client = to_i2c_client(dev);
2516 struct mxt_data *data = i2c_get_clientdata(client);
2517 struct input_dev *input_dev = data->input_dev;
2519 mxt_soft_reset(data);
2521 mutex_lock(&input_dev->mutex);
2523 if (input_dev->users)
2526 mutex_unlock(&input_dev->mutex);
2531 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
2533 static const struct of_device_id mxt_of_match[] = {
2534 { .compatible = "atmel,maxtouch", },
2537 MODULE_DEVICE_TABLE(of, mxt_of_match);
2539 static const struct i2c_device_id mxt_id[] = {
2540 { "qt602240_ts", 0 },
2541 { "atmel_mxt_ts", 0 },
2542 { "atmel_mxt_tp", 0 },
2546 MODULE_DEVICE_TABLE(i2c, mxt_id);
2548 static struct i2c_driver mxt_driver = {
2550 .name = "atmel_mxt_ts",
2551 .owner = THIS_MODULE,
2552 .of_match_table = of_match_ptr(mxt_of_match),
2556 .remove = mxt_remove,
2560 module_i2c_driver(mxt_driver);
2562 /* Module information */
2563 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
2564 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
2565 MODULE_LICENSE("GPL");