projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Input: atmel_mxt_ts - handle bootloader previously unlocked
[deliverable/linux.git] / drivers / input / touchscreen / atmel_mxt_ts.c
1 /*
2 * Atmel maXTouch Touchscreen driver
3 *
4 * Copyright (C) 2010 Samsung Electronics Co.Ltd
5 * Copyright (C) 2011-2014 Atmel Corporation
6 * Copyright (C) 2012 Google, Inc.
7 *
8 * Author: Joonyoung Shim <jy0922.shim@samsung.com>
9 *
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.
14 *
15 */
16
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>
26 #include <linux/of.h>
27 #include <linux/slab.h>
28
29 /* Version */
30 #define MXT_VER_20 20
31 #define MXT_VER_21 21
32 #define MXT_VER_22 22
33
34 /* Firmware files */
35 #define MXT_FW_NAME "maxtouch.fw"
36 #define MXT_CFG_NAME "maxtouch.cfg"
37 #define MXT_CFG_MAGIC "OBP_RAW V1"
38
39 /* Registers */
40 #define MXT_INFO 0x00
41 #define MXT_FAMILY_ID 0x00
42 #define MXT_VARIANT_ID 0x01
43 #define MXT_VERSION 0x02
44 #define MXT_BUILD 0x03
45 #define MXT_MATRIX_X_SIZE 0x04
46 #define MXT_MATRIX_Y_SIZE 0x05
47 #define MXT_OBJECT_NUM 0x06
48 #define MXT_OBJECT_START 0x07
49
50 #define MXT_OBJECT_SIZE 6
51 #define MXT_INFO_CHECKSUM_SIZE 3
52 #define MXT_MAX_BLOCK_WRITE 256
53
54 /* Object types */
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
82
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
89
90 /* Define for T6 status byte */
91 #define MXT_T6_STATUS_RESET (1 << 7)
92
93 /* MXT_GEN_POWER_T7 field */
94 #define MXT_POWER_IDLEACQINT 0
95 #define MXT_POWER_ACTVACQINT 1
96 #define MXT_POWER_ACTV2IDLETO 2
97
98 /* MXT_GEN_ACQUIRE_T8 field */
99 #define MXT_ACQUIRE_CHRGTIME 0
100 #define MXT_ACQUIRE_TCHDRIFT 2
101 #define MXT_ACQUIRE_DRIFTST 3
102 #define MXT_ACQUIRE_TCHAUTOCAL 4
103 #define MXT_ACQUIRE_SYNC 5
104 #define MXT_ACQUIRE_ATCHCALST 6
105 #define MXT_ACQUIRE_ATCHCALSTHR 7
106
107 /* MXT_TOUCH_MULTI_T9 field */
108 #define MXT_TOUCH_CTRL 0
109 #define MXT_T9_ORIENT 9
110 #define MXT_T9_RANGE 18
111
112 /* MXT_TOUCH_MULTI_T9 status */
113 #define MXT_T9_UNGRIP (1 << 0)
114 #define MXT_T9_SUPPRESS (1 << 1)
115 #define MXT_T9_AMP (1 << 2)
116 #define MXT_T9_VECTOR (1 << 3)
117 #define MXT_T9_MOVE (1 << 4)
118 #define MXT_T9_RELEASE (1 << 5)
119 #define MXT_T9_PRESS (1 << 6)
120 #define MXT_T9_DETECT (1 << 7)
121
122 struct t9_range {
123 u16 x;
124 u16 y;
125 } __packed;
126
127 /* MXT_TOUCH_MULTI_T9 orient */
128 #define MXT_T9_ORIENT_SWITCH (1 << 0)
129
130 /* MXT_PROCI_GRIPFACE_T20 field */
131 #define MXT_GRIPFACE_CTRL 0
132 #define MXT_GRIPFACE_XLOGRIP 1
133 #define MXT_GRIPFACE_XHIGRIP 2
134 #define MXT_GRIPFACE_YLOGRIP 3
135 #define MXT_GRIPFACE_YHIGRIP 4
136 #define MXT_GRIPFACE_MAXTCHS 5
137 #define MXT_GRIPFACE_SZTHR1 7
138 #define MXT_GRIPFACE_SZTHR2 8
139 #define MXT_GRIPFACE_SHPTHR1 9
140 #define MXT_GRIPFACE_SHPTHR2 10
141 #define MXT_GRIPFACE_SUPEXTTO 11
142
143 /* MXT_PROCI_NOISE field */
144 #define MXT_NOISE_CTRL 0
145 #define MXT_NOISE_OUTFLEN 1
146 #define MXT_NOISE_GCAFUL_LSB 3
147 #define MXT_NOISE_GCAFUL_MSB 4
148 #define MXT_NOISE_GCAFLL_LSB 5
149 #define MXT_NOISE_GCAFLL_MSB 6
150 #define MXT_NOISE_ACTVGCAFVALID 7
151 #define MXT_NOISE_NOISETHR 8
152 #define MXT_NOISE_FREQHOPSCALE 10
153 #define MXT_NOISE_FREQ0 11
154 #define MXT_NOISE_FREQ1 12
155 #define MXT_NOISE_FREQ2 13
156 #define MXT_NOISE_FREQ3 14
157 #define MXT_NOISE_FREQ4 15
158 #define MXT_NOISE_IDLEGCAFVALID 16
159
160 /* MXT_SPT_COMMSCONFIG_T18 */
161 #define MXT_COMMS_CTRL 0
162 #define MXT_COMMS_CMD 1
163
164 /* MXT_SPT_CTECONFIG_T28 field */
165 #define MXT_CTE_CTRL 0
166 #define MXT_CTE_CMD 1
167 #define MXT_CTE_MODE 2
168 #define MXT_CTE_IDLEGCAFDEPTH 3
169 #define MXT_CTE_ACTVGCAFDEPTH 4
170 #define MXT_CTE_VOLTAGE 5
171
172 #define MXT_VOLTAGE_DEFAULT 2700000
173 #define MXT_VOLTAGE_STEP 10000
174
175 /* Define for MXT_GEN_COMMAND_T6 */
176 #define MXT_BOOT_VALUE 0xa5
177 #define MXT_RESET_VALUE 0x01
178 #define MXT_BACKUP_VALUE 0x55
179
180 /* Delay times */
181 #define MXT_BACKUP_TIME 50 /* msec */
182 #define MXT_RESET_TIME 200 /* msec */
183 #define MXT_RESET_TIMEOUT 3000 /* msec */
184 #define MXT_CRC_TIMEOUT 1000 /* msec */
185 #define MXT_FW_RESET_TIME 3000 /* msec */
186 #define MXT_FW_CHG_TIMEOUT 300 /* msec */
187
188 /* Command to unlock bootloader */
189 #define MXT_UNLOCK_CMD_MSB 0xaa
190 #define MXT_UNLOCK_CMD_LSB 0xdc
191
192 /* Bootloader mode status */
193 #define MXT_WAITING_BOOTLOAD_CMD 0xc0 /* valid 7 6 bit only */
194 #define MXT_WAITING_FRAME_DATA 0x80 /* valid 7 6 bit only */
195 #define MXT_FRAME_CRC_CHECK 0x02
196 #define MXT_FRAME_CRC_FAIL 0x03
197 #define MXT_FRAME_CRC_PASS 0x04
198 #define MXT_APP_CRC_FAIL 0x40 /* valid 7 8 bit only */
199 #define MXT_BOOT_STATUS_MASK 0x3f
200 #define MXT_BOOT_EXTENDED_ID (1 << 5)
201 #define MXT_BOOT_ID_MASK 0x1f
202
203 /* Touchscreen absolute values */
204 #define MXT_MAX_AREA 0xff
205
206 #define MXT_PIXELS_PER_MM 20
207
208 struct mxt_info {
209 u8 family_id;
210 u8 variant_id;
211 u8 version;
212 u8 build;
213 u8 matrix_xsize;
214 u8 matrix_ysize;
215 u8 object_num;
216 };
217
218 struct mxt_object {
219 u8 type;
220 u16 start_address;
221 u8 size_minus_one;
222 u8 instances_minus_one;
223 u8 num_report_ids;
224 } __packed;
225
226 struct mxt_message {
227 u8 reportid;
228 u8 message[7];
229 };
230
231 /* Each client has this additional data */
232 struct mxt_data {
233 struct i2c_client *client;
234 struct input_dev *input_dev;
235 char phys[64]; /* device physical location */
236 const struct mxt_platform_data *pdata;
237 struct mxt_object *object_table;
238 struct mxt_info info;
239 unsigned int irq;
240 unsigned int max_x;
241 unsigned int max_y;
242 bool in_bootloader;
243 u16 mem_size;
244 u32 config_crc;
245 u32 info_crc;
246 u8 bootloader_addr;
247
248 /* Cached parameters from object table */
249 u8 T6_reportid;
250 u16 T6_address;
251 u16 T7_address;
252 u8 T9_reportid_min;
253 u8 T9_reportid_max;
254 u8 T19_reportid;
255
256 /* for fw update in bootloader */
257 struct completion bl_completion;
258
259 /* for reset handling */
260 struct completion reset_completion;
261
262 /* for config update handling */
263 struct completion crc_completion;
264 };
265
266 static size_t mxt_obj_size(const struct mxt_object *obj)
267 {
268 return obj->size_minus_one + 1;
269 }
270
271 static size_t mxt_obj_instances(const struct mxt_object *obj)
272 {
273 return obj->instances_minus_one + 1;
274 }
275
276 static bool mxt_object_readable(unsigned int type)
277 {
278 switch (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:
303 return true;
304 default:
305 return false;
306 }
307 }
308
309 static void mxt_dump_message(struct device *dev,
310 struct mxt_message *message)
311 {
312 dev_dbg(dev, "reportid: %u\tmessage: %*ph\n",
313 message->reportid, 7, message->message);
314 }
315
316 static int mxt_wait_for_completion(struct mxt_data *data,
317 struct completion *comp,
318 unsigned int timeout_ms)
319 {
320 struct device *dev = &data->client->dev;
321 unsigned long timeout = msecs_to_jiffies(timeout_ms);
322 long ret;
323
324 ret = wait_for_completion_interruptible_timeout(comp, timeout);
325 if (ret < 0) {
326 return ret;
327 } else if (ret == 0) {
328 dev_err(dev, "Wait for completion timed out.\n");
329 return -ETIMEDOUT;
330 }
331 return 0;
332 }
333
334 static int mxt_bootloader_read(struct mxt_data *data,
335 u8 *val, unsigned int count)
336 {
337 int ret;
338 struct i2c_msg msg;
339
340 msg.addr = data->bootloader_addr;
341 msg.flags = data->client->flags & I2C_M_TEN;
342 msg.flags |= I2C_M_RD;
343 msg.len = count;
344 msg.buf = val;
345
346 ret = i2c_transfer(data->client->adapter, &msg, 1);
347
348 if (ret == 1) {
349 ret = 0;
350 } else {
351 ret = ret < 0 ? ret : -EIO;
352 dev_err(&data->client->dev, "%s: i2c recv failed (%d)\n",
353 __func__, ret);
354 }
355
356 return ret;
357 }
358
359 static int mxt_bootloader_write(struct mxt_data *data,
360 const u8 * const val, unsigned int count)
361 {
362 int ret;
363 struct i2c_msg msg;
364
365 msg.addr = data->bootloader_addr;
366 msg.flags = data->client->flags & I2C_M_TEN;
367 msg.len = count;
368 msg.buf = (u8 *)val;
369
370 ret = i2c_transfer(data->client->adapter, &msg, 1);
371 if (ret == 1) {
372 ret = 0;
373 } else {
374 ret = ret < 0 ? ret : -EIO;
375 dev_err(&data->client->dev, "%s: i2c send failed (%d)\n",
376 __func__, ret);
377 }
378
379 return ret;
380 }
381
382 static int mxt_lookup_bootloader_address(struct mxt_data *data)
383 {
384 u8 appmode = data->client->addr;
385 u8 bootloader;
386
387 switch (appmode) {
388 case 0x4a:
389 case 0x4b:
390 case 0x4c:
391 case 0x4d:
392 case 0x5a:
393 case 0x5b:
394 bootloader = appmode - 0x26;
395 break;
396 default:
397 dev_err(&data->client->dev,
398 "Appmode i2c address 0x%02x not found\n",
399 appmode);
400 return -EINVAL;
401 }
402
403 data->bootloader_addr = bootloader;
404 return 0;
405 }
406
407 static int mxt_probe_bootloader(struct mxt_data *data)
408 {
409 struct device *dev = &data->client->dev;
410 int ret;
411 u8 val;
412 bool crc_failure;
413
414 ret = mxt_lookup_bootloader_address(data);
415 if (ret)
416 return ret;
417
418 ret = mxt_bootloader_read(data, &val, 1);
419 if (ret)
420 return ret;
421
422 /* Check app crc fail mode */
423 crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL;
424
425 dev_err(dev, "Detected bootloader, status:%02X%s\n",
426 val, crc_failure ? ", APP_CRC_FAIL" : "");
427
428 return 0;
429 }
430
431 static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
432 {
433 struct device *dev = &data->client->dev;
434 u8 buf[3];
435
436 if (val & MXT_BOOT_EXTENDED_ID) {
437 if (mxt_bootloader_read(data, &buf[0], 3) != 0) {
438 dev_err(dev, "%s: i2c failure\n", __func__);
439 return val;
440 }
441
442 dev_dbg(dev, "Bootloader ID:%d Version:%d\n", buf[1], buf[2]);
443
444 return buf[0];
445 } else {
446 dev_dbg(dev, "Bootloader ID:%d\n", val & MXT_BOOT_ID_MASK);
447
448 return val;
449 }
450 }
451
452 static int mxt_check_bootloader(struct mxt_data *data, unsigned int state,
453 bool wait)
454 {
455 struct device *dev = &data->client->dev;
456 u8 val;
457 int ret;
458
459 recheck:
460 if (wait) {
461 /*
462 * In application update mode, the interrupt
463 * line signals state transitions. We must wait for the
464 * CHG assertion before reading the status byte.
465 * Once the status byte has been read, the line is deasserted.
466 */
467 ret = mxt_wait_for_completion(data, &data->bl_completion,
468 MXT_FW_CHG_TIMEOUT);
469 if (ret) {
470 /*
471 * TODO: handle -ERESTARTSYS better by terminating
472 * fw update process before returning to userspace
473 * by writing length 0x000 to device (iff we are in
474 * WAITING_FRAME_DATA state).
475 */
476 dev_err(dev, "Update wait error %d\n", ret);
477 return ret;
478 }
479 }
480
481 ret = mxt_bootloader_read(data, &val, 1);
482 if (ret)
483 return ret;
484
485 if (state == MXT_WAITING_BOOTLOAD_CMD)
486 val = mxt_get_bootloader_version(data, val);
487
488 switch (state) {
489 case MXT_WAITING_BOOTLOAD_CMD:
490 case MXT_WAITING_FRAME_DATA:
491 case MXT_APP_CRC_FAIL:
492 val &= ~MXT_BOOT_STATUS_MASK;
493 break;
494 case MXT_FRAME_CRC_PASS:
495 if (val == MXT_FRAME_CRC_CHECK) {
496 goto recheck;
497 } else if (val == MXT_FRAME_CRC_FAIL) {
498 dev_err(dev, "Bootloader CRC fail\n");
499 return -EINVAL;
500 }
501 break;
502 default:
503 return -EINVAL;
504 }
505
506 if (val != state) {
507 dev_err(dev, "Invalid bootloader state %02X != %02X\n",
508 val, state);
509 return -EINVAL;
510 }
511
512 return 0;
513 }
514
515 static int mxt_unlock_bootloader(struct mxt_data *data)
516 {
517 int ret;
518 u8 buf[2];
519
520 buf[0] = MXT_UNLOCK_CMD_LSB;
521 buf[1] = MXT_UNLOCK_CMD_MSB;
522
523 ret = mxt_bootloader_write(data, buf, 2);
524 if (ret)
525 return ret;
526
527 return 0;
528 }
529
530 static int __mxt_read_reg(struct i2c_client *client,
531 u16 reg, u16 len, void *val)
532 {
533 struct i2c_msg xfer[2];
534 u8 buf[2];
535 int ret;
536
537 buf[0] = reg & 0xff;
538 buf[1] = (reg >> 8) & 0xff;
539
540 /* Write register */
541 xfer[0].addr = client->addr;
542 xfer[0].flags = 0;
543 xfer[0].len = 2;
544 xfer[0].buf = buf;
545
546 /* Read data */
547 xfer[1].addr = client->addr;
548 xfer[1].flags = I2C_M_RD;
549 xfer[1].len = len;
550 xfer[1].buf = val;
551
552 ret = i2c_transfer(client->adapter, xfer, 2);
553 if (ret == 2) {
554 ret = 0;
555 } else {
556 if (ret >= 0)
557 ret = -EIO;
558 dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
559 __func__, ret);
560 }
561
562 return ret;
563 }
564
565 static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
566 const void *val)
567 {
568 u8 *buf;
569 size_t count;
570 int ret;
571
572 count = len + 2;
573 buf = kmalloc(count, GFP_KERNEL);
574 if (!buf)
575 return -ENOMEM;
576
577 buf[0] = reg & 0xff;
578 buf[1] = (reg >> 8) & 0xff;
579 memcpy(&buf[2], val, len);
580
581 ret = i2c_master_send(client, buf, count);
582 if (ret == count) {
583 ret = 0;
584 } else {
585 if (ret >= 0)
586 ret = -EIO;
587 dev_err(&client->dev, "%s: i2c send failed (%d)\n",
588 __func__, ret);
589 }
590
591 kfree(buf);
592 return ret;
593 }
594
595 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
596 {
597 return __mxt_write_reg(client, reg, 1, &val);
598 }
599
600 static struct mxt_object *
601 mxt_get_object(struct mxt_data *data, u8 type)
602 {
603 struct mxt_object *object;
604 int i;
605
606 for (i = 0; i < data->info.object_num; i++) {
607 object = data->object_table + i;
608 if (object->type == type)
609 return object;
610 }
611
612 dev_warn(&data->client->dev, "Invalid object type T%u\n", type);
613 return NULL;
614 }
615
616 static int mxt_read_message(struct mxt_data *data,
617 struct mxt_message *message)
618 {
619 struct mxt_object *object;
620 u16 reg;
621
622 object = mxt_get_object(data, MXT_GEN_MESSAGE_T5);
623 if (!object)
624 return -EINVAL;
625
626 reg = object->start_address;
627 return __mxt_read_reg(data->client, reg,
628 sizeof(struct mxt_message), message);
629 }
630
631 static int mxt_write_object(struct mxt_data *data,
632 u8 type, u8 offset, u8 val)
633 {
634 struct mxt_object *object;
635 u16 reg;
636
637 object = mxt_get_object(data, type);
638 if (!object || offset >= mxt_obj_size(object))
639 return -EINVAL;
640
641 reg = object->start_address;
642 return mxt_write_reg(data->client, reg + offset, val);
643 }
644
645 static void mxt_input_button(struct mxt_data *data, struct mxt_message *message)
646 {
647 struct input_dev *input = data->input_dev;
648 const struct mxt_platform_data *pdata = data->pdata;
649 bool button;
650 int i;
651
652 /* Active-low switch */
653 for (i = 0; i < pdata->t19_num_keys; i++) {
654 if (pdata->t19_keymap[i] == KEY_RESERVED)
655 continue;
656 button = !(message->message[0] & (1 << i));
657 input_report_key(input, pdata->t19_keymap[i], button);
658 }
659 }
660
661 static void mxt_input_sync(struct mxt_data *data)
662 {
663 input_mt_report_pointer_emulation(data->input_dev,
664 data->pdata->t19_num_keys);
665 input_sync(data->input_dev);
666 }
667
668 static void mxt_input_touchevent(struct mxt_data *data,
669 struct mxt_message *message, int id)
670 {
671 struct device *dev = &data->client->dev;
672 u8 status = message->message[0];
673 struct input_dev *input_dev = data->input_dev;
674 int x;
675 int y;
676 int area;
677 int amplitude;
678
679 x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf);
680 y = (message->message[2] << 4) | ((message->message[3] & 0xf));
681
682 /* Handle 10/12 bit switching */
683 if (data->max_x < 1024)
684 x >>= 2;
685 if (data->max_y < 1024)
686 y >>= 2;
687
688 area = message->message[4];
689 amplitude = message->message[5];
690
691 dev_dbg(dev,
692 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
693 id,
694 (status & MXT_T9_DETECT) ? 'D' : '.',
695 (status & MXT_T9_PRESS) ? 'P' : '.',
696 (status & MXT_T9_RELEASE) ? 'R' : '.',
697 (status & MXT_T9_MOVE) ? 'M' : '.',
698 (status & MXT_T9_VECTOR) ? 'V' : '.',
699 (status & MXT_T9_AMP) ? 'A' : '.',
700 (status & MXT_T9_SUPPRESS) ? 'S' : '.',
701 (status & MXT_T9_UNGRIP) ? 'U' : '.',
702 x, y, area, amplitude);
703
704 input_mt_slot(input_dev, id);
705
706 if (status & MXT_T9_DETECT) {
707 /*
708 * Multiple bits may be set if the host is slow to read
709 * the status messages, indicating all the events that
710 * have happened.
711 */
712 if (status & MXT_T9_RELEASE) {
713 input_mt_report_slot_state(input_dev,
714 MT_TOOL_FINGER, 0);
715 mxt_input_sync(data);
716 }
717
718 /* Touch active */
719 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1);
720 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
721 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
722 input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
723 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
724 } else {
725 /* Touch no longer active, close out slot */
726 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0);
727 }
728 }
729
730 static u16 mxt_extract_T6_csum(const u8 *csum)
731 {
732 return csum[0] | (csum[1] << 8) | (csum[2] << 16);
733 }
734
735 static bool mxt_is_T9_message(struct mxt_data *data, struct mxt_message *msg)
736 {
737 u8 id = msg->reportid;
738 return (id >= data->T9_reportid_min && id <= data->T9_reportid_max);
739 }
740
741 static irqreturn_t mxt_process_messages_until_invalid(struct mxt_data *data)
742 {
743 struct mxt_message message;
744 const u8 *payload = &message.message[0];
745 struct device *dev = &data->client->dev;
746 u8 reportid;
747 bool update_input = false;
748 u32 crc;
749
750 do {
751 if (mxt_read_message(data, &message)) {
752 dev_err(dev, "Failed to read message\n");
753 return IRQ_NONE;
754 }
755
756 reportid = message.reportid;
757
758 if (reportid == data->T6_reportid) {
759 u8 status = payload[0];
760
761 crc = mxt_extract_T6_csum(&payload[1]);
762 if (crc != data->config_crc) {
763 data->config_crc = crc;
764 complete(&data->crc_completion);
765 }
766
767 dev_dbg(dev, "Status: %02x Config Checksum: %06x\n",
768 status, data->config_crc);
769
770 if (status & MXT_T6_STATUS_RESET)
771 complete(&data->reset_completion);
772 } else if (!data->input_dev) {
773 /*
774 * do not report events if input device
775 * is not yet registered
776 */
777 mxt_dump_message(dev, &message);
778 } else if (mxt_is_T9_message(data, &message)) {
779 int id = reportid - data->T9_reportid_min;
780 mxt_input_touchevent(data, &message, id);
781 update_input = true;
782 } else if (message.reportid == data->T19_reportid) {
783 mxt_input_button(data, &message);
784 update_input = true;
785 } else {
786 mxt_dump_message(dev, &message);
787 }
788 } while (reportid != 0xff);
789
790 if (update_input)
791 mxt_input_sync(data);
792
793 return IRQ_HANDLED;
794 }
795
796 static irqreturn_t mxt_interrupt(int irq, void *dev_id)
797 {
798 struct mxt_data *data = dev_id;
799
800 if (data->in_bootloader) {
801 /* bootloader state transition completion */
802 complete(&data->bl_completion);
803 return IRQ_HANDLED;
804 }
805
806 if (!data->object_table)
807 return IRQ_HANDLED;
808
809 return mxt_process_messages_until_invalid(data);
810 }
811
812 static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset,
813 u8 value, bool wait)
814 {
815 u16 reg;
816 u8 command_register;
817 int timeout_counter = 0;
818 int ret;
819
820 reg = data->T6_address + cmd_offset;
821
822 ret = mxt_write_reg(data->client, reg, value);
823 if (ret)
824 return ret;
825
826 if (!wait)
827 return 0;
828
829 do {
830 msleep(20);
831 ret = __mxt_read_reg(data->client, reg, 1, &command_register);
832 if (ret)
833 return ret;
834 } while (command_register != 0 && timeout_counter++ <= 100);
835
836 if (timeout_counter > 100) {
837 dev_err(&data->client->dev, "Command failed!\n");
838 return -EIO;
839 }
840
841 return 0;
842 }
843
844 static int mxt_soft_reset(struct mxt_data *data)
845 {
846 struct device *dev = &data->client->dev;
847 int ret = 0;
848
849 dev_info(dev, "Resetting chip\n");
850
851 reinit_completion(&data->reset_completion);
852
853 ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_RESET_VALUE, false);
854 if (ret)
855 return ret;
856
857 ret = mxt_wait_for_completion(data, &data->reset_completion,
858 MXT_RESET_TIMEOUT);
859 if (ret)
860 return ret;
861
862 return 0;
863 }
864
865 static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value)
866 {
867 /*
868 * On failure, CRC is set to 0 and config will always be
869 * downloaded.
870 */
871 data->config_crc = 0;
872 reinit_completion(&data->crc_completion);
873
874 mxt_t6_command(data, cmd, value, true);
875
876 /*
877 * Wait for crc message. On failure, CRC is set to 0 and config will
878 * always be downloaded.
879 */
880 mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT);
881 }
882
883 static void mxt_calc_crc24(u32 *crc, u8 firstbyte, u8 secondbyte)
884 {
885 static const unsigned int crcpoly = 0x80001B;
886 u32 result;
887 u32 data_word;
888
889 data_word = (secondbyte << 8) | firstbyte;
890 result = ((*crc << 1) ^ data_word);
891
892 if (result & 0x1000000)
893 result ^= crcpoly;
894
895 *crc = result;
896 }
897
898 static u32 mxt_calculate_crc(u8 *base, off_t start_off, off_t end_off)
899 {
900 u32 crc = 0;
901 u8 *ptr = base + start_off;
902 u8 *last_val = base + end_off - 1;
903
904 if (end_off < start_off)
905 return -EINVAL;
906
907 while (ptr < last_val) {
908 mxt_calc_crc24(&crc, *ptr, *(ptr + 1));
909 ptr += 2;
910 }
911
912 /* if len is odd, fill the last byte with 0 */
913 if (ptr == last_val)
914 mxt_calc_crc24(&crc, *ptr, 0);
915
916 /* Mask to 24-bit */
917 crc &= 0x00FFFFFF;
918
919 return crc;
920 }
921
922 /*
923 * mxt_update_cfg - download configuration to chip
924 *
925 * Atmel Raw Config File Format
926 *
927 * The first four lines of the raw config file contain:
928 * 1) Version
929 * 2) Chip ID Information (first 7 bytes of device memory)
930 * 3) Chip Information Block 24-bit CRC Checksum
931 * 4) Chip Configuration 24-bit CRC Checksum
932 *
933 * The rest of the file consists of one line per object instance:
934 * <TYPE> <INSTANCE> <SIZE> <CONTENTS>
935 *
936 * <TYPE> - 2-byte object type as hex
937 * <INSTANCE> - 2-byte object instance number as hex
938 * <SIZE> - 2-byte object size as hex
939 * <CONTENTS> - array of <SIZE> 1-byte hex values
940 */
941 static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg)
942 {
943 struct device *dev = &data->client->dev;
944 struct mxt_info cfg_info;
945 struct mxt_object *object;
946 int ret;
947 int offset;
948 int data_pos;
949 int byte_offset;
950 int i;
951 int cfg_start_ofs;
952 u32 info_crc, config_crc, calculated_crc;
953 u8 *config_mem;
954 size_t config_mem_size;
955 unsigned int type, instance, size;
956 u8 val;
957 u16 reg;
958
959 mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1);
960
961 if (strncmp(cfg->data, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
962 dev_err(dev, "Unrecognised config file\n");
963 ret = -EINVAL;
964 goto release;
965 }
966
967 data_pos = strlen(MXT_CFG_MAGIC);
968
969 /* Load information block and check */
970 for (i = 0; i < sizeof(struct mxt_info); i++) {
971 ret = sscanf(cfg->data + data_pos, "%hhx%n",
972 (unsigned char *)&cfg_info + i,
973 &offset);
974 if (ret != 1) {
975 dev_err(dev, "Bad format\n");
976 ret = -EINVAL;
977 goto release;
978 }
979
980 data_pos += offset;
981 }
982
983 if (cfg_info.family_id != data->info.family_id) {
984 dev_err(dev, "Family ID mismatch!\n");
985 ret = -EINVAL;
986 goto release;
987 }
988
989 if (cfg_info.variant_id != data->info.variant_id) {
990 dev_err(dev, "Variant ID mismatch!\n");
991 ret = -EINVAL;
992 goto release;
993 }
994
995 /* Read CRCs */
996 ret = sscanf(cfg->data + data_pos, "%x%n", &info_crc, &offset);
997 if (ret != 1) {
998 dev_err(dev, "Bad format: failed to parse Info CRC\n");
999 ret = -EINVAL;
1000 goto release;
1001 }
1002 data_pos += offset;
1003
1004 ret = sscanf(cfg->data + data_pos, "%x%n", &config_crc, &offset);
1005 if (ret != 1) {
1006 dev_err(dev, "Bad format: failed to parse Config CRC\n");
1007 ret = -EINVAL;
1008 goto release;
1009 }
1010 data_pos += offset;
1011
1012 /*
1013 * The Info Block CRC is calculated over mxt_info and the object
1014 * table. If it does not match then we are trying to load the
1015 * configuration from a different chip or firmware version, so
1016 * the configuration CRC is invalid anyway.
1017 */
1018 if (info_crc == data->info_crc) {
1019 if (config_crc == 0 || data->config_crc == 0) {
1020 dev_info(dev, "CRC zero, attempting to apply config\n");
1021 } else if (config_crc == data->config_crc) {
1022 dev_dbg(dev, "Config CRC 0x%06X: OK\n",
1023 data->config_crc);
1024 ret = 0;
1025 goto release;
1026 } else {
1027 dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n",
1028 data->config_crc, config_crc);
1029 }
1030 } else {
1031 dev_warn(dev,
1032 "Warning: Info CRC error - device=0x%06X file=0x%06X\n",
1033 data->info_crc, info_crc);
1034 }
1035
1036 /* Malloc memory to store configuration */
1037 cfg_start_ofs = MXT_OBJECT_START +
1038 data->info.object_num * sizeof(struct mxt_object) +
1039 MXT_INFO_CHECKSUM_SIZE;
1040 config_mem_size = data->mem_size - cfg_start_ofs;
1041 config_mem = kzalloc(config_mem_size, GFP_KERNEL);
1042 if (!config_mem) {
1043 dev_err(dev, "Failed to allocate memory\n");
1044 ret = -ENOMEM;
1045 goto release;
1046 }
1047
1048 while (data_pos < cfg->size) {
1049 /* Read type, instance, length */
1050 ret = sscanf(cfg->data + data_pos, "%x %x %x%n",
1051 &type, &instance, &size, &offset);
1052 if (ret == 0) {
1053 /* EOF */
1054 break;
1055 } else if (ret != 3) {
1056 dev_err(dev, "Bad format: failed to parse object\n");
1057 ret = -EINVAL;
1058 goto release_mem;
1059 }
1060 data_pos += offset;
1061
1062 object = mxt_get_object(data, type);
1063 if (!object) {
1064 /* Skip object */
1065 for (i = 0; i < size; i++) {
1066 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1067 &val,
1068 &offset);
1069 data_pos += offset;
1070 }
1071 continue;
1072 }
1073
1074 if (size > mxt_obj_size(object)) {
1075 /*
1076 * Either we are in fallback mode due to wrong
1077 * config or config from a later fw version,
1078 * or the file is corrupt or hand-edited.
1079 */
1080 dev_warn(dev, "Discarding %zu byte(s) in T%u\n",
1081 size - mxt_obj_size(object), type);
1082 } else if (mxt_obj_size(object) > size) {
1083 /*
1084 * If firmware is upgraded, new bytes may be added to
1085 * end of objects. It is generally forward compatible
1086 * to zero these bytes - previous behaviour will be
1087 * retained. However this does invalidate the CRC and
1088 * will force fallback mode until the configuration is
1089 * updated. We warn here but do nothing else - the
1090 * malloc has zeroed the entire configuration.
1091 */
1092 dev_warn(dev, "Zeroing %zu byte(s) in T%d\n",
1093 mxt_obj_size(object) - size, type);
1094 }
1095
1096 if (instance >= mxt_obj_instances(object)) {
1097 dev_err(dev, "Object instances exceeded!\n");
1098 ret = -EINVAL;
1099 goto release_mem;
1100 }
1101
1102 reg = object->start_address + mxt_obj_size(object) * instance;
1103
1104 for (i = 0; i < size; i++) {
1105 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1106 &val,
1107 &offset);
1108 if (ret != 1) {
1109 dev_err(dev, "Bad format in T%d\n", type);
1110 ret = -EINVAL;
1111 goto release_mem;
1112 }
1113 data_pos += offset;
1114
1115 if (i > mxt_obj_size(object))
1116 continue;
1117
1118 byte_offset = reg + i - cfg_start_ofs;
1119
1120 if ((byte_offset >= 0)
1121 && (byte_offset <= config_mem_size)) {
1122 *(config_mem + byte_offset) = val;
1123 } else {
1124 dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n",
1125 reg, object->type, byte_offset);
1126 ret = -EINVAL;
1127 goto release_mem;
1128 }
1129 }
1130 }
1131
1132 /* Calculate crc of the received configs (not the raw config file) */
1133 if (data->T7_address < cfg_start_ofs) {
1134 dev_err(dev, "Bad T7 address, T7addr = %x, config offset %x\n",
1135 data->T7_address, cfg_start_ofs);
1136 ret = 0;
1137 goto release_mem;
1138 }
1139
1140 calculated_crc = mxt_calculate_crc(config_mem,
1141 data->T7_address - cfg_start_ofs,
1142 config_mem_size);
1143
1144 if (config_crc > 0 && (config_crc != calculated_crc))
1145 dev_warn(dev, "Config CRC error, calculated=%06X, file=%06X\n",
1146 calculated_crc, config_crc);
1147
1148 /* Write configuration as blocks */
1149 byte_offset = 0;
1150 while (byte_offset < config_mem_size) {
1151 size = config_mem_size - byte_offset;
1152
1153 if (size > MXT_MAX_BLOCK_WRITE)
1154 size = MXT_MAX_BLOCK_WRITE;
1155
1156 ret = __mxt_write_reg(data->client,
1157 cfg_start_ofs + byte_offset,
1158 size, config_mem + byte_offset);
1159 if (ret != 0) {
1160 dev_err(dev, "Config write error, ret=%d\n", ret);
1161 goto release_mem;
1162 }
1163
1164 byte_offset += size;
1165 }
1166
1167 mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
1168
1169 ret = mxt_soft_reset(data);
1170 if (ret)
1171 goto release_mem;
1172
1173 dev_info(dev, "Config successfully updated\n");
1174
1175 release_mem:
1176 kfree(config_mem);
1177 release:
1178 release_firmware(cfg);
1179 return ret;
1180 }
1181
1182 static int mxt_make_highchg(struct mxt_data *data)
1183 {
1184 struct device *dev = &data->client->dev;
1185 struct mxt_message message;
1186 int count = 10;
1187 int error;
1188
1189 /* Read dummy message to make high CHG pin */
1190 do {
1191 error = mxt_read_message(data, &message);
1192 if (error)
1193 return error;
1194 } while (message.reportid != 0xff && --count);
1195
1196 if (!count) {
1197 dev_err(dev, "CHG pin isn't cleared\n");
1198 return -EBUSY;
1199 }
1200
1201 return 0;
1202 }
1203
1204 static int mxt_acquire_irq(struct mxt_data *data)
1205 {
1206 int error;
1207
1208 enable_irq(data->irq);
1209
1210 error = mxt_make_highchg(data);
1211 if (error)
1212 return error;
1213
1214 return 0;
1215 }
1216
1217 static int mxt_get_info(struct mxt_data *data)
1218 {
1219 struct i2c_client *client = data->client;
1220 struct mxt_info *info = &data->info;
1221 int error;
1222
1223 /* Read 7-byte info block starting at address 0 */
1224 error = __mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
1225 if (error)
1226 return error;
1227
1228 return 0;
1229 }
1230
1231 static int mxt_get_object_table(struct mxt_data *data)
1232 {
1233 struct i2c_client *client = data->client;
1234 size_t table_size;
1235 struct mxt_object *object_table;
1236 int error;
1237 int i;
1238 u8 reportid;
1239 u16 end_address;
1240
1241 table_size = data->info.object_num * sizeof(struct mxt_object);
1242 object_table = kzalloc(table_size, GFP_KERNEL);
1243 if (!object_table) {
1244 dev_err(&data->client->dev, "Failed to allocate memory\n");
1245 return -ENOMEM;
1246 }
1247
1248 error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
1249 object_table);
1250 if (error) {
1251 kfree(object_table);
1252 return error;
1253 }
1254
1255 /* Valid Report IDs start counting from 1 */
1256 reportid = 1;
1257 data->mem_size = 0;
1258 for (i = 0; i < data->info.object_num; i++) {
1259 struct mxt_object *object = object_table + i;
1260 u8 min_id, max_id;
1261
1262 le16_to_cpus(&object->start_address);
1263
1264 if (object->num_report_ids) {
1265 min_id = reportid;
1266 reportid += object->num_report_ids *
1267 mxt_obj_instances(object);
1268 max_id = reportid - 1;
1269 } else {
1270 min_id = 0;
1271 max_id = 0;
1272 }
1273
1274 dev_dbg(&data->client->dev,
1275 "T%u Start:%u Size:%zu Instances:%zu Report IDs:%u-%u\n",
1276 object->type, object->start_address,
1277 mxt_obj_size(object), mxt_obj_instances(object),
1278 min_id, max_id);
1279
1280 switch (object->type) {
1281 case MXT_GEN_COMMAND_T6:
1282 data->T6_reportid = min_id;
1283 data->T6_address = object->start_address;
1284 break;
1285 case MXT_GEN_POWER_T7:
1286 data->T7_address = object->start_address;
1287 break;
1288 case MXT_TOUCH_MULTI_T9:
1289 data->T9_reportid_min = min_id;
1290 data->T9_reportid_max = max_id;
1291 break;
1292 case MXT_SPT_GPIOPWM_T19:
1293 data->T19_reportid = min_id;
1294 break;
1295 }
1296
1297 end_address = object->start_address
1298 + mxt_obj_size(object) * mxt_obj_instances(object) - 1;
1299
1300 if (end_address >= data->mem_size)
1301 data->mem_size = end_address + 1;
1302 }
1303
1304 data->object_table = object_table;
1305
1306 return 0;
1307 }
1308
1309 static void mxt_free_object_table(struct mxt_data *data)
1310 {
1311 input_unregister_device(data->input_dev);
1312 data->input_dev = NULL;
1313
1314 kfree(data->object_table);
1315 data->object_table = NULL;
1316 data->T6_reportid = 0;
1317 data->T9_reportid_min = 0;
1318 data->T9_reportid_max = 0;
1319 data->T19_reportid = 0;
1320 }
1321
1322 static int mxt_read_t9_resolution(struct mxt_data *data)
1323 {
1324 struct i2c_client *client = data->client;
1325 int error;
1326 struct t9_range range;
1327 unsigned char orient;
1328 struct mxt_object *object;
1329
1330 object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
1331 if (!object)
1332 return -EINVAL;
1333
1334 error = __mxt_read_reg(client,
1335 object->start_address + MXT_T9_RANGE,
1336 sizeof(range), &range);
1337 if (error)
1338 return error;
1339
1340 le16_to_cpus(&range.x);
1341 le16_to_cpus(&range.y);
1342
1343 error = __mxt_read_reg(client,
1344 object->start_address + MXT_T9_ORIENT,
1345 1, &orient);
1346 if (error)
1347 return error;
1348
1349 /* Handle default values */
1350 if (range.x == 0)
1351 range.x = 1023;
1352
1353 if (range.y == 0)
1354 range.y = 1023;
1355
1356 if (orient & MXT_T9_ORIENT_SWITCH) {
1357 data->max_x = range.y;
1358 data->max_y = range.x;
1359 } else {
1360 data->max_x = range.x;
1361 data->max_y = range.y;
1362 }
1363
1364 dev_dbg(&client->dev,
1365 "Touchscreen size X%uY%u\n", data->max_x, data->max_y);
1366
1367 return 0;
1368 }
1369
1370 static int mxt_input_open(struct input_dev *dev);
1371 static void mxt_input_close(struct input_dev *dev);
1372
1373 static int mxt_initialize_t9_input_device(struct mxt_data *data)
1374 {
1375 struct device *dev = &data->client->dev;
1376 const struct mxt_platform_data *pdata = data->pdata;
1377 struct input_dev *input_dev;
1378 int error;
1379 unsigned int num_mt_slots;
1380 unsigned int mt_flags = 0;
1381 int i;
1382
1383 error = mxt_read_t9_resolution(data);
1384 if (error)
1385 dev_warn(dev, "Failed to initialize T9 resolution\n");
1386
1387 input_dev = input_allocate_device();
1388 if (!input_dev) {
1389 dev_err(dev, "Failed to allocate memory\n");
1390 return -ENOMEM;
1391 }
1392
1393 input_dev->name = "Atmel maXTouch Touchscreen";
1394 input_dev->phys = data->phys;
1395 input_dev->id.bustype = BUS_I2C;
1396 input_dev->dev.parent = dev;
1397 input_dev->open = mxt_input_open;
1398 input_dev->close = mxt_input_close;
1399
1400 __set_bit(EV_ABS, input_dev->evbit);
1401 __set_bit(EV_KEY, input_dev->evbit);
1402 __set_bit(BTN_TOUCH, input_dev->keybit);
1403
1404 if (pdata->t19_num_keys) {
1405 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
1406
1407 for (i = 0; i < pdata->t19_num_keys; i++)
1408 if (pdata->t19_keymap[i] != KEY_RESERVED)
1409 input_set_capability(input_dev, EV_KEY,
1410 pdata->t19_keymap[i]);
1411
1412 mt_flags |= INPUT_MT_POINTER;
1413
1414 input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
1415 input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
1416 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
1417 MXT_PIXELS_PER_MM);
1418 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
1419 MXT_PIXELS_PER_MM);
1420
1421 input_dev->name = "Atmel maXTouch Touchpad";
1422 }
1423
1424 /* For single touch */
1425 input_set_abs_params(input_dev, ABS_X,
1426 0, data->max_x, 0, 0);
1427 input_set_abs_params(input_dev, ABS_Y,
1428 0, data->max_y, 0, 0);
1429 input_set_abs_params(input_dev, ABS_PRESSURE,
1430 0, 255, 0, 0);
1431
1432 /* For multi touch */
1433 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
1434 error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags);
1435 if (error) {
1436 dev_err(dev, "Error %d initialising slots\n", error);
1437 goto err_free_mem;
1438 }
1439
1440 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1441 0, MXT_MAX_AREA, 0, 0);
1442 input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1443 0, data->max_x, 0, 0);
1444 input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1445 0, data->max_y, 0, 0);
1446 input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1447 0, 255, 0, 0);
1448
1449 input_set_drvdata(input_dev, data);
1450
1451 error = input_register_device(input_dev);
1452 if (error) {
1453 dev_err(dev, "Error %d registering input device\n", error);
1454 goto err_free_mem;
1455 }
1456
1457 data->input_dev = input_dev;
1458
1459 return 0;
1460
1461 err_free_mem:
1462 input_free_device(input_dev);
1463 return error;
1464 }
1465
1466 static int mxt_configure_objects(struct mxt_data *data,
1467 const struct firmware *cfg);
1468
1469 static void mxt_config_cb(const struct firmware *cfg, void *ctx)
1470 {
1471 mxt_configure_objects(ctx, cfg);
1472 }
1473
1474 static int mxt_initialize(struct mxt_data *data)
1475 {
1476 struct i2c_client *client = data->client;
1477 int error;
1478
1479 error = mxt_get_info(data);
1480 if (error) {
1481 error = mxt_probe_bootloader(data);
1482 if (error)
1483 return error;
1484
1485 data->in_bootloader = true;
1486 return 0;
1487 }
1488
1489 /* Get object table information */
1490 error = mxt_get_object_table(data);
1491 if (error) {
1492 dev_err(&client->dev, "Error %d reading object table\n", error);
1493 return error;
1494 }
1495
1496 mxt_acquire_irq(data);
1497 if (error)
1498 goto err_free_object_table;
1499
1500 request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
1501 &data->client->dev, GFP_KERNEL, data,
1502 mxt_config_cb);
1503
1504 return 0;
1505
1506 err_free_object_table:
1507 mxt_free_object_table(data);
1508 return error;
1509 }
1510
1511 static int mxt_configure_objects(struct mxt_data *data,
1512 const struct firmware *cfg)
1513 {
1514 struct device *dev = &data->client->dev;
1515 struct mxt_info *info = &data->info;
1516 int error;
1517
1518 if (cfg) {
1519 error = mxt_update_cfg(data, cfg);
1520 if (error)
1521 dev_warn(dev, "Error %d updating config\n", error);
1522 }
1523
1524 error = mxt_initialize_t9_input_device(data);
1525 if (error)
1526 return error;
1527
1528 dev_info(dev,
1529 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
1530 info->family_id, info->variant_id, info->version >> 4,
1531 info->version & 0xf, info->build, info->object_num);
1532
1533 return 0;
1534 }
1535
1536 /* Firmware Version is returned as Major.Minor.Build */
1537 static ssize_t mxt_fw_version_show(struct device *dev,
1538 struct device_attribute *attr, char *buf)
1539 {
1540 struct mxt_data *data = dev_get_drvdata(dev);
1541 struct mxt_info *info = &data->info;
1542 return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
1543 info->version >> 4, info->version & 0xf, info->build);
1544 }
1545
1546 /* Hardware Version is returned as FamilyID.VariantID */
1547 static ssize_t mxt_hw_version_show(struct device *dev,
1548 struct device_attribute *attr, char *buf)
1549 {
1550 struct mxt_data *data = dev_get_drvdata(dev);
1551 struct mxt_info *info = &data->info;
1552 return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
1553 info->family_id, info->variant_id);
1554 }
1555
1556 static ssize_t mxt_show_instance(char *buf, int count,
1557 struct mxt_object *object, int instance,
1558 const u8 *val)
1559 {
1560 int i;
1561
1562 if (mxt_obj_instances(object) > 1)
1563 count += scnprintf(buf + count, PAGE_SIZE - count,
1564 "Instance %u\n", instance);
1565
1566 for (i = 0; i < mxt_obj_size(object); i++)
1567 count += scnprintf(buf + count, PAGE_SIZE - count,
1568 "\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
1569 count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
1570
1571 return count;
1572 }
1573
1574 static ssize_t mxt_object_show(struct device *dev,
1575 struct device_attribute *attr, char *buf)
1576 {
1577 struct mxt_data *data = dev_get_drvdata(dev);
1578 struct mxt_object *object;
1579 int count = 0;
1580 int i, j;
1581 int error;
1582 u8 *obuf;
1583
1584 /* Pre-allocate buffer large enough to hold max sized object. */
1585 obuf = kmalloc(256, GFP_KERNEL);
1586 if (!obuf)
1587 return -ENOMEM;
1588
1589 error = 0;
1590 for (i = 0; i < data->info.object_num; i++) {
1591 object = data->object_table + i;
1592
1593 if (!mxt_object_readable(object->type))
1594 continue;
1595
1596 count += scnprintf(buf + count, PAGE_SIZE - count,
1597 "T%u:\n", object->type);
1598
1599 for (j = 0; j < mxt_obj_instances(object); j++) {
1600 u16 size = mxt_obj_size(object);
1601 u16 addr = object->start_address + j * size;
1602
1603 error = __mxt_read_reg(data->client, addr, size, obuf);
1604 if (error)
1605 goto done;
1606
1607 count = mxt_show_instance(buf, count, object, j, obuf);
1608 }
1609 }
1610
1611 done:
1612 kfree(obuf);
1613 return error ?: count;
1614 }
1615
1616 static int mxt_check_firmware_format(struct device *dev,
1617 const struct firmware *fw)
1618 {
1619 unsigned int pos = 0;
1620 char c;
1621
1622 while (pos < fw->size) {
1623 c = *(fw->data + pos);
1624
1625 if (c < '0' || (c > '9' && c < 'A') || c > 'F')
1626 return 0;
1627
1628 pos++;
1629 }
1630
1631 /*
1632 * To convert file try:
1633 * xxd -r -p mXTXXX__APP_VX-X-XX.enc > maxtouch.fw
1634 */
1635 dev_err(dev, "Aborting: firmware file must be in binary format\n");
1636
1637 return -EINVAL;
1638 }
1639
1640 static int mxt_load_fw(struct device *dev, const char *fn)
1641 {
1642 struct mxt_data *data = dev_get_drvdata(dev);
1643 const struct firmware *fw = NULL;
1644 unsigned int frame_size;
1645 unsigned int pos = 0;
1646 unsigned int retry = 0;
1647 unsigned int frame = 0;
1648 int ret;
1649
1650 ret = request_firmware(&fw, fn, dev);
1651 if (ret) {
1652 dev_err(dev, "Unable to open firmware %s\n", fn);
1653 return ret;
1654 }
1655
1656 /* Check for incorrect enc file */
1657 ret = mxt_check_firmware_format(dev, fw);
1658 if (ret)
1659 goto release_firmware;
1660
1661 ret = mxt_lookup_bootloader_address(data);
1662 if (ret)
1663 goto release_firmware;
1664
1665 if (!data->in_bootloader) {
1666 /* Change to the bootloader mode */
1667 data->in_bootloader = true;
1668
1669 ret = mxt_t6_command(data, MXT_COMMAND_RESET,
1670 MXT_BOOT_VALUE, false);
1671 if (ret)
1672 goto release_firmware;
1673
1674 msleep(MXT_RESET_TIME);
1675 }
1676
1677 mxt_free_object_table(data);
1678 reinit_completion(&data->bl_completion);
1679
1680 ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false);
1681 if (ret) {
1682 /* Bootloader may still be unlocked from previous attempt */
1683 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, false);
1684 if (ret)
1685 goto disable_irq;
1686 } else {
1687 dev_info(dev, "Unlocking bootloader\n");
1688
1689 /* Unlock bootloader */
1690 ret = mxt_unlock_bootloader(data);
1691 if (ret)
1692 goto disable_irq;
1693 }
1694
1695 while (pos < fw->size) {
1696 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, true);
1697 if (ret)
1698 goto disable_irq;
1699
1700 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
1701
1702 /* Take account of CRC bytes */
1703 frame_size += 2;
1704
1705 /* Write one frame to device */
1706 ret = mxt_bootloader_write(data, fw->data + pos, frame_size);
1707 if (ret)
1708 goto disable_irq;
1709
1710 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true);
1711 if (ret) {
1712 retry++;
1713
1714 /* Back off by 20ms per retry */
1715 msleep(retry * 20);
1716
1717 if (retry > 20) {
1718 dev_err(dev, "Retry count exceeded\n");
1719 goto disable_irq;
1720 }
1721 } else {
1722 retry = 0;
1723 pos += frame_size;
1724 frame++;
1725 }
1726
1727 if (frame % 50 == 0)
1728 dev_dbg(dev, "Sent %d frames, %d/%zd bytes\n",
1729 frame, pos, fw->size);
1730 }
1731
1732 /* Wait for flash. */
1733 ret = mxt_wait_for_completion(data, &data->bl_completion,
1734 MXT_FW_RESET_TIME);
1735 if (ret)
1736 goto disable_irq;
1737
1738 dev_dbg(dev, "Sent %d frames, %d bytes\n", frame, pos);
1739
1740 /*
1741 * Wait for device to reset. Some bootloader versions do not assert
1742 * the CHG line after bootloading has finished, so ignore potential
1743 * errors.
1744 */
1745 mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME);
1746
1747 data->in_bootloader = false;
1748
1749 disable_irq:
1750 disable_irq(data->irq);
1751 release_firmware:
1752 release_firmware(fw);
1753 return ret;
1754 }
1755
1756 static ssize_t mxt_update_fw_store(struct device *dev,
1757 struct device_attribute *attr,
1758 const char *buf, size_t count)
1759 {
1760 struct mxt_data *data = dev_get_drvdata(dev);
1761 int error;
1762
1763 error = mxt_load_fw(dev, MXT_FW_NAME);
1764 if (error) {
1765 dev_err(dev, "The firmware update failed(%d)\n", error);
1766 count = error;
1767 } else {
1768 dev_info(dev, "The firmware update succeeded\n");
1769
1770 error = mxt_initialize(data);
1771 if (error)
1772 return error;
1773 }
1774
1775 return count;
1776 }
1777
1778 static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
1779 static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
1780 static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
1781 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
1782
1783 static struct attribute *mxt_attrs[] = {
1784 &dev_attr_fw_version.attr,
1785 &dev_attr_hw_version.attr,
1786 &dev_attr_object.attr,
1787 &dev_attr_update_fw.attr,
1788 NULL
1789 };
1790
1791 static const struct attribute_group mxt_attr_group = {
1792 .attrs = mxt_attrs,
1793 };
1794
1795 static void mxt_start(struct mxt_data *data)
1796 {
1797 /* Touch enable */
1798 mxt_write_object(data,
1799 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83);
1800 }
1801
1802 static void mxt_stop(struct mxt_data *data)
1803 {
1804 /* Touch disable */
1805 mxt_write_object(data,
1806 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0);
1807 }
1808
1809 static int mxt_input_open(struct input_dev *dev)
1810 {
1811 struct mxt_data *data = input_get_drvdata(dev);
1812
1813 mxt_start(data);
1814
1815 return 0;
1816 }
1817
1818 static void mxt_input_close(struct input_dev *dev)
1819 {
1820 struct mxt_data *data = input_get_drvdata(dev);
1821
1822 mxt_stop(data);
1823 }
1824
1825 #ifdef CONFIG_OF
1826 static struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
1827 {
1828 struct mxt_platform_data *pdata;
1829 u32 *keymap;
1830 u32 keycode;
1831 int proplen, i, ret;
1832
1833 if (!client->dev.of_node)
1834 return ERR_PTR(-ENODEV);
1835
1836 pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
1837 if (!pdata)
1838 return ERR_PTR(-ENOMEM);
1839
1840 if (of_find_property(client->dev.of_node, "linux,gpio-keymap",
1841 &proplen)) {
1842 pdata->t19_num_keys = proplen / sizeof(u32);
1843
1844 keymap = devm_kzalloc(&client->dev,
1845 pdata->t19_num_keys * sizeof(keymap[0]),
1846 GFP_KERNEL);
1847 if (!keymap)
1848 return ERR_PTR(-ENOMEM);
1849
1850 for (i = 0; i < pdata->t19_num_keys; i++) {
1851 ret = of_property_read_u32_index(client->dev.of_node,
1852 "linux,gpio-keymap", i, &keycode);
1853 if (ret)
1854 keycode = KEY_RESERVED;
1855
1856 keymap[i] = keycode;
1857 }
1858
1859 pdata->t19_keymap = keymap;
1860 }
1861
1862 return pdata;
1863 }
1864 #else
1865 static struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
1866 {
1867 dev_dbg(&client->dev, "No platform data specified\n");
1868 return ERR_PTR(-EINVAL);
1869 }
1870 #endif
1871
1872 static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
1873 {
1874 struct mxt_data *data;
1875 const struct mxt_platform_data *pdata;
1876 int error;
1877
1878 pdata = dev_get_platdata(&client->dev);
1879 if (!pdata) {
1880 pdata = mxt_parse_dt(client);
1881 if (IS_ERR(pdata))
1882 return PTR_ERR(pdata);
1883 }
1884
1885 data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
1886 if (!data) {
1887 dev_err(&client->dev, "Failed to allocate memory\n");
1888 return -ENOMEM;
1889 }
1890
1891 snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
1892 client->adapter->nr, client->addr);
1893
1894 data->client = client;
1895 data->pdata = pdata;
1896 data->irq = client->irq;
1897 i2c_set_clientdata(client, data);
1898
1899 init_completion(&data->bl_completion);
1900 init_completion(&data->reset_completion);
1901 init_completion(&data->crc_completion);
1902
1903 error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
1904 pdata->irqflags | IRQF_ONESHOT,
1905 client->name, data);
1906 if (error) {
1907 dev_err(&client->dev, "Failed to register interrupt\n");
1908 goto err_free_mem;
1909 }
1910
1911 disable_irq(client->irq);
1912
1913 error = mxt_initialize(data);
1914 if (error)
1915 goto err_free_irq;
1916
1917 error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
1918 if (error) {
1919 dev_err(&client->dev, "Failure %d creating sysfs group\n",
1920 error);
1921 goto err_free_object;
1922 }
1923
1924 return 0;
1925
1926 err_free_object:
1927 kfree(data->object_table);
1928 err_free_irq:
1929 free_irq(client->irq, data);
1930 err_free_mem:
1931 kfree(data);
1932 return error;
1933 }
1934
1935 static int mxt_remove(struct i2c_client *client)
1936 {
1937 struct mxt_data *data = i2c_get_clientdata(client);
1938
1939 sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
1940 free_irq(data->irq, data);
1941 input_unregister_device(data->input_dev);
1942 kfree(data->object_table);
1943 kfree(data);
1944
1945 return 0;
1946 }
1947
1948 #ifdef CONFIG_PM_SLEEP
1949 static int mxt_suspend(struct device *dev)
1950 {
1951 struct i2c_client *client = to_i2c_client(dev);
1952 struct mxt_data *data = i2c_get_clientdata(client);
1953 struct input_dev *input_dev = data->input_dev;
1954
1955 mutex_lock(&input_dev->mutex);
1956
1957 if (input_dev->users)
1958 mxt_stop(data);
1959
1960 mutex_unlock(&input_dev->mutex);
1961
1962 return 0;
1963 }
1964
1965 static int mxt_resume(struct device *dev)
1966 {
1967 struct i2c_client *client = to_i2c_client(dev);
1968 struct mxt_data *data = i2c_get_clientdata(client);
1969 struct input_dev *input_dev = data->input_dev;
1970
1971 mxt_soft_reset(data);
1972
1973 mutex_lock(&input_dev->mutex);
1974
1975 if (input_dev->users)
1976 mxt_start(data);
1977
1978 mutex_unlock(&input_dev->mutex);
1979
1980 return 0;
1981 }
1982 #endif
1983
1984 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
1985
1986 static const struct of_device_id mxt_of_match[] = {
1987 { .compatible = "atmel,maxtouch", },
1988 {},
1989 };
1990 MODULE_DEVICE_TABLE(of, mxt_of_match);
1991
1992 static const struct i2c_device_id mxt_id[] = {
1993 { "qt602240_ts", 0 },
1994 { "atmel_mxt_ts", 0 },
1995 { "atmel_mxt_tp", 0 },
1996 { "mXT224", 0 },
1997 { }
1998 };
1999 MODULE_DEVICE_TABLE(i2c, mxt_id);
2000
2001 static struct i2c_driver mxt_driver = {
2002 .driver = {
2003 .name = "atmel_mxt_ts",
2004 .owner = THIS_MODULE,
2005 .of_match_table = of_match_ptr(mxt_of_match),
2006 .pm = &mxt_pm_ops,
2007 },
2008 .probe = mxt_probe,
2009 .remove = mxt_remove,
2010 .id_table = mxt_id,
2011 };
2012
2013 module_i2c_driver(mxt_driver);
2014
2015 /* Module information */
2016 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
2017 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
2018 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.076793 seconds and 6 git commands to generate.