1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/module.h>
15#include <linux/init.h>
16#include <linux/delay.h>
17#include <linux/firmware.h>
18#include <linux/i2c.h>
19#include <linux/i2c/atmel_mxt_ts.h>
20#include <linux/input/mt.h>
21#include <linux/interrupt.h>
22#include <linux/slab.h>
23
24
25#define MXT_VER_20 20
26#define MXT_VER_21 21
27#define MXT_VER_22 22
28
29
30#define MXT_APP_LOW 0x4a
31#define MXT_APP_HIGH 0x4b
32#define MXT_BOOT_LOW 0x24
33#define MXT_BOOT_HIGH 0x25
34
35
36#define MXT_FW_NAME "maxtouch.fw"
37
38
39#define MXT_INFO 0x00
40#define MXT_FAMILY_ID 0x00
41#define MXT_VARIANT_ID 0x01
42#define MXT_VERSION 0x02
43#define MXT_BUILD 0x03
44#define MXT_MATRIX_X_SIZE 0x04
45#define MXT_MATRIX_Y_SIZE 0x05
46#define MXT_OBJECT_NUM 0x06
47#define MXT_OBJECT_START 0x07
48
49#define MXT_OBJECT_SIZE 6
50
51
52#define MXT_DEBUG_DIAGNOSTIC_T37 37
53#define MXT_GEN_MESSAGE_T5 5
54#define MXT_GEN_COMMAND_T6 6
55#define MXT_GEN_POWER_T7 7
56#define MXT_GEN_ACQUIRE_T8 8
57#define MXT_GEN_DATASOURCE_T53 53
58#define MXT_TOUCH_MULTI_T9 9
59#define MXT_TOUCH_KEYARRAY_T15 15
60#define MXT_TOUCH_PROXIMITY_T23 23
61#define MXT_TOUCH_PROXKEY_T52 52
62#define MXT_PROCI_GRIPFACE_T20 20
63#define MXT_PROCG_NOISE_T22 22
64#define MXT_PROCI_ONETOUCH_T24 24
65#define MXT_PROCI_TWOTOUCH_T27 27
66#define MXT_PROCI_GRIP_T40 40
67#define MXT_PROCI_PALM_T41 41
68#define MXT_PROCI_TOUCHSUPPRESSION_T42 42
69#define MXT_PROCI_STYLUS_T47 47
70#define MXT_PROCG_NOISESUPPRESSION_T48 48
71#define MXT_SPT_COMMSCONFIG_T18 18
72#define MXT_SPT_GPIOPWM_T19 19
73#define MXT_SPT_SELFTEST_T25 25
74#define MXT_SPT_CTECONFIG_T28 28
75#define MXT_SPT_USERDATA_T38 38
76#define MXT_SPT_DIGITIZER_T43 43
77#define MXT_SPT_MESSAGECOUNT_T44 44
78#define MXT_SPT_CTECONFIG_T46 46
79
80
81#define MXT_COMMAND_RESET 0
82#define MXT_COMMAND_BACKUPNV 1
83#define MXT_COMMAND_CALIBRATE 2
84#define MXT_COMMAND_REPORTALL 3
85#define MXT_COMMAND_DIAGNOSTIC 5
86
87
88#define MXT_POWER_IDLEACQINT 0
89#define MXT_POWER_ACTVACQINT 1
90#define MXT_POWER_ACTV2IDLETO 2
91
92
93#define MXT_ACQUIRE_CHRGTIME 0
94#define MXT_ACQUIRE_TCHDRIFT 2
95#define MXT_ACQUIRE_DRIFTST 3
96#define MXT_ACQUIRE_TCHAUTOCAL 4
97#define MXT_ACQUIRE_SYNC 5
98#define MXT_ACQUIRE_ATCHCALST 6
99#define MXT_ACQUIRE_ATCHCALSTHR 7
100
101
102#define MXT_TOUCH_CTRL 0
103#define MXT_TOUCH_XORIGIN 1
104#define MXT_TOUCH_YORIGIN 2
105#define MXT_TOUCH_XSIZE 3
106#define MXT_TOUCH_YSIZE 4
107#define MXT_TOUCH_BLEN 6
108#define MXT_TOUCH_TCHTHR 7
109#define MXT_TOUCH_TCHDI 8
110#define MXT_TOUCH_ORIENT 9
111#define MXT_TOUCH_MOVHYSTI 11
112#define MXT_TOUCH_MOVHYSTN 12
113#define MXT_TOUCH_NUMTOUCH 14
114#define MXT_TOUCH_MRGHYST 15
115#define MXT_TOUCH_MRGTHR 16
116#define MXT_TOUCH_AMPHYST 17
117#define MXT_TOUCH_XRANGE_LSB 18
118#define MXT_TOUCH_XRANGE_MSB 19
119#define MXT_TOUCH_YRANGE_LSB 20
120#define MXT_TOUCH_YRANGE_MSB 21
121#define MXT_TOUCH_XLOCLIP 22
122#define MXT_TOUCH_XHICLIP 23
123#define MXT_TOUCH_YLOCLIP 24
124#define MXT_TOUCH_YHICLIP 25
125#define MXT_TOUCH_XEDGECTRL 26
126#define MXT_TOUCH_XEDGEDIST 27
127#define MXT_TOUCH_YEDGECTRL 28
128#define MXT_TOUCH_YEDGEDIST 29
129#define MXT_TOUCH_JUMPLIMIT 30
130
131
132#define MXT_GRIPFACE_CTRL 0
133#define MXT_GRIPFACE_XLOGRIP 1
134#define MXT_GRIPFACE_XHIGRIP 2
135#define MXT_GRIPFACE_YLOGRIP 3
136#define MXT_GRIPFACE_YHIGRIP 4
137#define MXT_GRIPFACE_MAXTCHS 5
138#define MXT_GRIPFACE_SZTHR1 7
139#define MXT_GRIPFACE_SZTHR2 8
140#define MXT_GRIPFACE_SHPTHR1 9
141#define MXT_GRIPFACE_SHPTHR2 10
142#define MXT_GRIPFACE_SUPEXTTO 11
143
144
145#define MXT_NOISE_CTRL 0
146#define MXT_NOISE_OUTFLEN 1
147#define MXT_NOISE_GCAFUL_LSB 3
148#define MXT_NOISE_GCAFUL_MSB 4
149#define MXT_NOISE_GCAFLL_LSB 5
150#define MXT_NOISE_GCAFLL_MSB 6
151#define MXT_NOISE_ACTVGCAFVALID 7
152#define MXT_NOISE_NOISETHR 8
153#define MXT_NOISE_FREQHOPSCALE 10
154#define MXT_NOISE_FREQ0 11
155#define MXT_NOISE_FREQ1 12
156#define MXT_NOISE_FREQ2 13
157#define MXT_NOISE_FREQ3 14
158#define MXT_NOISE_FREQ4 15
159#define MXT_NOISE_IDLEGCAFVALID 16
160
161
162#define MXT_COMMS_CTRL 0
163#define MXT_COMMS_CMD 1
164
165
166#define MXT_CTE_CTRL 0
167#define MXT_CTE_CMD 1
168#define MXT_CTE_MODE 2
169#define MXT_CTE_IDLEGCAFDEPTH 3
170#define MXT_CTE_ACTVGCAFDEPTH 4
171#define MXT_CTE_VOLTAGE 5
172
173#define MXT_VOLTAGE_DEFAULT 2700000
174#define MXT_VOLTAGE_STEP 10000
175
176
177#define MXT_BOOT_VALUE 0xa5
178#define MXT_BACKUP_VALUE 0x55
179#define MXT_BACKUP_TIME 25
180#define MXT_RESET_TIME 65
181
182#define MXT_FWRESET_TIME 175
183
184
185#define MXT_UNLOCK_CMD_MSB 0xaa
186#define MXT_UNLOCK_CMD_LSB 0xdc
187
188
189#define MXT_WAITING_BOOTLOAD_CMD 0xc0
190#define MXT_WAITING_FRAME_DATA 0x80
191#define MXT_FRAME_CRC_CHECK 0x02
192#define MXT_FRAME_CRC_FAIL 0x03
193#define MXT_FRAME_CRC_PASS 0x04
194#define MXT_APP_CRC_FAIL 0x40
195#define MXT_BOOT_STATUS_MASK 0x3f
196
197
198#define MXT_UNGRIP (1 << 0)
199#define MXT_SUPPRESS (1 << 1)
200#define MXT_AMP (1 << 2)
201#define MXT_VECTOR (1 << 3)
202#define MXT_MOVE (1 << 4)
203#define MXT_RELEASE (1 << 5)
204#define MXT_PRESS (1 << 6)
205#define MXT_DETECT (1 << 7)
206
207
208#define MXT_XY_SWITCH (1 << 0)
209#define MXT_X_INVERT (1 << 1)
210#define MXT_Y_INVERT (1 << 2)
211
212
213#define MXT_MAX_AREA 0xff
214
215struct mxt_info {
216 u8 family_id;
217 u8 variant_id;
218 u8 version;
219 u8 build;
220 u8 matrix_xsize;
221 u8 matrix_ysize;
222 u8 object_num;
223};
224
225struct mxt_object {
226 u8 type;
227 u16 start_address;
228 u8 size;
229 u8 instances;
230 u8 num_report_ids;
231} __packed;
232
233struct mxt_message {
234 u8 reportid;
235 u8 message[7];
236};
237
238
239struct mxt_data {
240 struct i2c_client *client;
241 struct input_dev *input_dev;
242 char phys[64];
243 const struct mxt_platform_data *pdata;
244 struct mxt_object *object_table;
245 struct mxt_info info;
246 unsigned int irq;
247 unsigned int max_x;
248 unsigned int max_y;
249
250
251 u8 T6_reportid;
252 u8 T9_reportid_min;
253 u8 T9_reportid_max;
254};
255
256static bool mxt_object_readable(unsigned int type)
257{
258 switch (type) {
259 case MXT_GEN_COMMAND_T6:
260 case MXT_GEN_POWER_T7:
261 case MXT_GEN_ACQUIRE_T8:
262 case MXT_GEN_DATASOURCE_T53:
263 case MXT_TOUCH_MULTI_T9:
264 case MXT_TOUCH_KEYARRAY_T15:
265 case MXT_TOUCH_PROXIMITY_T23:
266 case MXT_TOUCH_PROXKEY_T52:
267 case MXT_PROCI_GRIPFACE_T20:
268 case MXT_PROCG_NOISE_T22:
269 case MXT_PROCI_ONETOUCH_T24:
270 case MXT_PROCI_TWOTOUCH_T27:
271 case MXT_PROCI_GRIP_T40:
272 case MXT_PROCI_PALM_T41:
273 case MXT_PROCI_TOUCHSUPPRESSION_T42:
274 case MXT_PROCI_STYLUS_T47:
275 case MXT_PROCG_NOISESUPPRESSION_T48:
276 case MXT_SPT_COMMSCONFIG_T18:
277 case MXT_SPT_GPIOPWM_T19:
278 case MXT_SPT_SELFTEST_T25:
279 case MXT_SPT_CTECONFIG_T28:
280 case MXT_SPT_USERDATA_T38:
281 case MXT_SPT_DIGITIZER_T43:
282 case MXT_SPT_CTECONFIG_T46:
283 return true;
284 default:
285 return false;
286 }
287}
288
289static bool mxt_object_writable(unsigned int type)
290{
291 switch (type) {
292 case MXT_GEN_COMMAND_T6:
293 case MXT_GEN_POWER_T7:
294 case MXT_GEN_ACQUIRE_T8:
295 case MXT_TOUCH_MULTI_T9:
296 case MXT_TOUCH_KEYARRAY_T15:
297 case MXT_TOUCH_PROXIMITY_T23:
298 case MXT_TOUCH_PROXKEY_T52:
299 case MXT_PROCI_GRIPFACE_T20:
300 case MXT_PROCG_NOISE_T22:
301 case MXT_PROCI_ONETOUCH_T24:
302 case MXT_PROCI_TWOTOUCH_T27:
303 case MXT_PROCI_GRIP_T40:
304 case MXT_PROCI_PALM_T41:
305 case MXT_PROCI_TOUCHSUPPRESSION_T42:
306 case MXT_PROCI_STYLUS_T47:
307 case MXT_PROCG_NOISESUPPRESSION_T48:
308 case MXT_SPT_COMMSCONFIG_T18:
309 case MXT_SPT_GPIOPWM_T19:
310 case MXT_SPT_SELFTEST_T25:
311 case MXT_SPT_CTECONFIG_T28:
312 case MXT_SPT_DIGITIZER_T43:
313 case MXT_SPT_CTECONFIG_T46:
314 return true;
315 default:
316 return false;
317 }
318}
319
320static void mxt_dump_message(struct device *dev,
321 struct mxt_message *message)
322{
323 dev_dbg(dev, "reportid: %u\tmessage: %*ph\n",
324 message->reportid, 7, message->message);
325}
326
327static int mxt_check_bootloader(struct i2c_client *client,
328 unsigned int state)
329{
330 u8 val;
331
332recheck:
333 if (i2c_master_recv(client, &val, 1) != 1) {
334 dev_err(&client->dev, "%s: i2c recv failed\n", __func__);
335 return -EIO;
336 }
337
338 switch (state) {
339 case MXT_WAITING_BOOTLOAD_CMD:
340 case MXT_WAITING_FRAME_DATA:
341 val &= ~MXT_BOOT_STATUS_MASK;
342 break;
343 case MXT_FRAME_CRC_PASS:
344 if (val == MXT_FRAME_CRC_CHECK)
345 goto recheck;
346 break;
347 default:
348 return -EINVAL;
349 }
350
351 if (val != state) {
352 dev_err(&client->dev, "Unvalid bootloader mode state\n");
353 return -EINVAL;
354 }
355
356 return 0;
357}
358
359static int mxt_unlock_bootloader(struct i2c_client *client)
360{
361 u8 buf[2];
362
363 buf[0] = MXT_UNLOCK_CMD_LSB;
364 buf[1] = MXT_UNLOCK_CMD_MSB;
365
366 if (i2c_master_send(client, buf, 2) != 2) {
367 dev_err(&client->dev, "%s: i2c send failed\n", __func__);
368 return -EIO;
369 }
370
371 return 0;
372}
373
374static int mxt_fw_write(struct i2c_client *client,
375 const u8 *data, unsigned int frame_size)
376{
377 if (i2c_master_send(client, data, frame_size) != frame_size) {
378 dev_err(&client->dev, "%s: i2c send failed\n", __func__);
379 return -EIO;
380 }
381
382 return 0;
383}
384
385static int __mxt_read_reg(struct i2c_client *client,
386 u16 reg, u16 len, void *val)
387{
388 struct i2c_msg xfer[2];
389 u8 buf[2];
390 int ret;
391
392 buf[0] = reg & 0xff;
393 buf[1] = (reg >> 8) & 0xff;
394
395
396 xfer[0].addr = client->addr;
397 xfer[0].flags = 0;
398 xfer[0].len = 2;
399 xfer[0].buf = buf;
400
401
402 xfer[1].addr = client->addr;
403 xfer[1].flags = I2C_M_RD;
404 xfer[1].len = len;
405 xfer[1].buf = val;
406
407 ret = i2c_transfer(client->adapter, xfer, 2);
408 if (ret == 2) {
409 ret = 0;
410 } else {
411 if (ret >= 0)
412 ret = -EIO;
413 dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
414 __func__, ret);
415 }
416
417 return ret;
418}
419
420static int mxt_read_reg(struct i2c_client *client, u16 reg, u8 *val)
421{
422 return __mxt_read_reg(client, reg, 1, val);
423}
424
425static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
426 const void *val)
427{
428 u8 *buf;
429 size_t count;
430 int ret;
431
432 count = len + 2;
433 buf = kmalloc(count, GFP_KERNEL);
434 if (!buf)
435 return -ENOMEM;
436
437 buf[0] = reg & 0xff;
438 buf[1] = (reg >> 8) & 0xff;
439 memcpy(&buf[2], val, len);
440
441 ret = i2c_master_send(client, buf, count);
442 if (ret == count) {
443 ret = 0;
444 } else {
445 if (ret >= 0)
446 ret = -EIO;
447 dev_err(&client->dev, "%s: i2c send failed (%d)\n",
448 __func__, ret);
449 }
450
451 kfree(buf);
452 return ret;
453}
454
455static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
456{
457 return __mxt_write_reg(client, reg, 1, &val);
458}
459
460static struct mxt_object *
461mxt_get_object(struct mxt_data *data, u8 type)
462{
463 struct mxt_object *object;
464 int i;
465
466 for (i = 0; i < data->info.object_num; i++) {
467 object = data->object_table + i;
468 if (object->type == type)
469 return object;
470 }
471
472 dev_err(&data->client->dev, "Invalid object type\n");
473 return NULL;
474}
475
476static int mxt_read_message(struct mxt_data *data,
477 struct mxt_message *message)
478{
479 struct mxt_object *object;
480 u16 reg;
481
482 object = mxt_get_object(data, MXT_GEN_MESSAGE_T5);
483 if (!object)
484 return -EINVAL;
485
486 reg = object->start_address;
487 return __mxt_read_reg(data->client, reg,
488 sizeof(struct mxt_message), message);
489}
490
491static int mxt_write_object(struct mxt_data *data,
492 u8 type, u8 offset, u8 val)
493{
494 struct mxt_object *object;
495 u16 reg;
496
497 object = mxt_get_object(data, type);
498 if (!object || offset >= object->size + 1)
499 return -EINVAL;
500
501 reg = object->start_address;
502 return mxt_write_reg(data->client, reg + offset, val);
503}
504
505static void mxt_input_touchevent(struct mxt_data *data,
506 struct mxt_message *message, int id)
507{
508 struct device *dev = &data->client->dev;
509 u8 status = message->message[0];
510 struct input_dev *input_dev = data->input_dev;
511 int x;
512 int y;
513 int area;
514 int pressure;
515
516 x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf);
517 y = (message->message[2] << 4) | ((message->message[3] & 0xf));
518 if (data->max_x < 1024)
519 x = x >> 2;
520 if (data->max_y < 1024)
521 y = y >> 2;
522
523 area = message->message[4];
524 pressure = message->message[5];
525
526 dev_dbg(dev,
527 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
528 id,
529 (status & MXT_DETECT) ? 'D' : '.',
530 (status & MXT_PRESS) ? 'P' : '.',
531 (status & MXT_RELEASE) ? 'R' : '.',
532 (status & MXT_MOVE) ? 'M' : '.',
533 (status & MXT_VECTOR) ? 'V' : '.',
534 (status & MXT_AMP) ? 'A' : '.',
535 (status & MXT_SUPPRESS) ? 'S' : '.',
536 (status & MXT_UNGRIP) ? 'U' : '.',
537 x, y, area, pressure);
538
539 input_mt_slot(input_dev, id);
540 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
541 status & MXT_DETECT);
542
543 if (status & MXT_DETECT) {
544 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
545 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
546 input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
547 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
548 }
549}
550
551static unsigned mxt_extract_T6_csum(const u8 *csum)
552{
553 return csum[0] | (csum[1] << 8) | (csum[2] << 16);
554}
555
556static bool mxt_is_T9_message(struct mxt_data *data, struct mxt_message *msg)
557{
558 u8 id = msg->reportid;
559 return (id >= data->T9_reportid_min && id <= data->T9_reportid_max);
560}
561
562static irqreturn_t mxt_interrupt(int irq, void *dev_id)
563{
564 struct mxt_data *data = dev_id;
565 struct mxt_message message;
566 const u8 *payload = &message.message[0];
567 struct device *dev = &data->client->dev;
568 u8 reportid;
569 bool update_input = false;
570
571 do {
572 if (mxt_read_message(data, &message)) {
573 dev_err(dev, "Failed to read message\n");
574 goto end;
575 }
576
577 reportid = message.reportid;
578
579 if (reportid == data->T6_reportid) {
580 u8 status = payload[0];
581 unsigned csum = mxt_extract_T6_csum(&payload[1]);
582 dev_dbg(dev, "Status: %02x Config Checksum: %06x\n",
583 status, csum);
584 } else if (mxt_is_T9_message(data, &message)) {
585 int id = reportid - data->T9_reportid_min;
586 mxt_input_touchevent(data, &message, id);
587 update_input = true;
588 } else {
589 mxt_dump_message(dev, &message);
590 }
591 } while (reportid != 0xff);
592
593 if (update_input) {
594 input_mt_report_pointer_emulation(data->input_dev, false);
595 input_sync(data->input_dev);
596 }
597
598end:
599 return IRQ_HANDLED;
600}
601
602static int mxt_check_reg_init(struct mxt_data *data)
603{
604 const struct mxt_platform_data *pdata = data->pdata;
605 struct mxt_object *object;
606 struct device *dev = &data->client->dev;
607 int index = 0;
608 int i, size;
609 int ret;
610
611 if (!pdata->config) {
612 dev_dbg(dev, "No cfg data defined, skipping reg init\n");
613 return 0;
614 }
615
616 for (i = 0; i < data->info.object_num; i++) {
617 object = data->object_table + i;
618
619 if (!mxt_object_writable(object->type))
620 continue;
621
622 size = (object->size + 1) * (object->instances + 1);
623 if (index + size > pdata->config_length) {
624 dev_err(dev, "Not enough config data!\n");
625 return -EINVAL;
626 }
627
628 ret = __mxt_write_reg(data->client, object->start_address,
629 size, &pdata->config[index]);
630 if (ret)
631 return ret;
632 index += size;
633 }
634
635 return 0;
636}
637
638static int mxt_make_highchg(struct mxt_data *data)
639{
640 struct device *dev = &data->client->dev;
641 struct mxt_message message;
642 int count = 10;
643 int error;
644
645
646 do {
647 error = mxt_read_message(data, &message);
648 if (error)
649 return error;
650 } while (message.reportid != 0xff && --count);
651
652 if (!count) {
653 dev_err(dev, "CHG pin isn't cleared\n");
654 return -EBUSY;
655 }
656
657 return 0;
658}
659
660static void mxt_handle_pdata(struct mxt_data *data)
661{
662 const struct mxt_platform_data *pdata = data->pdata;
663 u8 voltage;
664
665
666 mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_XSIZE,
667 pdata->x_line);
668 mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_YSIZE,
669 pdata->y_line);
670
671
672 mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_ORIENT,
673 pdata->orient);
674
675
676 mxt_write_object(data, MXT_TOUCH_MULTI_T9,
677 MXT_TOUCH_BLEN, pdata->blen);
678
679
680 mxt_write_object(data, MXT_TOUCH_MULTI_T9,
681 MXT_TOUCH_TCHTHR, pdata->threshold);
682
683
684 mxt_write_object(data, MXT_TOUCH_MULTI_T9,
685 MXT_TOUCH_XRANGE_LSB, (pdata->x_size - 1) & 0xff);
686 mxt_write_object(data, MXT_TOUCH_MULTI_T9,
687 MXT_TOUCH_XRANGE_MSB, (pdata->x_size - 1) >> 8);
688 mxt_write_object(data, MXT_TOUCH_MULTI_T9,
689 MXT_TOUCH_YRANGE_LSB, (pdata->y_size - 1) & 0xff);
690 mxt_write_object(data, MXT_TOUCH_MULTI_T9,
691 MXT_TOUCH_YRANGE_MSB, (pdata->y_size - 1) >> 8);
692
693
694 if (pdata->voltage) {
695 if (pdata->voltage < MXT_VOLTAGE_DEFAULT) {
696 voltage = (MXT_VOLTAGE_DEFAULT - pdata->voltage) /
697 MXT_VOLTAGE_STEP;
698 voltage = 0xff - voltage + 1;
699 } else
700 voltage = (pdata->voltage - MXT_VOLTAGE_DEFAULT) /
701 MXT_VOLTAGE_STEP;
702
703 mxt_write_object(data, MXT_SPT_CTECONFIG_T28,
704 MXT_CTE_VOLTAGE, voltage);
705 }
706}
707
708static int mxt_get_info(struct mxt_data *data)
709{
710 struct i2c_client *client = data->client;
711 struct mxt_info *info = &data->info;
712 int error;
713
714
715 error = __mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
716 if (error)
717 return error;
718
719 return 0;
720}
721
722static int mxt_get_object_table(struct mxt_data *data)
723{
724 struct i2c_client *client = data->client;
725 size_t table_size;
726 int error;
727 int i;
728 u8 reportid;
729
730 table_size = data->info.object_num * sizeof(struct mxt_object);
731 error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
732 data->object_table);
733 if (error)
734 return error;
735
736
737 reportid = 1;
738 for (i = 0; i < data->info.object_num; i++) {
739 struct mxt_object *object = data->object_table + i;
740 u8 min_id, max_id;
741
742 le16_to_cpus(&object->start_address);
743
744 if (object->num_report_ids) {
745 min_id = reportid;
746 reportid += object->num_report_ids *
747 (object->instances + 1);
748 max_id = reportid - 1;
749 } else {
750 min_id = 0;
751 max_id = 0;
752 }
753
754 dev_dbg(&data->client->dev,
755 "Type %2d Start %3d Size %3d Instances %2d ReportIDs %3u : %3u\n",
756 object->type, object->start_address, object->size + 1,
757 object->instances + 1, min_id, max_id);
758
759 switch (object->type) {
760 case MXT_GEN_COMMAND_T6:
761 data->T6_reportid = min_id;
762 break;
763 case MXT_TOUCH_MULTI_T9:
764 data->T9_reportid_min = min_id;
765 data->T9_reportid_max = max_id;
766 break;
767 }
768 }
769
770 return 0;
771}
772
773static void mxt_free_object_table(struct mxt_data *data)
774{
775 kfree(data->object_table);
776 data->object_table = NULL;
777 data->T6_reportid = 0;
778 data->T9_reportid_min = 0;
779 data->T9_reportid_max = 0;
780
781}
782
783static int mxt_initialize(struct mxt_data *data)
784{
785 struct i2c_client *client = data->client;
786 struct mxt_info *info = &data->info;
787 int error;
788 u8 val;
789
790 error = mxt_get_info(data);
791 if (error)
792 return error;
793
794 data->object_table = kcalloc(info->object_num,
795 sizeof(struct mxt_object),
796 GFP_KERNEL);
797 if (!data->object_table) {
798 dev_err(&client->dev, "Failed to allocate memory\n");
799 return -ENOMEM;
800 }
801
802
803 error = mxt_get_object_table(data);
804 if (error)
805 goto err_free_object_table;
806
807
808 error = mxt_check_reg_init(data);
809 if (error)
810 goto err_free_object_table;
811
812 mxt_handle_pdata(data);
813
814
815 mxt_write_object(data, MXT_GEN_COMMAND_T6,
816 MXT_COMMAND_BACKUPNV,
817 MXT_BACKUP_VALUE);
818 msleep(MXT_BACKUP_TIME);
819
820
821 mxt_write_object(data, MXT_GEN_COMMAND_T6,
822 MXT_COMMAND_RESET, 1);
823 msleep(MXT_RESET_TIME);
824
825
826 error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, &val);
827 if (error)
828 goto err_free_object_table;
829 info->matrix_xsize = val;
830
831 error = mxt_read_reg(client, MXT_MATRIX_Y_SIZE, &val);
832 if (error)
833 goto err_free_object_table;
834 info->matrix_ysize = val;
835
836 dev_info(&client->dev,
837 "Family ID: %u Variant ID: %u Major.Minor.Build: %u.%u.%02X\n",
838 info->family_id, info->variant_id, info->version >> 4,
839 info->version & 0xf, info->build);
840
841 dev_info(&client->dev,
842 "Matrix X Size: %u Matrix Y Size: %u Object Num: %u\n",
843 info->matrix_xsize, info->matrix_ysize,
844 info->object_num);
845
846 return 0;
847
848err_free_object_table:
849 mxt_free_object_table(data);
850 return error;
851}
852
853static void mxt_calc_resolution(struct mxt_data *data)
854{
855 unsigned int max_x = data->pdata->x_size - 1;
856 unsigned int max_y = data->pdata->y_size - 1;
857
858 if (data->pdata->orient & MXT_XY_SWITCH) {
859 data->max_x = max_y;
860 data->max_y = max_x;
861 } else {
862 data->max_x = max_x;
863 data->max_y = max_y;
864 }
865}
866
867
868static ssize_t mxt_fw_version_show(struct device *dev,
869 struct device_attribute *attr, char *buf)
870{
871 struct mxt_data *data = dev_get_drvdata(dev);
872 struct mxt_info *info = &data->info;
873 return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
874 info->version >> 4, info->version & 0xf, info->build);
875}
876
877
878static ssize_t mxt_hw_version_show(struct device *dev,
879 struct device_attribute *attr, char *buf)
880{
881 struct mxt_data *data = dev_get_drvdata(dev);
882 struct mxt_info *info = &data->info;
883 return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
884 info->family_id, info->variant_id);
885}
886
887static ssize_t mxt_show_instance(char *buf, int count,
888 struct mxt_object *object, int instance,
889 const u8 *val)
890{
891 int i;
892
893 if (object->instances > 0)
894 count += scnprintf(buf + count, PAGE_SIZE - count,
895 "Instance %u\n", instance);
896
897 for (i = 0; i < object->size + 1; i++)
898 count += scnprintf(buf + count, PAGE_SIZE - count,
899 "\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
900 count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
901
902 return count;
903}
904
905static ssize_t mxt_object_show(struct device *dev,
906 struct device_attribute *attr, char *buf)
907{
908 struct mxt_data *data = dev_get_drvdata(dev);
909 struct mxt_object *object;
910 int count = 0;
911 int i, j;
912 int error;
913 u8 *obuf;
914
915
916 obuf = kmalloc(256, GFP_KERNEL);
917 if (!obuf)
918 return -ENOMEM;
919
920 error = 0;
921 for (i = 0; i < data->info.object_num; i++) {
922 object = data->object_table + i;
923
924 if (!mxt_object_readable(object->type))
925 continue;
926
927 count += scnprintf(buf + count, PAGE_SIZE - count,
928 "T%u:\n", object->type);
929
930 for (j = 0; j < object->instances + 1; j++) {
931 u16 size = object->size + 1;
932 u16 addr = object->start_address + j * size;
933
934 error = __mxt_read_reg(data->client, addr, size, obuf);
935 if (error)
936 goto done;
937
938 count = mxt_show_instance(buf, count, object, j, obuf);
939 }
940 }
941
942done:
943 kfree(obuf);
944 return error ?: count;
945}
946
947static int mxt_load_fw(struct device *dev, const char *fn)
948{
949 struct mxt_data *data = dev_get_drvdata(dev);
950 struct i2c_client *client = data->client;
951 const struct firmware *fw = NULL;
952 unsigned int frame_size;
953 unsigned int pos = 0;
954 int ret;
955
956 ret = request_firmware(&fw, fn, dev);
957 if (ret) {
958 dev_err(dev, "Unable to open firmware %s\n", fn);
959 return ret;
960 }
961
962
963 mxt_write_object(data, MXT_GEN_COMMAND_T6,
964 MXT_COMMAND_RESET, MXT_BOOT_VALUE);
965 msleep(MXT_RESET_TIME);
966
967
968 if (client->addr == MXT_APP_LOW)
969 client->addr = MXT_BOOT_LOW;
970 else
971 client->addr = MXT_BOOT_HIGH;
972
973 ret = mxt_check_bootloader(client, MXT_WAITING_BOOTLOAD_CMD);
974 if (ret)
975 goto out;
976
977
978 mxt_unlock_bootloader(client);
979
980 while (pos < fw->size) {
981 ret = mxt_check_bootloader(client,
982 MXT_WAITING_FRAME_DATA);
983 if (ret)
984 goto out;
985
986 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
987
988
989
990
991 frame_size += 2;
992
993
994 mxt_fw_write(client, fw->data + pos, frame_size);
995
996 ret = mxt_check_bootloader(client,
997 MXT_FRAME_CRC_PASS);
998 if (ret)
999 goto out;
1000
1001 pos += frame_size;
1002
1003 dev_dbg(dev, "Updated %d bytes / %zd bytes\n", pos, fw->size);
1004 }
1005
1006out:
1007 release_firmware(fw);
1008
1009
1010 if (client->addr == MXT_BOOT_LOW)
1011 client->addr = MXT_APP_LOW;
1012 else
1013 client->addr = MXT_APP_HIGH;
1014
1015 return ret;
1016}
1017
1018static ssize_t mxt_update_fw_store(struct device *dev,
1019 struct device_attribute *attr,
1020 const char *buf, size_t count)
1021{
1022 struct mxt_data *data = dev_get_drvdata(dev);
1023 int error;
1024
1025 disable_irq(data->irq);
1026
1027 error = mxt_load_fw(dev, MXT_FW_NAME);
1028 if (error) {
1029 dev_err(dev, "The firmware update failed(%d)\n", error);
1030 count = error;
1031 } else {
1032 dev_dbg(dev, "The firmware update succeeded\n");
1033
1034
1035 msleep(MXT_FWRESET_TIME);
1036
1037 mxt_free_object_table(data);
1038
1039 mxt_initialize(data);
1040 }
1041
1042 enable_irq(data->irq);
1043
1044 error = mxt_make_highchg(data);
1045 if (error)
1046 return error;
1047
1048 return count;
1049}
1050
1051static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
1052static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
1053static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
1054static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
1055
1056static struct attribute *mxt_attrs[] = {
1057 &dev_attr_fw_version.attr,
1058 &dev_attr_hw_version.attr,
1059 &dev_attr_object.attr,
1060 &dev_attr_update_fw.attr,
1061 NULL
1062};
1063
1064static const struct attribute_group mxt_attr_group = {
1065 .attrs = mxt_attrs,
1066};
1067
1068static void mxt_start(struct mxt_data *data)
1069{
1070
1071 mxt_write_object(data,
1072 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83);
1073}
1074
1075static void mxt_stop(struct mxt_data *data)
1076{
1077
1078 mxt_write_object(data,
1079 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0);
1080}
1081
1082static int mxt_input_open(struct input_dev *dev)
1083{
1084 struct mxt_data *data = input_get_drvdata(dev);
1085
1086 mxt_start(data);
1087
1088 return 0;
1089}
1090
1091static void mxt_input_close(struct input_dev *dev)
1092{
1093 struct mxt_data *data = input_get_drvdata(dev);
1094
1095 mxt_stop(data);
1096}
1097
1098static int mxt_probe(struct i2c_client *client,
1099 const struct i2c_device_id *id)
1100{
1101 const struct mxt_platform_data *pdata = client->dev.platform_data;
1102 struct mxt_data *data;
1103 struct input_dev *input_dev;
1104 int error;
1105 unsigned int num_mt_slots;
1106
1107 if (!pdata)
1108 return -EINVAL;
1109
1110 data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
1111 input_dev = input_allocate_device();
1112 if (!data || !input_dev) {
1113 dev_err(&client->dev, "Failed to allocate memory\n");
1114 error = -ENOMEM;
1115 goto err_free_mem;
1116 }
1117
1118 input_dev->name = "Atmel maXTouch Touchscreen";
1119 snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
1120 client->adapter->nr, client->addr);
1121 input_dev->phys = data->phys;
1122
1123 input_dev->id.bustype = BUS_I2C;
1124 input_dev->dev.parent = &client->dev;
1125 input_dev->open = mxt_input_open;
1126 input_dev->close = mxt_input_close;
1127
1128 data->client = client;
1129 data->input_dev = input_dev;
1130 data->pdata = pdata;
1131 data->irq = client->irq;
1132
1133 mxt_calc_resolution(data);
1134
1135 error = mxt_initialize(data);
1136 if (error)
1137 goto err_free_mem;
1138
1139 __set_bit(EV_ABS, input_dev->evbit);
1140 __set_bit(EV_KEY, input_dev->evbit);
1141 __set_bit(BTN_TOUCH, input_dev->keybit);
1142
1143
1144 input_set_abs_params(input_dev, ABS_X,
1145 0, data->max_x, 0, 0);
1146 input_set_abs_params(input_dev, ABS_Y,
1147 0, data->max_y, 0, 0);
1148 input_set_abs_params(input_dev, ABS_PRESSURE,
1149 0, 255, 0, 0);
1150
1151
1152 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
1153 error = input_mt_init_slots(input_dev, num_mt_slots, 0);
1154 if (error)
1155 goto err_free_object;
1156 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1157 0, MXT_MAX_AREA, 0, 0);
1158 input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1159 0, data->max_x, 0, 0);
1160 input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1161 0, data->max_y, 0, 0);
1162 input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1163 0, 255, 0, 0);
1164
1165 input_set_drvdata(input_dev, data);
1166 i2c_set_clientdata(client, data);
1167
1168 error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
1169 pdata->irqflags | IRQF_ONESHOT,
1170 client->name, data);
1171 if (error) {
1172 dev_err(&client->dev, "Failed to register interrupt\n");
1173 goto err_free_object;
1174 }
1175
1176 error = mxt_make_highchg(data);
1177 if (error)
1178 goto err_free_irq;
1179
1180 error = input_register_device(input_dev);
1181 if (error)
1182 goto err_free_irq;
1183
1184 error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
1185 if (error)
1186 goto err_unregister_device;
1187
1188 return 0;
1189
1190err_unregister_device:
1191 input_unregister_device(input_dev);
1192 input_dev = NULL;
1193err_free_irq:
1194 free_irq(client->irq, data);
1195err_free_object:
1196 kfree(data->object_table);
1197err_free_mem:
1198 input_free_device(input_dev);
1199 kfree(data);
1200 return error;
1201}
1202
1203static int mxt_remove(struct i2c_client *client)
1204{
1205 struct mxt_data *data = i2c_get_clientdata(client);
1206
1207 sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
1208 free_irq(data->irq, data);
1209 input_unregister_device(data->input_dev);
1210 kfree(data->object_table);
1211 kfree(data);
1212
1213 return 0;
1214}
1215
1216#ifdef CONFIG_PM_SLEEP
1217static int mxt_suspend(struct device *dev)
1218{
1219 struct i2c_client *client = to_i2c_client(dev);
1220 struct mxt_data *data = i2c_get_clientdata(client);
1221 struct input_dev *input_dev = data->input_dev;
1222
1223 mutex_lock(&input_dev->mutex);
1224
1225 if (input_dev->users)
1226 mxt_stop(data);
1227
1228 mutex_unlock(&input_dev->mutex);
1229
1230 return 0;
1231}
1232
1233static int mxt_resume(struct device *dev)
1234{
1235 struct i2c_client *client = to_i2c_client(dev);
1236 struct mxt_data *data = i2c_get_clientdata(client);
1237 struct input_dev *input_dev = data->input_dev;
1238
1239
1240 mxt_write_object(data, MXT_GEN_COMMAND_T6,
1241 MXT_COMMAND_RESET, 1);
1242
1243 msleep(MXT_RESET_TIME);
1244
1245 mutex_lock(&input_dev->mutex);
1246
1247 if (input_dev->users)
1248 mxt_start(data);
1249
1250 mutex_unlock(&input_dev->mutex);
1251
1252 return 0;
1253}
1254#endif
1255
1256static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
1257
1258static const struct i2c_device_id mxt_id[] = {
1259 { "qt602240_ts", 0 },
1260 { "atmel_mxt_ts", 0 },
1261 { "mXT224", 0 },
1262 { }
1263};
1264MODULE_DEVICE_TABLE(i2c, mxt_id);
1265
1266static struct i2c_driver mxt_driver = {
1267 .driver = {
1268 .name = "atmel_mxt_ts",
1269 .owner = THIS_MODULE,
1270 .pm = &mxt_pm_ops,
1271 },
1272 .probe = mxt_probe,
1273 .remove = mxt_remove,
1274 .id_table = mxt_id,
1275};
1276
1277module_i2c_driver(mxt_driver);
1278
1279
1280MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
1281MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
1282MODULE_LICENSE("GPL");
1283
