Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
auo-pixcir-ts.c
Go to the documentation of this file.
1 /*
2  * Driver for AUO in-cell touchscreens
3  *
4  * Copyright (c) 2011 Heiko Stuebner <[email protected]>
5  *
6  * loosely based on auo_touch.c from Dell Streak vendor-kernel
7  *
8  * Copyright (c) 2008 QUALCOMM Incorporated.
9  * Copyright (c) 2008 QUALCOMM USA, INC.
10  *
11  *
12  * This software is licensed under the terms of the GNU General Public
13  * License version 2, as published by the Free Software Foundation, and
14  * may be copied, distributed, and modified under those terms.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU General Public License for more details.
20  *
21  */
22 
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/interrupt.h>
26 #include <linux/slab.h>
27 #include <linux/input.h>
28 #include <linux/jiffies.h>
29 #include <linux/i2c.h>
30 #include <linux/mutex.h>
31 #include <linux/delay.h>
32 #include <linux/gpio.h>
33 #include <linux/input/auo-pixcir-ts.h>
34 
35 /*
36  * Coordinate calculation:
37  * X1 = X1_LSB + X1_MSB*256
38  * Y1 = Y1_LSB + Y1_MSB*256
39  * X2 = X2_LSB + X2_MSB*256
40  * Y2 = Y2_LSB + Y2_MSB*256
41  */
42 #define AUO_PIXCIR_REG_X1_LSB 0x00
43 #define AUO_PIXCIR_REG_X1_MSB 0x01
44 #define AUO_PIXCIR_REG_Y1_LSB 0x02
45 #define AUO_PIXCIR_REG_Y1_MSB 0x03
46 #define AUO_PIXCIR_REG_X2_LSB 0x04
47 #define AUO_PIXCIR_REG_X2_MSB 0x05
48 #define AUO_PIXCIR_REG_Y2_LSB 0x06
49 #define AUO_PIXCIR_REG_Y2_MSB 0x07
50 
51 #define AUO_PIXCIR_REG_STRENGTH 0x0d
52 #define AUO_PIXCIR_REG_STRENGTH_X1_LSB 0x0e
53 #define AUO_PIXCIR_REG_STRENGTH_X1_MSB 0x0f
54 
55 #define AUO_PIXCIR_REG_RAW_DATA_X 0x2b
56 #define AUO_PIXCIR_REG_RAW_DATA_Y 0x4f
57 
58 #define AUO_PIXCIR_REG_X_SENSITIVITY 0x6f
59 #define AUO_PIXCIR_REG_Y_SENSITIVITY 0x70
60 #define AUO_PIXCIR_REG_INT_SETTING 0x71
61 #define AUO_PIXCIR_REG_INT_WIDTH 0x72
62 #define AUO_PIXCIR_REG_POWER_MODE 0x73
63 
64 #define AUO_PIXCIR_REG_VERSION 0x77
65 #define AUO_PIXCIR_REG_CALIBRATE 0x78
66 
67 #define AUO_PIXCIR_REG_TOUCHAREA_X1 0x1e
68 #define AUO_PIXCIR_REG_TOUCHAREA_Y1 0x1f
69 #define AUO_PIXCIR_REG_TOUCHAREA_X2 0x20
70 #define AUO_PIXCIR_REG_TOUCHAREA_Y2 0x21
71 
72 #define AUO_PIXCIR_REG_EEPROM_CALIB_X 0x42
73 #define AUO_PIXCIR_REG_EEPROM_CALIB_Y 0xad
74 
75 #define AUO_PIXCIR_INT_TPNUM_MASK 0xe0
76 #define AUO_PIXCIR_INT_TPNUM_SHIFT 5
77 #define AUO_PIXCIR_INT_RELEASE (1 << 4)
78 #define AUO_PIXCIR_INT_ENABLE (1 << 3)
79 #define AUO_PIXCIR_INT_POL_HIGH (1 << 2)
80 #define AUO_PIXCIR_INT_MODE_MASK 0x03
81 
82 /*
83  * Power modes:
84  * active: scan speed 60Hz
85  * sleep: scan speed 10Hz can be auto-activated, wakeup on 1st touch
86  * deep sleep: scan speed 1Hz can only be entered or left manually.
87  */
88 #define AUO_PIXCIR_POWER_ACTIVE 0x00
89 #define AUO_PIXCIR_POWER_SLEEP 0x01
90 #define AUO_PIXCIR_POWER_DEEP_SLEEP 0x02
91 #define AUO_PIXCIR_POWER_MASK 0x03
92 
93 #define AUO_PIXCIR_POWER_ALLOW_SLEEP (1 << 2)
94 #define AUO_PIXCIR_POWER_IDLE_TIME(ms) ((ms & 0xf) << 4)
95 
96 #define AUO_PIXCIR_CALIBRATE 0x03
97 
98 #define AUO_PIXCIR_EEPROM_CALIB_X_LEN 62
99 #define AUO_PIXCIR_EEPROM_CALIB_Y_LEN 36
100 
101 #define AUO_PIXCIR_RAW_DATA_X_LEN 18
102 #define AUO_PIXCIR_RAW_DATA_Y_LEN 11
103 
104 #define AUO_PIXCIR_STRENGTH_ENABLE (1 << 0)
105 
106 /* Touchscreen absolute values */
107 #define AUO_PIXCIR_REPORT_POINTS 2
108 #define AUO_PIXCIR_MAX_AREA 0xff
109 #define AUO_PIXCIR_PENUP_TIMEOUT_MS 10
110 
111 struct auo_pixcir_ts {
112  struct i2c_client *client;
113  struct input_dev *input;
114  char phys[32];
115 
116  /* special handling for touch_indicate interupt mode */
117  bool touch_ind_mode;
118 
119  wait_queue_head_t wait;
120  bool stopped;
121 };
122 
123 struct auo_point_t {
124  int coord_x;
125  int coord_y;
126  int area_major;
127  int area_minor;
128  int orientation;
129 };
130 
131 static int auo_pixcir_collect_data(struct auo_pixcir_ts *ts,
132  struct auo_point_t *point)
133 {
134  struct i2c_client *client = ts->client;
135  const struct auo_pixcir_ts_platdata *pdata = client->dev.platform_data;
136  uint8_t raw_coord[8];
137  uint8_t raw_area[4];
138  int i, ret;
139 
140  /* touch coordinates */
141  ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_X1_LSB,
142  8, raw_coord);
143  if (ret < 0) {
144  dev_err(&client->dev, "failed to read coordinate, %d\n", ret);
145  return ret;
146  }
147 
148  /* touch area */
149  ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_TOUCHAREA_X1,
150  4, raw_area);
151  if (ret < 0) {
152  dev_err(&client->dev, "could not read touch area, %d\n", ret);
153  return ret;
154  }
155 
156  for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) {
157  point[i].coord_x =
158  raw_coord[4 * i + 1] << 8 | raw_coord[4 * i];
159  point[i].coord_y =
160  raw_coord[4 * i + 3] << 8 | raw_coord[4 * i + 2];
161 
162  if (point[i].coord_x > pdata->x_max ||
163  point[i].coord_y > pdata->y_max) {
164  dev_warn(&client->dev, "coordinates (%d,%d) invalid\n",
165  point[i].coord_x, point[i].coord_y);
166  point[i].coord_x = point[i].coord_y = 0;
167  }
168 
169  /* determine touch major, minor and orientation */
170  point[i].area_major = max(raw_area[2 * i], raw_area[2 * i + 1]);
171  point[i].area_minor = min(raw_area[2 * i], raw_area[2 * i + 1]);
172  point[i].orientation = raw_area[2 * i] > raw_area[2 * i + 1];
173  }
174 
175  return 0;
176 }
177 
178 static irqreturn_t auo_pixcir_interrupt(int irq, void *dev_id)
179 {
180  struct auo_pixcir_ts *ts = dev_id;
181  struct i2c_client *client = ts->client;
182  const struct auo_pixcir_ts_platdata *pdata = client->dev.platform_data;
183  struct auo_point_t point[AUO_PIXCIR_REPORT_POINTS];
184  int i;
185  int ret;
186  int fingers = 0;
187  int abs = -1;
188 
189  while (!ts->stopped) {
190 
191  /* check for up event in touch touch_ind_mode */
192  if (ts->touch_ind_mode) {
193  if (gpio_get_value(pdata->gpio_int) == 0) {
194  input_mt_sync(ts->input);
195  input_report_key(ts->input, BTN_TOUCH, 0);
196  input_sync(ts->input);
197  break;
198  }
199  }
200 
201  ret = auo_pixcir_collect_data(ts, point);
202  if (ret < 0) {
203  /* we want to loop only in touch_ind_mode */
204  if (!ts->touch_ind_mode)
205  break;
206 
207  wait_event_timeout(ts->wait, ts->stopped,
208  msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS));
209  continue;
210  }
211 
212  for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) {
213  if (point[i].coord_x > 0 || point[i].coord_y > 0) {
214  input_report_abs(ts->input, ABS_MT_POSITION_X,
215  point[i].coord_x);
216  input_report_abs(ts->input, ABS_MT_POSITION_Y,
217  point[i].coord_y);
218  input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
219  point[i].area_major);
220  input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
221  point[i].area_minor);
222  input_report_abs(ts->input, ABS_MT_ORIENTATION,
223  point[i].orientation);
224  input_mt_sync(ts->input);
225 
226  /* use first finger as source for singletouch */
227  if (fingers == 0)
228  abs = i;
229 
230  /* number of touch points could also be queried
231  * via i2c but would require an additional call
232  */
233  fingers++;
234  }
235  }
236 
237  input_report_key(ts->input, BTN_TOUCH, fingers > 0);
238 
239  if (abs > -1) {
240  input_report_abs(ts->input, ABS_X, point[abs].coord_x);
241  input_report_abs(ts->input, ABS_Y, point[abs].coord_y);
242  }
243 
244  input_sync(ts->input);
245 
246  /* we want to loop only in touch_ind_mode */
247  if (!ts->touch_ind_mode)
248  break;
249 
250  wait_event_timeout(ts->wait, ts->stopped,
251  msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS));
252  }
253 
254  return IRQ_HANDLED;
255 }
256 
257 /*
258  * Set the power mode of the device.
259  * Valid modes are
260  * - AUO_PIXCIR_POWER_ACTIVE
261  * - AUO_PIXCIR_POWER_SLEEP - automatically left on first touch
262  * - AUO_PIXCIR_POWER_DEEP_SLEEP
263  */
264 static int auo_pixcir_power_mode(struct auo_pixcir_ts *ts, int mode)
265 {
266  struct i2c_client *client = ts->client;
267  int ret;
268 
269  ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_POWER_MODE);
270  if (ret < 0) {
271  dev_err(&client->dev, "unable to read reg %Xh, %d\n",
272  AUO_PIXCIR_REG_POWER_MODE, ret);
273  return ret;
274  }
275 
276  ret &= ~AUO_PIXCIR_POWER_MASK;
277  ret |= mode;
278 
279  ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_POWER_MODE, ret);
280  if (ret) {
281  dev_err(&client->dev, "unable to write reg %Xh, %d\n",
282  AUO_PIXCIR_REG_POWER_MODE, ret);
283  return ret;
284  }
285 
286  return 0;
287 }
288 
289 static __devinit int auo_pixcir_int_config(struct auo_pixcir_ts *ts,
290  int int_setting)
291 {
292  struct i2c_client *client = ts->client;
293  struct auo_pixcir_ts_platdata *pdata = client->dev.platform_data;
294  int ret;
295 
296  ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING);
297  if (ret < 0) {
298  dev_err(&client->dev, "unable to read reg %Xh, %d\n",
299  AUO_PIXCIR_REG_INT_SETTING, ret);
300  return ret;
301  }
302 
303  ret &= ~AUO_PIXCIR_INT_MODE_MASK;
304  ret |= int_setting;
305  ret |= AUO_PIXCIR_INT_POL_HIGH; /* always use high for interrupts */
306 
307  ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING,
308  ret);
309  if (ret < 0) {
310  dev_err(&client->dev, "unable to write reg %Xh, %d\n",
311  AUO_PIXCIR_REG_INT_SETTING, ret);
312  return ret;
313  }
314 
315  ts->touch_ind_mode = pdata->int_setting == AUO_PIXCIR_INT_TOUCH_IND;
316 
317  return 0;
318 }
319 
320 /* control the generation of interrupts on the device side */
321 static int auo_pixcir_int_toggle(struct auo_pixcir_ts *ts, bool enable)
322 {
323  struct i2c_client *client = ts->client;
324  int ret;
325 
326  ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING);
327  if (ret < 0) {
328  dev_err(&client->dev, "unable to read reg %Xh, %d\n",
329  AUO_PIXCIR_REG_INT_SETTING, ret);
330  return ret;
331  }
332 
333  if (enable)
334  ret |= AUO_PIXCIR_INT_ENABLE;
335  else
336  ret &= ~AUO_PIXCIR_INT_ENABLE;
337 
338  ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING,
339  ret);
340  if (ret < 0) {
341  dev_err(&client->dev, "unable to write reg %Xh, %d\n",
342  AUO_PIXCIR_REG_INT_SETTING, ret);
343  return ret;
344  }
345 
346  return 0;
347 }
348 
349 static int auo_pixcir_start(struct auo_pixcir_ts *ts)
350 {
351  struct i2c_client *client = ts->client;
352  int ret;
353 
354  ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_ACTIVE);
355  if (ret < 0) {
356  dev_err(&client->dev, "could not set power mode, %d\n",
357  ret);
358  return ret;
359  }
360 
361  ts->stopped = false;
362  mb();
363  enable_irq(client->irq);
364 
365  ret = auo_pixcir_int_toggle(ts, 1);
366  if (ret < 0) {
367  dev_err(&client->dev, "could not enable interrupt, %d\n",
368  ret);
369  disable_irq(client->irq);
370  return ret;
371  }
372 
373  return 0;
374 }
375 
376 static int auo_pixcir_stop(struct auo_pixcir_ts *ts)
377 {
378  struct i2c_client *client = ts->client;
379  int ret;
380 
381  ret = auo_pixcir_int_toggle(ts, 0);
382  if (ret < 0) {
383  dev_err(&client->dev, "could not disable interrupt, %d\n",
384  ret);
385  return ret;
386  }
387 
388  /* disable receiving of interrupts */
389  disable_irq(client->irq);
390  ts->stopped = true;
391  mb();
392  wake_up(&ts->wait);
393 
394  return auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_DEEP_SLEEP);
395 }
396 
397 static int auo_pixcir_input_open(struct input_dev *dev)
398 {
399  struct auo_pixcir_ts *ts = input_get_drvdata(dev);
400  int ret;
401 
402  ret = auo_pixcir_start(ts);
403  if (ret)
404  return ret;
405 
406  return 0;
407 }
408 
409 static void auo_pixcir_input_close(struct input_dev *dev)
410 {
411  struct auo_pixcir_ts *ts = input_get_drvdata(dev);
412 
413  auo_pixcir_stop(ts);
414 
415  return;
416 }
417 
418 #ifdef CONFIG_PM_SLEEP
419 static int auo_pixcir_suspend(struct device *dev)
420 {
421  struct i2c_client *client = to_i2c_client(dev);
422  struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
423  struct input_dev *input = ts->input;
424  int ret = 0;
425 
426  mutex_lock(&input->mutex);
427 
428  /* when configured as wakeup source, device should always wake system
429  * therefore start device if necessary
430  */
431  if (device_may_wakeup(&client->dev)) {
432  /* need to start device if not open, to be wakeup source */
433  if (!input->users) {
434  ret = auo_pixcir_start(ts);
435  if (ret)
436  goto unlock;
437  }
438 
439  enable_irq_wake(client->irq);
440  ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_SLEEP);
441  } else if (input->users) {
442  ret = auo_pixcir_stop(ts);
443  }
444 
445 unlock:
446  mutex_unlock(&input->mutex);
447 
448  return ret;
449 }
450 
451 static int auo_pixcir_resume(struct device *dev)
452 {
453  struct i2c_client *client = to_i2c_client(dev);
454  struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
455  struct input_dev *input = ts->input;
456  int ret = 0;
457 
458  mutex_lock(&input->mutex);
459 
460  if (device_may_wakeup(&client->dev)) {
461  disable_irq_wake(client->irq);
462 
463  /* need to stop device if it was not open on suspend */
464  if (!input->users) {
465  ret = auo_pixcir_stop(ts);
466  if (ret)
467  goto unlock;
468  }
469 
470  /* device wakes automatically from SLEEP */
471  } else if (input->users) {
472  ret = auo_pixcir_start(ts);
473  }
474 
475 unlock:
476  mutex_unlock(&input->mutex);
477 
478  return ret;
479 }
480 #endif
481 
482 static SIMPLE_DEV_PM_OPS(auo_pixcir_pm_ops, auo_pixcir_suspend,
483  auo_pixcir_resume);
484 
485 static int __devinit auo_pixcir_probe(struct i2c_client *client,
486  const struct i2c_device_id *id)
487 {
488  const struct auo_pixcir_ts_platdata *pdata = client->dev.platform_data;
489  struct auo_pixcir_ts *ts;
490  struct input_dev *input_dev;
491  int ret;
492 
493  if (!pdata)
494  return -EINVAL;
495 
496  ts = kzalloc(sizeof(struct auo_pixcir_ts), GFP_KERNEL);
497  if (!ts)
498  return -ENOMEM;
499 
500  ret = gpio_request(pdata->gpio_int, "auo_pixcir_ts_int");
501  if (ret) {
502  dev_err(&client->dev, "request of gpio %d failed, %d\n",
503  pdata->gpio_int, ret);
504  goto err_gpio_int;
505  }
506 
507  if (pdata->init_hw)
508  pdata->init_hw(client);
509 
510  ts->client = client;
511  ts->touch_ind_mode = 0;
512  init_waitqueue_head(&ts->wait);
513 
514  snprintf(ts->phys, sizeof(ts->phys),
515  "%s/input0", dev_name(&client->dev));
516 
517  input_dev = input_allocate_device();
518  if (!input_dev) {
519  dev_err(&client->dev, "could not allocate input device\n");
520  goto err_input_alloc;
521  }
522 
523  ts->input = input_dev;
524 
525  input_dev->name = "AUO-Pixcir touchscreen";
526  input_dev->phys = ts->phys;
527  input_dev->id.bustype = BUS_I2C;
528  input_dev->dev.parent = &client->dev;
529 
530  input_dev->open = auo_pixcir_input_open;
531  input_dev->close = auo_pixcir_input_close;
532 
533  __set_bit(EV_ABS, input_dev->evbit);
534  __set_bit(EV_KEY, input_dev->evbit);
535 
536  __set_bit(BTN_TOUCH, input_dev->keybit);
537 
538  /* For single touch */
539  input_set_abs_params(input_dev, ABS_X, 0, pdata->x_max, 0, 0);
540  input_set_abs_params(input_dev, ABS_Y, 0, pdata->y_max, 0, 0);
541 
542  /* For multi touch */
543  input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
544  pdata->x_max, 0, 0);
545  input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
546  pdata->y_max, 0, 0);
547  input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0,
548  AUO_PIXCIR_MAX_AREA, 0, 0);
549  input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0,
550  AUO_PIXCIR_MAX_AREA, 0, 0);
551  input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
552 
553  ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_VERSION);
554  if (ret < 0)
555  goto err_fw_vers;
556  dev_info(&client->dev, "firmware version 0x%X\n", ret);
557 
558  ret = auo_pixcir_int_config(ts, pdata->int_setting);
559  if (ret)
560  goto err_fw_vers;
561 
562  input_set_drvdata(ts->input, ts);
563  ts->stopped = true;
564 
565  ret = request_threaded_irq(client->irq, NULL, auo_pixcir_interrupt,
566  IRQF_TRIGGER_RISING | IRQF_ONESHOT,
567  input_dev->name, ts);
568  if (ret) {
569  dev_err(&client->dev, "irq %d requested failed\n", client->irq);
570  goto err_fw_vers;
571  }
572 
573  /* stop device and put it into deep sleep until it is opened */
574  ret = auo_pixcir_stop(ts);
575  if (ret < 0)
576  goto err_input_register;
577 
578  ret = input_register_device(input_dev);
579  if (ret) {
580  dev_err(&client->dev, "could not register input device\n");
581  goto err_input_register;
582  }
583 
584  i2c_set_clientdata(client, ts);
585 
586  return 0;
587 
588 err_input_register:
589  free_irq(client->irq, ts);
590 err_fw_vers:
591  input_free_device(input_dev);
592 err_input_alloc:
593  if (pdata->exit_hw)
594  pdata->exit_hw(client);
595  gpio_free(pdata->gpio_int);
596 err_gpio_int:
597  kfree(ts);
598 
599  return ret;
600 }
601 
602 static int __devexit auo_pixcir_remove(struct i2c_client *client)
603 {
604  struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
605  const struct auo_pixcir_ts_platdata *pdata = client->dev.platform_data;
606 
607  free_irq(client->irq, ts);
608 
609  input_unregister_device(ts->input);
610 
611  if (pdata->exit_hw)
612  pdata->exit_hw(client);
613 
614  gpio_free(pdata->gpio_int);
615 
616  kfree(ts);
617 
618  return 0;
619 }
620 
621 static const struct i2c_device_id auo_pixcir_idtable[] = {
622  { "auo_pixcir_ts", 0 },
623  { }
624 };
625 MODULE_DEVICE_TABLE(i2c, auo_pixcir_idtable);
626 
627 static struct i2c_driver auo_pixcir_driver = {
628  .driver = {
629  .owner = THIS_MODULE,
630  .name = "auo_pixcir_ts",
631  .pm = &auo_pixcir_pm_ops,
632  },
633  .probe = auo_pixcir_probe,
634  .remove = __devexit_p(auo_pixcir_remove),
635  .id_table = auo_pixcir_idtable,
636 };
637 
638 module_i2c_driver(auo_pixcir_driver);
639 
640 MODULE_DESCRIPTION("AUO-PIXCIR touchscreen driver");
641 MODULE_LICENSE("GPL v2");
642 MODULE_AUTHOR("Heiko Stuebner <[email protected]>");
Generated on Thu Jan 10 2013 13:40:12 for Linux Kernel by   doxygen 1.8.2