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