Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
atmel_mxt_ts.c
Go to the documentation of this file.
1 /*
2  * Atmel maXTouch Touchscreen driver
3  *
4  * Copyright (C) 2010 Samsung Electronics Co.Ltd
5  * Author: Joonyoung Shim <[email protected]>
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_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 /* Object types */
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 /* MXT_GEN_COMMAND_T6 field */
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 /* MXT_GEN_POWER_T7 field */
88 #define MXT_POWER_IDLEACQINT 0
89 #define MXT_POWER_ACTVACQINT 1
90 #define MXT_POWER_ACTV2IDLETO 2
91 
92 /* MXT_GEN_ACQUIRE_T8 field */
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 /* MXT_TOUCH_MULTI_T9 field */
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 /* MXT_PROCI_GRIPFACE_T20 field */
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 /* MXT_PROCI_NOISE field */
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 /* MXT_SPT_COMMSCONFIG_T18 */
162 #define MXT_COMMS_CTRL 0
163 #define MXT_COMMS_CMD 1
164 
165 /* MXT_SPT_CTECONFIG_T28 field */
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 /* Define for MXT_GEN_COMMAND_T6 */
177 #define MXT_BOOT_VALUE 0xa5
178 #define MXT_BACKUP_VALUE 0x55
179 #define MXT_BACKUP_TIME 25 /* msec */
180 #define MXT_RESET_TIME 65 /* msec */
181 
182 #define MXT_FWRESET_TIME 175 /* msec */
183 
184 /* Command to unlock bootloader */
185 #define MXT_UNLOCK_CMD_MSB 0xaa
186 #define MXT_UNLOCK_CMD_LSB 0xdc
187 
188 /* Bootloader mode status */
189 #define MXT_WAITING_BOOTLOAD_CMD 0xc0 /* valid 7 6 bit only */
190 #define MXT_WAITING_FRAME_DATA 0x80 /* valid 7 6 bit only */
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 /* valid 7 8 bit only */
195 #define MXT_BOOT_STATUS_MASK 0x3f
196 
197 /* Touch status */
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 /* Touch orient bits */
208 #define MXT_XY_SWITCH (1 << 0)
209 #define MXT_X_INVERT (1 << 1)
210 #define MXT_Y_INVERT (1 << 2)
211 
212 /* Touchscreen absolute values */
213 #define MXT_MAX_AREA 0xff
214 
215 struct mxt_info {
223 };
224 
225 struct mxt_object {
228  u8 size; /* Size of each instance - 1 */
229  u8 instances; /* Number of instances - 1 */
231 } __packed;
232 
233 struct mxt_message {
236 };
237 
238 /* Each client has this additional data */
239 struct mxt_data {
242  char phys[64]; /* device physical location */
243  const struct mxt_platform_data *pdata;
245  struct mxt_info info;
246  unsigned int irq;
247  unsigned int max_x;
248  unsigned int max_y;
249 
250  /* Cached parameters from object table */
254 };
255 
256 static 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:
263  case MXT_TOUCH_MULTI_T9:
268  case MXT_PROCG_NOISE_T22:
271  case MXT_PROCI_GRIP_T40:
272  case MXT_PROCI_PALM_T41:
277  case MXT_SPT_GPIOPWM_T19:
283  return true;
284  default:
285  return false;
286  }
287 }
288 
289 static 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:
300  case MXT_PROCG_NOISE_T22:
303  case MXT_PROCI_GRIP_T40:
304  case MXT_PROCI_PALM_T41:
309  case MXT_SPT_GPIOPWM_T19:
314  return true;
315  default:
316  return false;
317  }
318 }
319 
320 static 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 
327 static int mxt_check_bootloader(struct i2c_client *client,
328  unsigned int state)
329 {
330  u8 val;
331 
332 recheck:
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) {
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 
359 static 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 
374 static 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 
385 static 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  /* Write register */
396  xfer[0].addr = client->addr;
397  xfer[0].flags = 0;
398  xfer[0].len = 2;
399  xfer[0].buf = buf;
400 
401  /* Read data */
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 
420 static int mxt_read_reg(struct i2c_client *client, u16 reg, u8 *val)
421 {
422  return __mxt_read_reg(client, reg, 1, val);
423 }
424 
425 static 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 
455 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
456 {
457  return __mxt_write_reg(client, reg, 1, &val);
458 }
459 
460 static struct mxt_object *
461 mxt_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 
476 static 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 
491 static 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 
505 static 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);
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 
551 static unsigned mxt_extract_T6_csum(const u8 *csum)
552 {
553  return csum[0] | (csum[1] << 8) | (csum[2] << 16);
554 }
555 
556 static 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 
562 static 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) {
595  input_sync(data->input_dev);
596  }
597 
598 end:
599  return IRQ_HANDLED;
600 }
601 
602 static 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 
638 static 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  /* Read dummy message to make high CHG pin */
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 
660 static void mxt_handle_pdata(struct mxt_data *data)
661 {
662  const struct mxt_platform_data *pdata = data->pdata;
663  u8 voltage;
664 
665  /* Set touchscreen lines */
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  /* Set touchscreen orient */
672  mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_ORIENT,
673  pdata->orient);
674 
675  /* Set touchscreen burst length */
676  mxt_write_object(data, MXT_TOUCH_MULTI_T9,
677  MXT_TOUCH_BLEN, pdata->blen);
678 
679  /* Set touchscreen threshold */
680  mxt_write_object(data, MXT_TOUCH_MULTI_T9,
681  MXT_TOUCH_TCHTHR, pdata->threshold);
682 
683  /* Set touchscreen resolution */
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  /* Set touchscreen voltage */
694  if (pdata->voltage) {
695  if (pdata->voltage < MXT_VOLTAGE_DEFAULT) {
696  voltage = (MXT_VOLTAGE_DEFAULT - pdata->voltage) /
698  voltage = 0xff - voltage + 1;
699  } else
700  voltage = (pdata->voltage - MXT_VOLTAGE_DEFAULT) /
702 
703  mxt_write_object(data, MXT_SPT_CTECONFIG_T28,
704  MXT_CTE_VOLTAGE, voltage);
705  }
706 }
707 
708 static 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  /* Read 7-byte info block starting at address 0 */
715  error = __mxt_read_reg(client, MXT_INFO, sizeof(*info), info);
716  if (error)
717  return error;
718 
719  return 0;
720 }
721 
722 static 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  /* Valid Report IDs start counting from 1 */
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 
773 static 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 
783 static 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  /* Get object table information */
803  error = mxt_get_object_table(data);
804  if (error)
805  goto err_free_object_table;
806 
807  /* Check register init values */
808  error = mxt_check_reg_init(data);
809  if (error)
810  goto err_free_object_table;
811 
812  mxt_handle_pdata(data);
813 
814  /* Backup to memory */
815  mxt_write_object(data, MXT_GEN_COMMAND_T6,
819 
820  /* Soft reset */
821  mxt_write_object(data, MXT_GEN_COMMAND_T6,
822  MXT_COMMAND_RESET, 1);
824 
825  /* Update matrix size at info struct */
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 
848 err_free_object_table:
849  mxt_free_object_table(data);
850  return error;
851 }
852 
853 static 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 /* Firmware Version is returned as Major.Minor.Build */
868 static 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 /* Hardware Version is returned as FamilyID.VariantID */
878 static 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 
887 static 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 
905 static 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  /* Pre-allocate buffer large enough to hold max sized object. */
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 
942 done:
943  kfree(obuf);
944  return error ?: count;
945 }
946 
947 static 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  /* Change to the bootloader mode */
963  mxt_write_object(data, MXT_GEN_COMMAND_T6,
966 
967  /* Change to slave address of bootloader */
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  /* Unlock bootloader */
978  mxt_unlock_bootloader(client);
979 
980  while (pos < fw->size) {
981  ret = mxt_check_bootloader(client,
983  if (ret)
984  goto out;
985 
986  frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
987 
988  /* We should add 2 at frame size as the the firmware data is not
989  * included the CRC bytes.
990  */
991  frame_size += 2;
992 
993  /* Write one frame to device */
994  mxt_fw_write(client, fw->data + pos, frame_size);
995 
996  ret = mxt_check_bootloader(client,
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 
1006 out:
1007  release_firmware(fw);
1008 
1009  /* Change to slave address of application */
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 
1018 static 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  /* Wait for reset */
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 
1051 static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
1052 static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
1053 static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
1054 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
1055 
1056 static 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 
1064 static const struct attribute_group mxt_attr_group = {
1065  .attrs = mxt_attrs,
1066 };
1067 
1068 static void mxt_start(struct mxt_data *data)
1069 {
1070  /* Touch enable */
1071  mxt_write_object(data,
1073 }
1074 
1075 static void mxt_stop(struct mxt_data *data)
1076 {
1077  /* Touch disable */
1078  mxt_write_object(data,
1080 }
1081 
1082 static 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 
1091 static 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 
1098 static int __devinit 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  /* For single touch */
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  /* For multi touch */
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 
1190 err_unregister_device:
1191  input_unregister_device(input_dev);
1192  input_dev = NULL;
1193 err_free_irq:
1194  free_irq(client->irq, data);
1195 err_free_object:
1196  kfree(data->object_table);
1197 err_free_mem:
1198  input_free_device(input_dev);
1199  kfree(data);
1200  return error;
1201 }
1202 
1203 static int __devexit 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
1217 static 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 
1233 static 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  /* Soft reset */
1240  mxt_write_object(data, MXT_GEN_COMMAND_T6,
1241  MXT_COMMAND_RESET, 1);
1242 
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 
1256 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
1257 
1258 static const struct i2c_device_id mxt_id[] = {
1259  { "qt602240_ts", 0 },
1260  { "atmel_mxt_ts", 0 },
1261  { "mXT224", 0 },
1262  { }
1263 };
1264 MODULE_DEVICE_TABLE(i2c, mxt_id);
1265 
1266 static 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 = __devexit_p(mxt_remove),
1274  .id_table = mxt_id,
1275 };
1276 
1277 module_i2c_driver(mxt_driver);
1278 
1279 /* Module information */
1280 MODULE_AUTHOR("Joonyoung Shim <[email protected]>");
1281 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
1282 MODULE_LICENSE("GPL");