2 * Atmel maXTouch Touchscreen driver
4 * Copyright (C) 2010 Samsung Electronics Co.Ltd
5 * Copyright (C) 2012 Google, Inc.
7 * Author: Joonyoung Shim <jy0922.shim@samsung.com>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/completion.h>
19 #include <linux/delay.h>
20 #include <linux/firmware.h>
21 #include <linux/i2c.h>
22 #include <linux/i2c/atmel_mxt_ts.h>
23 #include <linux/input/mt.h>
24 #include <linux/interrupt.h>
25 #include <linux/slab.h>
33 #define MXT_APP_LOW 0x4a
34 #define MXT_APP_HIGH 0x4b
35 #define MXT_BOOT_LOW 0x24
36 #define MXT_BOOT_HIGH 0x25
39 #define MXT_FW_NAME "maxtouch.fw"
43 #define MXT_FAMILY_ID 0x00
44 #define MXT_VARIANT_ID 0x01
45 #define MXT_VERSION 0x02
46 #define MXT_BUILD 0x03
47 #define MXT_MATRIX_X_SIZE 0x04
48 #define MXT_MATRIX_Y_SIZE 0x05
49 #define MXT_OBJECT_NUM 0x06
50 #define MXT_OBJECT_START 0x07
52 #define MXT_OBJECT_SIZE 6
55 #define MXT_DEBUG_DIAGNOSTIC_T37 37
56 #define MXT_GEN_MESSAGE_T5 5
57 #define MXT_GEN_COMMAND_T6 6
58 #define MXT_GEN_POWER_T7 7
59 #define MXT_GEN_ACQUIRE_T8 8
60 #define MXT_GEN_DATASOURCE_T53 53
61 #define MXT_TOUCH_MULTI_T9 9
62 #define MXT_TOUCH_KEYARRAY_T15 15
63 #define MXT_TOUCH_PROXIMITY_T23 23
64 #define MXT_TOUCH_PROXKEY_T52 52
65 #define MXT_PROCI_GRIPFACE_T20 20
66 #define MXT_PROCG_NOISE_T22 22
67 #define MXT_PROCI_ONETOUCH_T24 24
68 #define MXT_PROCI_TWOTOUCH_T27 27
69 #define MXT_PROCI_GRIP_T40 40
70 #define MXT_PROCI_PALM_T41 41
71 #define MXT_PROCI_TOUCHSUPPRESSION_T42 42
72 #define MXT_PROCI_STYLUS_T47 47
73 #define MXT_PROCG_NOISESUPPRESSION_T48 48
74 #define MXT_SPT_COMMSCONFIG_T18 18
75 #define MXT_SPT_GPIOPWM_T19 19
76 #define MXT_SPT_SELFTEST_T25 25
77 #define MXT_SPT_CTECONFIG_T28 28
78 #define MXT_SPT_USERDATA_T38 38
79 #define MXT_SPT_DIGITIZER_T43 43
80 #define MXT_SPT_MESSAGECOUNT_T44 44
81 #define MXT_SPT_CTECONFIG_T46 46
83 /* MXT_GEN_COMMAND_T6 field */
84 #define MXT_COMMAND_RESET 0
85 #define MXT_COMMAND_BACKUPNV 1
86 #define MXT_COMMAND_CALIBRATE 2
87 #define MXT_COMMAND_REPORTALL 3
88 #define MXT_COMMAND_DIAGNOSTIC 5
90 /* MXT_GEN_POWER_T7 field */
91 #define MXT_POWER_IDLEACQINT 0
92 #define MXT_POWER_ACTVACQINT 1
93 #define MXT_POWER_ACTV2IDLETO 2
95 /* MXT_GEN_ACQUIRE_T8 field */
96 #define MXT_ACQUIRE_CHRGTIME 0
97 #define MXT_ACQUIRE_TCHDRIFT 2
98 #define MXT_ACQUIRE_DRIFTST 3
99 #define MXT_ACQUIRE_TCHAUTOCAL 4
100 #define MXT_ACQUIRE_SYNC 5
101 #define MXT_ACQUIRE_ATCHCALST 6
102 #define MXT_ACQUIRE_ATCHCALSTHR 7
104 /* MXT_TOUCH_MULTI_T9 field */
105 #define MXT_TOUCH_CTRL 0
106 #define MXT_TOUCH_XORIGIN 1
107 #define MXT_TOUCH_YORIGIN 2
108 #define MXT_TOUCH_XSIZE 3
109 #define MXT_TOUCH_YSIZE 4
110 #define MXT_TOUCH_BLEN 6
111 #define MXT_TOUCH_TCHTHR 7
112 #define MXT_TOUCH_TCHDI 8
113 #define MXT_TOUCH_ORIENT 9
114 #define MXT_TOUCH_MOVHYSTI 11
115 #define MXT_TOUCH_MOVHYSTN 12
116 #define MXT_TOUCH_NUMTOUCH 14
117 #define MXT_TOUCH_MRGHYST 15
118 #define MXT_TOUCH_MRGTHR 16
119 #define MXT_TOUCH_AMPHYST 17
120 #define MXT_TOUCH_XRANGE_LSB 18
121 #define MXT_TOUCH_XRANGE_MSB 19
122 #define MXT_TOUCH_YRANGE_LSB 20
123 #define MXT_TOUCH_YRANGE_MSB 21
124 #define MXT_TOUCH_XLOCLIP 22
125 #define MXT_TOUCH_XHICLIP 23
126 #define MXT_TOUCH_YLOCLIP 24
127 #define MXT_TOUCH_YHICLIP 25
128 #define MXT_TOUCH_XEDGECTRL 26
129 #define MXT_TOUCH_XEDGEDIST 27
130 #define MXT_TOUCH_YEDGECTRL 28
131 #define MXT_TOUCH_YEDGEDIST 29
132 #define MXT_TOUCH_JUMPLIMIT 30
134 /* MXT_PROCI_GRIPFACE_T20 field */
135 #define MXT_GRIPFACE_CTRL 0
136 #define MXT_GRIPFACE_XLOGRIP 1
137 #define MXT_GRIPFACE_XHIGRIP 2
138 #define MXT_GRIPFACE_YLOGRIP 3
139 #define MXT_GRIPFACE_YHIGRIP 4
140 #define MXT_GRIPFACE_MAXTCHS 5
141 #define MXT_GRIPFACE_SZTHR1 7
142 #define MXT_GRIPFACE_SZTHR2 8
143 #define MXT_GRIPFACE_SHPTHR1 9
144 #define MXT_GRIPFACE_SHPTHR2 10
145 #define MXT_GRIPFACE_SUPEXTTO 11
147 /* MXT_PROCI_NOISE field */
148 #define MXT_NOISE_CTRL 0
149 #define MXT_NOISE_OUTFLEN 1
150 #define MXT_NOISE_GCAFUL_LSB 3
151 #define MXT_NOISE_GCAFUL_MSB 4
152 #define MXT_NOISE_GCAFLL_LSB 5
153 #define MXT_NOISE_GCAFLL_MSB 6
154 #define MXT_NOISE_ACTVGCAFVALID 7
155 #define MXT_NOISE_NOISETHR 8
156 #define MXT_NOISE_FREQHOPSCALE 10
157 #define MXT_NOISE_FREQ0 11
158 #define MXT_NOISE_FREQ1 12
159 #define MXT_NOISE_FREQ2 13
160 #define MXT_NOISE_FREQ3 14
161 #define MXT_NOISE_FREQ4 15
162 #define MXT_NOISE_IDLEGCAFVALID 16
164 /* MXT_SPT_COMMSCONFIG_T18 */
165 #define MXT_COMMS_CTRL 0
166 #define MXT_COMMS_CMD 1
168 /* MXT_SPT_CTECONFIG_T28 field */
169 #define MXT_CTE_CTRL 0
170 #define MXT_CTE_CMD 1
171 #define MXT_CTE_MODE 2
172 #define MXT_CTE_IDLEGCAFDEPTH 3
173 #define MXT_CTE_ACTVGCAFDEPTH 4
174 #define MXT_CTE_VOLTAGE 5
176 #define MXT_VOLTAGE_DEFAULT 2700000
177 #define MXT_VOLTAGE_STEP 10000
179 /* Define for MXT_GEN_COMMAND_T6 */
180 #define MXT_BOOT_VALUE 0xa5
181 #define MXT_BACKUP_VALUE 0x55
182 #define MXT_BACKUP_TIME 50 /* msec */
183 #define MXT_RESET_TIME 200 /* msec */
184 #define MXT_FW_RESET_TIME 3000 /* msec */
185 #define MXT_FW_CHG_TIMEOUT 300 /* msec */
187 /* Command to unlock bootloader */
188 #define MXT_UNLOCK_CMD_MSB 0xaa
189 #define MXT_UNLOCK_CMD_LSB 0xdc
191 /* Bootloader mode status */
192 #define MXT_WAITING_BOOTLOAD_CMD 0xc0 /* valid 7 6 bit only */
193 #define MXT_WAITING_FRAME_DATA 0x80 /* valid 7 6 bit only */
194 #define MXT_FRAME_CRC_CHECK 0x02
195 #define MXT_FRAME_CRC_FAIL 0x03
196 #define MXT_FRAME_CRC_PASS 0x04
197 #define MXT_APP_CRC_FAIL 0x40 /* valid 7 8 bit only */
198 #define MXT_BOOT_STATUS_MASK 0x3f
201 #define MXT_UNGRIP (1 << 0)
202 #define MXT_SUPPRESS (1 << 1)
203 #define MXT_AMP (1 << 2)
204 #define MXT_VECTOR (1 << 3)
205 #define MXT_MOVE (1 << 4)
206 #define MXT_RELEASE (1 << 5)
207 #define MXT_PRESS (1 << 6)
208 #define MXT_DETECT (1 << 7)
210 /* Touch orient bits */
211 #define MXT_XY_SWITCH (1 << 0)
212 #define MXT_X_INVERT (1 << 1)
213 #define MXT_Y_INVERT (1 << 2)
215 /* Touchscreen absolute values */
216 #define MXT_MAX_AREA 0xff
218 #define MXT_PIXELS_PER_MM 20
234 u8 instances_minus_one;
243 /* Each client has this additional data */
245 struct i2c_client *client;
246 struct input_dev *input_dev;
247 char phys[64]; /* device physical location */
248 const struct mxt_platform_data *pdata;
249 struct mxt_object *object_table;
250 struct mxt_info info;
256 /* Cached parameters from object table */
262 /* for fw update in bootloader */
263 struct completion bl_completion;
266 static size_t mxt_obj_size(const struct mxt_object *obj)
268 return obj->size_minus_one + 1;
271 static size_t mxt_obj_instances(const struct mxt_object *obj)
273 return obj->instances_minus_one + 1;
276 static bool mxt_object_readable(unsigned int type)
279 case MXT_GEN_COMMAND_T6:
280 case MXT_GEN_POWER_T7:
281 case MXT_GEN_ACQUIRE_T8:
282 case MXT_GEN_DATASOURCE_T53:
283 case MXT_TOUCH_MULTI_T9:
284 case MXT_TOUCH_KEYARRAY_T15:
285 case MXT_TOUCH_PROXIMITY_T23:
286 case MXT_TOUCH_PROXKEY_T52:
287 case MXT_PROCI_GRIPFACE_T20:
288 case MXT_PROCG_NOISE_T22:
289 case MXT_PROCI_ONETOUCH_T24:
290 case MXT_PROCI_TWOTOUCH_T27:
291 case MXT_PROCI_GRIP_T40:
292 case MXT_PROCI_PALM_T41:
293 case MXT_PROCI_TOUCHSUPPRESSION_T42:
294 case MXT_PROCI_STYLUS_T47:
295 case MXT_PROCG_NOISESUPPRESSION_T48:
296 case MXT_SPT_COMMSCONFIG_T18:
297 case MXT_SPT_GPIOPWM_T19:
298 case MXT_SPT_SELFTEST_T25:
299 case MXT_SPT_CTECONFIG_T28:
300 case MXT_SPT_USERDATA_T38:
301 case MXT_SPT_DIGITIZER_T43:
302 case MXT_SPT_CTECONFIG_T46:
309 static bool mxt_object_writable(unsigned int type)
312 case MXT_GEN_COMMAND_T6:
313 case MXT_GEN_POWER_T7:
314 case MXT_GEN_ACQUIRE_T8:
315 case MXT_TOUCH_MULTI_T9:
316 case MXT_TOUCH_KEYARRAY_T15:
317 case MXT_TOUCH_PROXIMITY_T23:
318 case MXT_TOUCH_PROXKEY_T52:
319 case MXT_PROCI_GRIPFACE_T20:
320 case MXT_PROCG_NOISE_T22:
321 case MXT_PROCI_ONETOUCH_T24:
322 case MXT_PROCI_TWOTOUCH_T27:
323 case MXT_PROCI_GRIP_T40:
324 case MXT_PROCI_PALM_T41:
325 case MXT_PROCI_TOUCHSUPPRESSION_T42:
326 case MXT_PROCI_STYLUS_T47:
327 case MXT_PROCG_NOISESUPPRESSION_T48:
328 case MXT_SPT_COMMSCONFIG_T18:
329 case MXT_SPT_GPIOPWM_T19:
330 case MXT_SPT_SELFTEST_T25:
331 case MXT_SPT_CTECONFIG_T28:
332 case MXT_SPT_DIGITIZER_T43:
333 case MXT_SPT_CTECONFIG_T46:
340 static void mxt_dump_message(struct device *dev,
341 struct mxt_message *message)
343 dev_dbg(dev, "reportid: %u\tmessage: %*ph\n",
344 message->reportid, 7, message->message);
347 static int mxt_wait_for_chg(struct mxt_data *data, unsigned int timeout_ms)
349 struct device *dev = &data->client->dev;
350 struct completion *comp = &data->bl_completion;
351 unsigned long timeout = msecs_to_jiffies(timeout_ms);
354 ret = wait_for_completion_interruptible_timeout(comp, timeout);
357 } else if (ret == 0) {
358 dev_err(dev, "Wait for completion timed out.\n");
364 static int mxt_check_bootloader(struct mxt_data *data, unsigned int state)
366 struct i2c_client *client = data->client;
371 if (state != MXT_WAITING_BOOTLOAD_CMD) {
373 * In application update mode, the interrupt
374 * line signals state transitions. We must wait for the
375 * CHG assertion before reading the status byte.
376 * Once the status byte has been read, the line is deasserted.
378 ret = mxt_wait_for_chg(data, MXT_FW_CHG_TIMEOUT);
381 * TODO: handle -ERESTARTSYS better by terminating
382 * fw update process before returning to userspace
383 * by writing length 0x000 to device (iff we are in
384 * WAITING_FRAME_DATA state).
386 dev_err(&client->dev, "Update wait error %d\n", ret);
391 if (i2c_master_recv(client, &val, 1) != 1) {
392 dev_err(&client->dev, "%s: i2c recv failed\n", __func__);
397 case MXT_WAITING_BOOTLOAD_CMD:
398 case MXT_WAITING_FRAME_DATA:
399 val &= ~MXT_BOOT_STATUS_MASK;
401 case MXT_FRAME_CRC_PASS:
402 if (val == MXT_FRAME_CRC_CHECK)
410 dev_err(&client->dev, "Unvalid bootloader mode state\n");
417 static int mxt_unlock_bootloader(struct i2c_client *client)
421 buf[0] = MXT_UNLOCK_CMD_LSB;
422 buf[1] = MXT_UNLOCK_CMD_MSB;
424 if (i2c_master_send(client, buf, 2) != 2) {
425 dev_err(&client->dev, "%s: i2c send failed\n", __func__);
432 static int mxt_fw_write(struct i2c_client *client,
433 const u8 *data, unsigned int frame_size)
435 if (i2c_master_send(client, data, frame_size) != frame_size) {
436 dev_err(&client->dev, "%s: i2c send failed\n", __func__);
443 static int __mxt_read_reg(struct i2c_client *client,
444 u16 reg, u16 len, void *val)
446 struct i2c_msg xfer[2];
451 buf[1] = (reg >> 8) & 0xff;
454 xfer[0].addr = client->addr;
460 xfer[1].addr = client->addr;
461 xfer[1].flags = I2C_M_RD;
465 ret = i2c_transfer(client->adapter, xfer, 2);
471 dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
478 static int mxt_read_reg(struct i2c_client *client, u16 reg, u8 *val)
480 return __mxt_read_reg(client, reg, 1, val);
483 static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
491 buf = kmalloc(count, GFP_KERNEL);
496 buf[1] = (reg >> 8) & 0xff;
497 memcpy(&buf[2], val, len);
499 ret = i2c_master_send(client, buf, count);
505 dev_err(&client->dev, "%s: i2c send failed (%d)\n",
513 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
515 return __mxt_write_reg(client, reg, 1, &val);
518 static struct mxt_object *
519 mxt_get_object(struct mxt_data *data, u8 type)
521 struct mxt_object *object;
524 for (i = 0; i < data->info.object_num; i++) {
525 object = data->object_table + i;
526 if (object->type == type)
530 dev_err(&data->client->dev, "Invalid object type\n");
534 static int mxt_read_message(struct mxt_data *data,
535 struct mxt_message *message)
537 struct mxt_object *object;
540 object = mxt_get_object(data, MXT_GEN_MESSAGE_T5);
544 reg = object->start_address;
545 return __mxt_read_reg(data->client, reg,
546 sizeof(struct mxt_message), message);
549 static int mxt_write_object(struct mxt_data *data,
550 u8 type, u8 offset, u8 val)
552 struct mxt_object *object;
555 object = mxt_get_object(data, type);
556 if (!object || offset >= mxt_obj_size(object))
559 reg = object->start_address;
560 return mxt_write_reg(data->client, reg + offset, val);
563 static void mxt_input_button(struct mxt_data *data, struct mxt_message *message)
565 struct input_dev *input = data->input_dev;
566 const struct mxt_platform_data *pdata = data->pdata;
570 /* Active-low switch */
571 for (i = 0; i < pdata->t19_num_keys; i++) {
572 if (pdata->t19_keymap[i] == KEY_RESERVED)
574 button = !(message->message[0] & (1 << i));
575 input_report_key(input, pdata->t19_keymap[i], button);
579 static void mxt_input_touchevent(struct mxt_data *data,
580 struct mxt_message *message, int id)
582 struct device *dev = &data->client->dev;
583 u8 status = message->message[0];
584 struct input_dev *input_dev = data->input_dev;
590 x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf);
591 y = (message->message[2] << 4) | ((message->message[3] & 0xf));
592 if (data->max_x < 1024)
594 if (data->max_y < 1024)
597 area = message->message[4];
598 pressure = message->message[5];
601 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
603 (status & MXT_DETECT) ? 'D' : '.',
604 (status & MXT_PRESS) ? 'P' : '.',
605 (status & MXT_RELEASE) ? 'R' : '.',
606 (status & MXT_MOVE) ? 'M' : '.',
607 (status & MXT_VECTOR) ? 'V' : '.',
608 (status & MXT_AMP) ? 'A' : '.',
609 (status & MXT_SUPPRESS) ? 'S' : '.',
610 (status & MXT_UNGRIP) ? 'U' : '.',
611 x, y, area, pressure);
613 input_mt_slot(input_dev, id);
614 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
615 status & MXT_DETECT);
617 if (status & MXT_DETECT) {
618 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
619 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
620 input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
621 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
625 static unsigned mxt_extract_T6_csum(const u8 *csum)
627 return csum[0] | (csum[1] << 8) | (csum[2] << 16);
630 static bool mxt_is_T9_message(struct mxt_data *data, struct mxt_message *msg)
632 u8 id = msg->reportid;
633 return (id >= data->T9_reportid_min && id <= data->T9_reportid_max);
636 static irqreturn_t mxt_process_messages_until_invalid(struct mxt_data *data)
638 struct mxt_message message;
639 const u8 *payload = &message.message[0];
640 struct device *dev = &data->client->dev;
642 bool update_input = false;
645 if (mxt_read_message(data, &message)) {
646 dev_err(dev, "Failed to read message\n");
650 reportid = message.reportid;
652 if (reportid == data->T6_reportid) {
653 u8 status = payload[0];
654 unsigned csum = mxt_extract_T6_csum(&payload[1]);
655 dev_dbg(dev, "Status: %02x Config Checksum: %06x\n",
657 } else if (mxt_is_T9_message(data, &message)) {
658 int id = reportid - data->T9_reportid_min;
659 mxt_input_touchevent(data, &message, id);
661 } else if (message.reportid == data->T19_reportid) {
662 mxt_input_button(data, &message);
665 mxt_dump_message(dev, &message);
667 } while (reportid != 0xff);
670 input_mt_report_pointer_emulation(data->input_dev, false);
671 input_sync(data->input_dev);
677 static irqreturn_t mxt_interrupt(int irq, void *dev_id)
679 struct mxt_data *data = dev_id;
681 if (data->in_bootloader) {
682 /* bootloader state transition completion */
683 complete(&data->bl_completion);
687 return mxt_process_messages_until_invalid(data);
690 static int mxt_check_reg_init(struct mxt_data *data)
692 const struct mxt_platform_data *pdata = data->pdata;
693 struct mxt_object *object;
694 struct device *dev = &data->client->dev;
699 if (!pdata->config) {
700 dev_dbg(dev, "No cfg data defined, skipping reg init\n");
704 for (i = 0; i < data->info.object_num; i++) {
705 object = data->object_table + i;
707 if (!mxt_object_writable(object->type))
710 size = mxt_obj_size(object) * mxt_obj_instances(object);
711 if (index + size > pdata->config_length) {
712 dev_err(dev, "Not enough config data!\n");
716 ret = __mxt_write_reg(data->client, object->start_address,
717 size, &pdata->config[index]);
726 static int mxt_make_highchg(struct mxt_data *data)
728 struct device *dev = &data->client->dev;
729 struct mxt_message message;
733 /* Read dummy message to make high CHG pin */
735 error = mxt_read_message(data, &message);
738 } while (message.reportid != 0xff && --count);
741 dev_err(dev, "CHG pin isn't cleared\n");
748 static int mxt_get_info(struct mxt_data *data)
750 struct i2c_client *client = data->client;
751 struct mxt_info *info = &data->info;
754 /* Read 7-byte info block starting at address 0 */
755 error = __mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
762 static int mxt_get_object_table(struct mxt_data *data)
764 struct i2c_client *client = data->client;
770 table_size = data->info.object_num * sizeof(struct mxt_object);
771 error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
776 /* Valid Report IDs start counting from 1 */
778 for (i = 0; i < data->info.object_num; i++) {
779 struct mxt_object *object = data->object_table + i;
782 le16_to_cpus(&object->start_address);
784 if (object->num_report_ids) {
786 reportid += object->num_report_ids *
787 mxt_obj_instances(object);
788 max_id = reportid - 1;
794 dev_dbg(&data->client->dev,
795 "Type %2d Start %3d Size %3zd Instances %2zd ReportIDs %3u : %3u\n",
796 object->type, object->start_address,
797 mxt_obj_size(object), mxt_obj_instances(object),
800 switch (object->type) {
801 case MXT_GEN_COMMAND_T6:
802 data->T6_reportid = min_id;
804 case MXT_TOUCH_MULTI_T9:
805 data->T9_reportid_min = min_id;
806 data->T9_reportid_max = max_id;
808 case MXT_SPT_GPIOPWM_T19:
809 data->T19_reportid = min_id;
817 static void mxt_free_object_table(struct mxt_data *data)
819 kfree(data->object_table);
820 data->object_table = NULL;
821 data->T6_reportid = 0;
822 data->T9_reportid_min = 0;
823 data->T9_reportid_max = 0;
824 data->T19_reportid = 0;
827 static int mxt_initialize(struct mxt_data *data)
829 struct i2c_client *client = data->client;
830 struct mxt_info *info = &data->info;
834 error = mxt_get_info(data);
838 data->object_table = kcalloc(info->object_num,
839 sizeof(struct mxt_object),
841 if (!data->object_table) {
842 dev_err(&client->dev, "Failed to allocate memory\n");
846 /* Get object table information */
847 error = mxt_get_object_table(data);
849 goto err_free_object_table;
851 /* Check register init values */
852 error = mxt_check_reg_init(data);
854 goto err_free_object_table;
856 /* Backup to memory */
857 mxt_write_object(data, MXT_GEN_COMMAND_T6,
858 MXT_COMMAND_BACKUPNV,
860 msleep(MXT_BACKUP_TIME);
863 mxt_write_object(data, MXT_GEN_COMMAND_T6,
864 MXT_COMMAND_RESET, 1);
865 msleep(MXT_RESET_TIME);
867 /* Update matrix size at info struct */
868 error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, &val);
870 goto err_free_object_table;
871 info->matrix_xsize = val;
873 error = mxt_read_reg(client, MXT_MATRIX_Y_SIZE, &val);
875 goto err_free_object_table;
876 info->matrix_ysize = val;
878 dev_info(&client->dev,
879 "Family ID: %u Variant ID: %u Major.Minor.Build: %u.%u.%02X\n",
880 info->family_id, info->variant_id, info->version >> 4,
881 info->version & 0xf, info->build);
883 dev_info(&client->dev,
884 "Matrix X Size: %u Matrix Y Size: %u Object Num: %u\n",
885 info->matrix_xsize, info->matrix_ysize,
890 err_free_object_table:
891 mxt_free_object_table(data);
895 static void mxt_calc_resolution(struct mxt_data *data)
897 unsigned int max_x = data->pdata->x_size - 1;
898 unsigned int max_y = data->pdata->y_size - 1;
900 if (data->pdata->orient & MXT_XY_SWITCH) {
909 /* Firmware Version is returned as Major.Minor.Build */
910 static ssize_t mxt_fw_version_show(struct device *dev,
911 struct device_attribute *attr, char *buf)
913 struct mxt_data *data = dev_get_drvdata(dev);
914 struct mxt_info *info = &data->info;
915 return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
916 info->version >> 4, info->version & 0xf, info->build);
919 /* Hardware Version is returned as FamilyID.VariantID */
920 static ssize_t mxt_hw_version_show(struct device *dev,
921 struct device_attribute *attr, char *buf)
923 struct mxt_data *data = dev_get_drvdata(dev);
924 struct mxt_info *info = &data->info;
925 return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
926 info->family_id, info->variant_id);
929 static ssize_t mxt_show_instance(char *buf, int count,
930 struct mxt_object *object, int instance,
935 if (mxt_obj_instances(object) > 1)
936 count += scnprintf(buf + count, PAGE_SIZE - count,
937 "Instance %u\n", instance);
939 for (i = 0; i < mxt_obj_size(object); i++)
940 count += scnprintf(buf + count, PAGE_SIZE - count,
941 "\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
942 count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
947 static ssize_t mxt_object_show(struct device *dev,
948 struct device_attribute *attr, char *buf)
950 struct mxt_data *data = dev_get_drvdata(dev);
951 struct mxt_object *object;
957 /* Pre-allocate buffer large enough to hold max sized object. */
958 obuf = kmalloc(256, GFP_KERNEL);
963 for (i = 0; i < data->info.object_num; i++) {
964 object = data->object_table + i;
966 if (!mxt_object_readable(object->type))
969 count += scnprintf(buf + count, PAGE_SIZE - count,
970 "T%u:\n", object->type);
972 for (j = 0; j < mxt_obj_instances(object); j++) {
973 u16 size = mxt_obj_size(object);
974 u16 addr = object->start_address + j * size;
976 error = __mxt_read_reg(data->client, addr, size, obuf);
980 count = mxt_show_instance(buf, count, object, j, obuf);
986 return error ?: count;
989 static int mxt_load_fw(struct device *dev, const char *fn)
991 struct mxt_data *data = dev_get_drvdata(dev);
992 struct i2c_client *client = data->client;
993 const struct firmware *fw = NULL;
994 unsigned int frame_size;
995 unsigned int pos = 0;
998 ret = request_firmware(&fw, fn, dev);
1000 dev_err(dev, "Unable to open firmware %s\n", fn);
1004 /* Change to the bootloader mode */
1005 data->in_bootloader = true;
1007 mxt_write_object(data, MXT_GEN_COMMAND_T6,
1008 MXT_COMMAND_RESET, MXT_BOOT_VALUE);
1009 msleep(MXT_RESET_TIME);
1011 /* Change to slave address of bootloader */
1012 if (client->addr == MXT_APP_LOW)
1013 client->addr = MXT_BOOT_LOW;
1015 client->addr = MXT_BOOT_HIGH;
1017 reinit_completion(&data->bl_completion);
1019 ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD);
1023 /* Unlock bootloader */
1024 mxt_unlock_bootloader(client);
1026 while (pos < fw->size) {
1027 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA);
1031 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
1033 /* We should add 2 at frame size as the the firmware data is not
1034 * included the CRC bytes.
1038 /* Write one frame to device */
1039 mxt_fw_write(client, fw->data + pos, frame_size);
1041 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS);
1047 dev_dbg(dev, "Updated %d bytes / %zd bytes\n", pos, fw->size);
1050 /* Wait for flash. */
1051 ret = mxt_wait_for_chg(data, MXT_FW_RESET_TIME);
1056 * Wait for device to reset. Some bootloader versions do not assert
1057 * the CHG line after bootloading has finished, so ignore potential
1060 mxt_wait_for_chg(data, MXT_FW_RESET_TIME);
1062 data->in_bootloader = false;
1065 disable_irq(data->irq);
1066 release_firmware(fw);
1068 /* Change to slave address of application */
1069 if (client->addr == MXT_BOOT_LOW)
1070 client->addr = MXT_APP_LOW;
1072 client->addr = MXT_APP_HIGH;
1077 static ssize_t mxt_update_fw_store(struct device *dev,
1078 struct device_attribute *attr,
1079 const char *buf, size_t count)
1081 struct mxt_data *data = dev_get_drvdata(dev);
1084 error = mxt_load_fw(dev, MXT_FW_NAME);
1086 dev_err(dev, "The firmware update failed(%d)\n", error);
1089 dev_dbg(dev, "The firmware update succeeded\n");
1090 mxt_free_object_table(data);
1092 mxt_initialize(data);
1094 enable_irq(data->irq);
1096 error = mxt_make_highchg(data);
1104 static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
1105 static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
1106 static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
1107 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
1109 static struct attribute *mxt_attrs[] = {
1110 &dev_attr_fw_version.attr,
1111 &dev_attr_hw_version.attr,
1112 &dev_attr_object.attr,
1113 &dev_attr_update_fw.attr,
1117 static const struct attribute_group mxt_attr_group = {
1121 static void mxt_start(struct mxt_data *data)
1124 mxt_write_object(data,
1125 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83);
1128 static void mxt_stop(struct mxt_data *data)
1131 mxt_write_object(data,
1132 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0);
1135 static int mxt_input_open(struct input_dev *dev)
1137 struct mxt_data *data = input_get_drvdata(dev);
1144 static void mxt_input_close(struct input_dev *dev)
1146 struct mxt_data *data = input_get_drvdata(dev);
1151 static int mxt_probe(struct i2c_client *client,
1152 const struct i2c_device_id *id)
1154 const struct mxt_platform_data *pdata = dev_get_platdata(&client->dev);
1155 struct mxt_data *data;
1156 struct input_dev *input_dev;
1158 unsigned int num_mt_slots;
1159 unsigned int mt_flags = 0;
1165 data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
1166 input_dev = input_allocate_device();
1167 if (!data || !input_dev) {
1168 dev_err(&client->dev, "Failed to allocate memory\n");
1173 input_dev->name = "Atmel maXTouch Touchscreen";
1174 snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
1175 client->adapter->nr, client->addr);
1177 input_dev->phys = data->phys;
1179 input_dev->id.bustype = BUS_I2C;
1180 input_dev->dev.parent = &client->dev;
1181 input_dev->open = mxt_input_open;
1182 input_dev->close = mxt_input_close;
1184 data->client = client;
1185 data->input_dev = input_dev;
1186 data->pdata = pdata;
1187 data->irq = client->irq;
1189 init_completion(&data->bl_completion);
1191 mxt_calc_resolution(data);
1193 error = mxt_initialize(data);
1197 __set_bit(EV_ABS, input_dev->evbit);
1198 __set_bit(EV_KEY, input_dev->evbit);
1199 __set_bit(BTN_TOUCH, input_dev->keybit);
1201 if (pdata->t19_num_keys) {
1202 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
1204 for (i = 0; i < pdata->t19_num_keys; i++)
1205 if (pdata->t19_keymap[i] != KEY_RESERVED)
1206 input_set_capability(input_dev, EV_KEY,
1207 pdata->t19_keymap[i]);
1209 mt_flags |= INPUT_MT_POINTER;
1211 input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
1212 input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
1213 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
1215 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
1218 input_dev->name = "Atmel maXTouch Touchpad";
1221 /* For single touch */
1222 input_set_abs_params(input_dev, ABS_X,
1223 0, data->max_x, 0, 0);
1224 input_set_abs_params(input_dev, ABS_Y,
1225 0, data->max_y, 0, 0);
1226 input_set_abs_params(input_dev, ABS_PRESSURE,
1229 /* For multi touch */
1230 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
1231 error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags);
1233 goto err_free_object;
1234 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1235 0, MXT_MAX_AREA, 0, 0);
1236 input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1237 0, data->max_x, 0, 0);
1238 input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1239 0, data->max_y, 0, 0);
1240 input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1243 input_set_drvdata(input_dev, data);
1244 i2c_set_clientdata(client, data);
1246 error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
1247 pdata->irqflags | IRQF_ONESHOT,
1248 client->name, data);
1250 dev_err(&client->dev, "Failed to register interrupt\n");
1251 goto err_free_object;
1254 error = mxt_make_highchg(data);
1258 error = input_register_device(input_dev);
1262 error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
1264 goto err_unregister_device;
1268 err_unregister_device:
1269 input_unregister_device(input_dev);
1272 free_irq(client->irq, data);
1274 kfree(data->object_table);
1276 input_free_device(input_dev);
1281 static int mxt_remove(struct i2c_client *client)
1283 struct mxt_data *data = i2c_get_clientdata(client);
1285 sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
1286 free_irq(data->irq, data);
1287 input_unregister_device(data->input_dev);
1288 kfree(data->object_table);
1294 #ifdef CONFIG_PM_SLEEP
1295 static int mxt_suspend(struct device *dev)
1297 struct i2c_client *client = to_i2c_client(dev);
1298 struct mxt_data *data = i2c_get_clientdata(client);
1299 struct input_dev *input_dev = data->input_dev;
1301 mutex_lock(&input_dev->mutex);
1303 if (input_dev->users)
1306 mutex_unlock(&input_dev->mutex);
1311 static int mxt_resume(struct device *dev)
1313 struct i2c_client *client = to_i2c_client(dev);
1314 struct mxt_data *data = i2c_get_clientdata(client);
1315 struct input_dev *input_dev = data->input_dev;
1318 mxt_write_object(data, MXT_GEN_COMMAND_T6,
1319 MXT_COMMAND_RESET, 1);
1321 msleep(MXT_RESET_TIME);
1323 mutex_lock(&input_dev->mutex);
1325 if (input_dev->users)
1328 mutex_unlock(&input_dev->mutex);
1334 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
1336 static const struct i2c_device_id mxt_id[] = {
1337 { "qt602240_ts", 0 },
1338 { "atmel_mxt_ts", 0 },
1339 { "atmel_mxt_tp", 0 },
1343 MODULE_DEVICE_TABLE(i2c, mxt_id);
1345 static struct i2c_driver mxt_driver = {
1347 .name = "atmel_mxt_ts",
1348 .owner = THIS_MODULE,
1352 .remove = mxt_remove,
1356 module_i2c_driver(mxt_driver);
1358 /* Module information */
1359 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
1360 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
1361 MODULE_LICENSE("GPL");