Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
wm97xx-core.c
Go to the documentation of this file.
1 /*
2  * wm97xx-core.c -- Touch screen driver core for Wolfson WM9705, WM9712
3  * and WM9713 AC97 Codecs.
4  *
5  * Copyright 2003, 2004, 2005, 2006, 2007, 2008 Wolfson Microelectronics PLC.
6  * Author: Liam Girdwood <[email protected]>
7  * Parts Copyright : Ian Molton <[email protected]>
8  * Andrew Zabolotny <[email protected]>
9  * Russell King <[email protected]>
10  *
11  * This program is free software; you can redistribute it and/or modify it
12  * under the terms of the GNU General Public License as published by the
13  * Free Software Foundation; either version 2 of the License, or (at your
14  * option) any later version.
15  *
16  * Notes:
17  *
18  * Features:
19  * - supports WM9705, WM9712, WM9713
20  * - polling mode
21  * - continuous mode (arch-dependent)
22  * - adjustable rpu/dpp settings
23  * - adjustable pressure current
24  * - adjustable sample settle delay
25  * - 4 and 5 wire touchscreens (5 wire is WM9712 only)
26  * - pen down detection
27  * - battery monitor
28  * - sample AUX adcs
29  * - power management
30  * - codec GPIO
31  * - codec event notification
32  * Todo
33  * - Support for async sampling control for noisy LCDs.
34  *
35  */
36 
37 #include <linux/module.h>
38 #include <linux/moduleparam.h>
39 #include <linux/kernel.h>
40 #include <linux/init.h>
41 #include <linux/delay.h>
42 #include <linux/string.h>
43 #include <linux/proc_fs.h>
44 #include <linux/pm.h>
45 #include <linux/interrupt.h>
46 #include <linux/bitops.h>
47 #include <linux/workqueue.h>
48 #include <linux/wm97xx.h>
49 #include <linux/uaccess.h>
50 #include <linux/io.h>
51 #include <linux/slab.h>
52 
53 #define TS_NAME "wm97xx"
54 #define WM_CORE_VERSION "1.00"
55 #define DEFAULT_PRESSURE 0xb0c0
56 
57 
58 /*
59  * Touchscreen absolute values
60  *
61  * These parameters are used to help the input layer discard out of
62  * range readings and reduce jitter etc.
63  *
64  * o min, max:- indicate the min and max values your touch screen returns
65  * o fuzz:- use a higher number to reduce jitter
66  *
67  * The default values correspond to Mainstone II in QVGA mode
68  *
69  * Please read
70  * Documentation/input/input-programming.txt for more details.
71  */
72 
73 static int abs_x[3] = {350, 3900, 5};
74 module_param_array(abs_x, int, NULL, 0);
75 MODULE_PARM_DESC(abs_x, "Touchscreen absolute X min, max, fuzz");
76 
77 static int abs_y[3] = {320, 3750, 40};
78 module_param_array(abs_y, int, NULL, 0);
79 MODULE_PARM_DESC(abs_y, "Touchscreen absolute Y min, max, fuzz");
80 
81 static int abs_p[3] = {0, 150, 4};
82 module_param_array(abs_p, int, NULL, 0);
83 MODULE_PARM_DESC(abs_p, "Touchscreen absolute Pressure min, max, fuzz");
84 
85 /*
86  * wm97xx IO access, all IO locking done by AC97 layer
87  */
88 int wm97xx_reg_read(struct wm97xx *wm, u16 reg)
89 {
90  if (wm->ac97)
91  return wm->ac97->bus->ops->read(wm->ac97, reg);
92  else
93  return -1;
94 }
96 
97 void wm97xx_reg_write(struct wm97xx *wm, u16 reg, u16 val)
98 {
99  /* cache digitiser registers */
100  if (reg >= AC97_WM9713_DIG1 && reg <= AC97_WM9713_DIG3)
101  wm->dig[(reg - AC97_WM9713_DIG1) >> 1] = val;
102 
103  /* cache gpio regs */
104  if (reg >= AC97_GPIO_CFG && reg <= AC97_MISC_AFE)
105  wm->gpio[(reg - AC97_GPIO_CFG) >> 1] = val;
106 
107  /* wm9713 irq reg */
108  if (reg == 0x5a)
109  wm->misc = val;
110 
111  if (wm->ac97)
112  wm->ac97->bus->ops->write(wm->ac97, reg, val);
113 }
115 
124 int wm97xx_read_aux_adc(struct wm97xx *wm, u16 adcsel)
125 {
126  int power_adc = 0, auxval;
127  u16 power = 0;
128  int rc = 0;
129  int timeout = 0;
130 
131  /* get codec */
132  mutex_lock(&wm->codec_mutex);
133 
134  /* When the touchscreen is not in use, we may have to power up
135  * the AUX ADC before we can use sample the AUX inputs->
136  */
137  if (wm->id == WM9713_ID2 &&
138  (power = wm97xx_reg_read(wm, AC97_EXTENDED_MID)) & 0x8000) {
139  power_adc = 1;
140  wm97xx_reg_write(wm, AC97_EXTENDED_MID, power & 0x7fff);
141  }
142 
143  /* Prepare the codec for AUX reading */
144  wm->codec->aux_prepare(wm);
145 
146  /* Turn polling mode on to read AUX ADC */
147  wm->pen_probably_down = 1;
148 
149  while (rc != RC_VALID && timeout++ < 5)
150  rc = wm->codec->poll_sample(wm, adcsel, &auxval);
151 
152  if (power_adc)
153  wm97xx_reg_write(wm, AC97_EXTENDED_MID, power | 0x8000);
154 
155  wm->codec->dig_restore(wm);
156 
157  wm->pen_probably_down = 0;
158 
159  if (timeout >= 5) {
160  dev_err(wm->dev,
161  "timeout reading auxadc %d, disabling digitiser\n",
162  adcsel);
163  wm->codec->dig_enable(wm, false);
164  }
165 
167  return (rc == RC_VALID ? auxval & 0xfff : -EBUSY);
168 }
170 
180 {
181  u16 status;
182  enum wm97xx_gpio_status ret;
183 
184  mutex_lock(&wm->codec_mutex);
185  status = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
186 
187  if (status & gpio)
188  ret = WM97XX_GPIO_HIGH;
189  else
190  ret = WM97XX_GPIO_LOW;
191 
193  return ret;
194 }
196 
206 void wm97xx_set_gpio(struct wm97xx *wm, u32 gpio,
208 {
209  u16 reg;
210 
211  mutex_lock(&wm->codec_mutex);
213 
214  if (status == WM97XX_GPIO_HIGH)
215  reg |= gpio;
216  else
217  reg &= ~gpio;
218 
219  if (wm->id == WM9712_ID2 && wm->variant != WM97xx_WM1613)
220  wm97xx_reg_write(wm, AC97_GPIO_STATUS, reg << 1);
221  else
224 }
226 
227 /*
228  * Codec GPIO pin configuration, this sets pin direction, polarity,
229  * stickyness and wake up.
230  */
231 void wm97xx_config_gpio(struct wm97xx *wm, u32 gpio, enum wm97xx_gpio_dir dir,
232  enum wm97xx_gpio_pol pol, enum wm97xx_gpio_sticky sticky,
233  enum wm97xx_gpio_wake wake)
234 {
235  u16 reg;
236 
237  mutex_lock(&wm->codec_mutex);
239 
240  if (pol == WM97XX_GPIO_POL_HIGH)
241  reg |= gpio;
242  else
243  reg &= ~gpio;
244 
247 
248  if (sticky == WM97XX_GPIO_STICKY)
249  reg |= gpio;
250  else
251  reg &= ~gpio;
252 
255 
256  if (wake == WM97XX_GPIO_WAKE)
257  reg |= gpio;
258  else
259  reg &= ~gpio;
260 
262  reg = wm97xx_reg_read(wm, AC97_GPIO_CFG);
263 
264  if (dir == WM97XX_GPIO_IN)
265  reg |= gpio;
266  else
267  reg &= ~gpio;
268 
271 }
273 
274 /*
275  * Configure the WM97XX_PRP value to use while system is suspended.
276  * If a value other than 0 is set then WM97xx pen detection will be
277  * left enabled in the configured mode while the system is in suspend,
278  * the device has users and suspend has not been disabled via the
279  * wakeup sysfs entries.
280  *
281  * @wm: WM97xx device to configure
282  * @mode: WM97XX_PRP value to configure while suspended
283  */
285 {
286  wm->suspend_mode = mode;
287  device_init_wakeup(&wm->input_dev->dev, mode != 0);
288 }
290 
291 /*
292  * Handle a pen down interrupt.
293  */
294 static void wm97xx_pen_irq_worker(struct work_struct *work)
295 {
296  struct wm97xx *wm = container_of(work, struct wm97xx, pen_event_work);
297  int pen_was_down = wm->pen_is_down;
298 
299  /* do we need to enable the touch panel reader */
300  if (wm->id == WM9705_ID2) {
303  wm->pen_is_down = 1;
304  else
305  wm->pen_is_down = 0;
306  } else {
307  u16 status, pol;
308  mutex_lock(&wm->codec_mutex);
309  status = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
311 
312  if (WM97XX_GPIO_13 & pol & status) {
313  wm->pen_is_down = 1;
315  ~WM97XX_GPIO_13);
316  } else {
317  wm->pen_is_down = 0;
320  }
321 
322  if (wm->id == WM9712_ID2 && wm->variant != WM97xx_WM1613)
323  wm97xx_reg_write(wm, AC97_GPIO_STATUS, (status &
324  ~WM97XX_GPIO_13) << 1);
325  else
326  wm97xx_reg_write(wm, AC97_GPIO_STATUS, status &
327  ~WM97XX_GPIO_13);
329  }
330 
331  /* If the system is not using continuous mode or it provides a
332  * pen down operation then we need to schedule polls while the
333  * pen is down. Otherwise the machine driver is responsible
334  * for scheduling reads.
335  */
336  if (!wm->mach_ops->acc_enabled || wm->mach_ops->acc_pen_down) {
337  if (wm->pen_is_down && !pen_was_down) {
338  /* Data is not available immediately on pen down */
339  queue_delayed_work(wm->ts_workq, &wm->ts_reader, 1);
340  }
341 
342  /* Let ts_reader report the pen up for debounce. */
343  if (!wm->pen_is_down && pen_was_down)
344  wm->pen_is_down = 1;
345  }
346 
347  if (!wm->pen_is_down && wm->mach_ops->acc_enabled)
348  wm->mach_ops->acc_pen_up(wm);
349 
350  wm->mach_ops->irq_enable(wm, 1);
351 }
352 
353 /*
354  * Codec PENDOWN irq handler
355  *
356  * We have to disable the codec interrupt in the handler because it
357  * can take up to 1ms to clear the interrupt source. We schedule a task
358  * in a work queue to do the actual interaction with the chip. The
359  * interrupt is then enabled again in the slow handler when the source
360  * has been cleared.
361  */
362 static irqreturn_t wm97xx_pen_interrupt(int irq, void *dev_id)
363 {
364  struct wm97xx *wm = dev_id;
365 
366  if (!work_pending(&wm->pen_event_work)) {
367  wm->mach_ops->irq_enable(wm, 0);
369  }
370 
371  return IRQ_HANDLED;
372 }
373 
374 /*
375  * initialise pen IRQ handler and workqueue
376  */
377 static int wm97xx_init_pen_irq(struct wm97xx *wm)
378 {
379  u16 reg;
380 
381  /* If an interrupt is supplied an IRQ enable operation must also be
382  * provided. */
383  BUG_ON(!wm->mach_ops->irq_enable);
384 
385  if (request_irq(wm->pen_irq, wm97xx_pen_interrupt, IRQF_SHARED,
386  "wm97xx-pen", wm)) {
387  dev_err(wm->dev,
388  "Failed to register pen down interrupt, polling");
389  wm->pen_irq = 0;
390  return -EINVAL;
391  }
392 
393  /* Configure GPIO as interrupt source on WM971x */
394  if (wm->id != WM9705_ID2) {
395  BUG_ON(!wm->mach_ops->irq_gpio);
396  reg = wm97xx_reg_read(wm, AC97_MISC_AFE);
398  reg & ~(wm->mach_ops->irq_gpio));
399  reg = wm97xx_reg_read(wm, 0x5a);
400  wm97xx_reg_write(wm, 0x5a, reg & ~0x0001);
401  }
402 
403  return 0;
404 }
405 
406 static int wm97xx_read_samples(struct wm97xx *wm)
407 {
408  struct wm97xx_data data;
409  int rc;
410 
411  mutex_lock(&wm->codec_mutex);
412 
413  if (wm->mach_ops && wm->mach_ops->acc_enabled)
414  rc = wm->mach_ops->acc_pen_down(wm);
415  else
416  rc = wm->codec->poll_touch(wm, &data);
417 
418  if (rc & RC_PENUP) {
419  if (wm->pen_is_down) {
420  wm->pen_is_down = 0;
421  dev_dbg(wm->dev, "pen up\n");
422  input_report_abs(wm->input_dev, ABS_PRESSURE, 0);
423  input_report_key(wm->input_dev, BTN_TOUCH, 0);
424  input_sync(wm->input_dev);
425  } else if (!(rc & RC_AGAIN)) {
426  /* We need high frequency updates only while
427  * pen is down, the user never will be able to
428  * touch screen faster than a few times per
429  * second... On the other hand, when the user
430  * is actively working with the touchscreen we
431  * don't want to lose the quick response. So we
432  * will slowly increase sleep time after the
433  * pen is up and quicky restore it to ~one task
434  * switch when pen is down again.
435  */
436  if (wm->ts_reader_interval < HZ / 10)
437  wm->ts_reader_interval++;
438  }
439 
440  } else if (rc & RC_VALID) {
441  dev_dbg(wm->dev,
442  "pen down: x=%x:%d, y=%x:%d, pressure=%x:%d\n",
443  data.x >> 12, data.x & 0xfff, data.y >> 12,
444  data.y & 0xfff, data.p >> 12, data.p & 0xfff);
445  input_report_abs(wm->input_dev, ABS_X, data.x & 0xfff);
446  input_report_abs(wm->input_dev, ABS_Y, data.y & 0xfff);
447  input_report_abs(wm->input_dev, ABS_PRESSURE, data.p & 0xfff);
448  input_report_key(wm->input_dev, BTN_TOUCH, 1);
449  input_sync(wm->input_dev);
450  wm->pen_is_down = 1;
452  } else if (rc & RC_PENDOWN) {
453  dev_dbg(wm->dev, "pen down\n");
454  wm->pen_is_down = 1;
456  }
457 
459  return rc;
460 }
461 
462 /*
463 * The touchscreen sample reader.
464 */
465 static void wm97xx_ts_reader(struct work_struct *work)
466 {
467  int rc;
468  struct wm97xx *wm = container_of(work, struct wm97xx, ts_reader.work);
469 
470  BUG_ON(!wm->codec);
471 
472  do {
473  rc = wm97xx_read_samples(wm);
474  } while (rc & RC_AGAIN);
475 
476  if (wm->pen_is_down || !wm->pen_irq)
478  wm->ts_reader_interval);
479 }
480 
488 static int wm97xx_ts_input_open(struct input_dev *idev)
489 {
490  struct wm97xx *wm = input_get_drvdata(idev);
491 
492  wm->ts_workq = create_singlethread_workqueue("kwm97xx");
493  if (wm->ts_workq == NULL) {
494  dev_err(wm->dev,
495  "Failed to create workqueue\n");
496  return -EINVAL;
497  }
498 
499  /* start digitiser */
500  if (wm->mach_ops && wm->mach_ops->acc_enabled)
501  wm->codec->acc_enable(wm, 1);
502  wm->codec->dig_enable(wm, 1);
503 
504  INIT_DELAYED_WORK(&wm->ts_reader, wm97xx_ts_reader);
505  INIT_WORK(&wm->pen_event_work, wm97xx_pen_irq_worker);
506 
507  wm->ts_reader_min_interval = HZ >= 100 ? HZ / 100 : 1;
508  if (wm->ts_reader_min_interval < 1)
509  wm->ts_reader_min_interval = 1;
511 
512  wm->pen_is_down = 0;
513  if (wm->pen_irq)
514  wm97xx_init_pen_irq(wm);
515  else
516  dev_err(wm->dev, "No IRQ specified\n");
517 
518  /* If we either don't have an interrupt for pen down events or
519  * failed to acquire it then we need to poll.
520  */
521  if (wm->pen_irq == 0)
523  wm->ts_reader_interval);
524 
525  return 0;
526 }
527 
537 static void wm97xx_ts_input_close(struct input_dev *idev)
538 {
539  struct wm97xx *wm = input_get_drvdata(idev);
540  u16 reg;
541 
542  if (wm->pen_irq) {
543  /* Return the interrupt to GPIO usage (disabling it) */
544  if (wm->id != WM9705_ID2) {
545  BUG_ON(!wm->mach_ops->irq_gpio);
546  reg = wm97xx_reg_read(wm, AC97_MISC_AFE);
548  reg | wm->mach_ops->irq_gpio);
549  }
550 
551  free_irq(wm->pen_irq, wm);
552  }
553 
554  wm->pen_is_down = 0;
555 
556  /* Balance out interrupt disables/enables */
558  wm->mach_ops->irq_enable(wm, 1);
559 
560  /* ts_reader rearms itself so we need to explicitly stop it
561  * before we destroy the workqueue.
562  */
564 
566 
567  /* stop digitiser */
568  wm->codec->dig_enable(wm, 0);
569  if (wm->mach_ops && wm->mach_ops->acc_enabled)
570  wm->codec->acc_enable(wm, 0);
571 }
572 
573 static int wm97xx_probe(struct device *dev)
574 {
575  struct wm97xx *wm;
576  struct wm97xx_pdata *pdata = dev->platform_data;
577  int ret = 0, id = 0;
578 
579  wm = kzalloc(sizeof(struct wm97xx), GFP_KERNEL);
580  if (!wm)
581  return -ENOMEM;
582  mutex_init(&wm->codec_mutex);
583 
584  wm->dev = dev;
585  dev_set_drvdata(dev, wm);
586  wm->ac97 = to_ac97_t(dev);
587 
588  /* check that we have a supported codec */
590  if (id != WM97XX_ID1) {
591  dev_err(dev, "Device with vendor %04x is not a wm97xx\n", id);
592  ret = -ENODEV;
593  goto alloc_err;
594  }
595 
597 
598  wm->variant = WM97xx_GENERIC;
599 
600  dev_info(wm->dev, "detected a wm97%02x codec\n", wm->id & 0xff);
601 
602  switch (wm->id & 0xff) {
603 #ifdef CONFIG_TOUCHSCREEN_WM9705
604  case 0x05:
605  wm->codec = &wm9705_codec;
606  break;
607 #endif
608 #ifdef CONFIG_TOUCHSCREEN_WM9712
609  case 0x12:
610  wm->codec = &wm9712_codec;
611  break;
612 #endif
613 #ifdef CONFIG_TOUCHSCREEN_WM9713
614  case 0x13:
615  wm->codec = &wm9713_codec;
616  break;
617 #endif
618  default:
619  dev_err(wm->dev, "Support for wm97%02x not compiled in.\n",
620  wm->id & 0xff);
621  ret = -ENODEV;
622  goto alloc_err;
623  }
624 
625  /* set up physical characteristics */
626  wm->codec->phy_init(wm);
627 
628  /* load gpio cache */
629  wm->gpio[0] = wm97xx_reg_read(wm, AC97_GPIO_CFG);
631  wm->gpio[2] = wm97xx_reg_read(wm, AC97_GPIO_STICKY);
632  wm->gpio[3] = wm97xx_reg_read(wm, AC97_GPIO_WAKEUP);
633  wm->gpio[4] = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
634  wm->gpio[5] = wm97xx_reg_read(wm, AC97_MISC_AFE);
635 
636  wm->input_dev = input_allocate_device();
637  if (wm->input_dev == NULL) {
638  ret = -ENOMEM;
639  goto alloc_err;
640  }
641 
642  /* set up touch configuration */
643  wm->input_dev->name = "wm97xx touchscreen";
644  wm->input_dev->phys = "wm97xx";
645  wm->input_dev->open = wm97xx_ts_input_open;
646  wm->input_dev->close = wm97xx_ts_input_close;
647 
648  __set_bit(EV_ABS, wm->input_dev->evbit);
649  __set_bit(EV_KEY, wm->input_dev->evbit);
650  __set_bit(BTN_TOUCH, wm->input_dev->keybit);
651 
652  input_set_abs_params(wm->input_dev, ABS_X, abs_x[0], abs_x[1],
653  abs_x[2], 0);
654  input_set_abs_params(wm->input_dev, ABS_Y, abs_y[0], abs_y[1],
655  abs_y[2], 0);
656  input_set_abs_params(wm->input_dev, ABS_PRESSURE, abs_p[0], abs_p[1],
657  abs_p[2], 0);
658 
659  input_set_drvdata(wm->input_dev, wm);
660  wm->input_dev->dev.parent = dev;
661 
662  ret = input_register_device(wm->input_dev);
663  if (ret < 0)
664  goto dev_alloc_err;
665 
666  /* register our battery device */
667  wm->battery_dev = platform_device_alloc("wm97xx-battery", -1);
668  if (!wm->battery_dev) {
669  ret = -ENOMEM;
670  goto batt_err;
671  }
672  platform_set_drvdata(wm->battery_dev, wm);
673  wm->battery_dev->dev.parent = dev;
674  wm->battery_dev->dev.platform_data = pdata;
675  ret = platform_device_add(wm->battery_dev);
676  if (ret < 0)
677  goto batt_reg_err;
678 
679  /* register our extended touch device (for machine specific
680  * extensions) */
681  wm->touch_dev = platform_device_alloc("wm97xx-touch", -1);
682  if (!wm->touch_dev) {
683  ret = -ENOMEM;
684  goto touch_err;
685  }
686  platform_set_drvdata(wm->touch_dev, wm);
687  wm->touch_dev->dev.parent = dev;
688  wm->touch_dev->dev.platform_data = pdata;
689  ret = platform_device_add(wm->touch_dev);
690  if (ret < 0)
691  goto touch_reg_err;
692 
693  return ret;
694 
695  touch_reg_err:
697  touch_err:
699  batt_reg_err:
701  batt_err:
702  input_unregister_device(wm->input_dev);
703  wm->input_dev = NULL;
704  dev_alloc_err:
705  input_free_device(wm->input_dev);
706  alloc_err:
707  kfree(wm);
708 
709  return ret;
710 }
711 
712 static int wm97xx_remove(struct device *dev)
713 {
714  struct wm97xx *wm = dev_get_drvdata(dev);
715 
718  input_unregister_device(wm->input_dev);
719  kfree(wm);
720 
721  return 0;
722 }
723 
724 #ifdef CONFIG_PM
725 static int wm97xx_suspend(struct device *dev, pm_message_t state)
726 {
727  struct wm97xx *wm = dev_get_drvdata(dev);
728  u16 reg;
729  int suspend_mode;
730 
731  if (device_may_wakeup(&wm->input_dev->dev))
732  suspend_mode = wm->suspend_mode;
733  else
734  suspend_mode = 0;
735 
736  if (wm->input_dev->users)
738 
739  /* Power down the digitiser (bypassing the cache for resume) */
741  reg &= ~WM97XX_PRP_DET_DIG;
742  if (wm->input_dev->users)
743  reg |= suspend_mode;
744  wm->ac97->bus->ops->write(wm->ac97, AC97_WM97XX_DIGITISER2, reg);
745 
746  /* WM9713 has an additional power bit - turn it off if there
747  * are no users or if suspend mode is zero. */
748  if (wm->id == WM9713_ID2 &&
749  (!wm->input_dev->users || !suspend_mode)) {
750  reg = wm97xx_reg_read(wm, AC97_EXTENDED_MID) | 0x8000;
752  }
753 
754  return 0;
755 }
756 
757 static int wm97xx_resume(struct device *dev)
758 {
759  struct wm97xx *wm = dev_get_drvdata(dev);
760 
761  /* restore digitiser and gpios */
762  if (wm->id == WM9713_ID2) {
764  wm97xx_reg_write(wm, 0x5a, wm->misc);
765  if (wm->input_dev->users) {
766  u16 reg;
767  reg = wm97xx_reg_read(wm, AC97_EXTENDED_MID) & 0x7fff;
769  }
770  }
771 
774 
775  wm97xx_reg_write(wm, AC97_GPIO_CFG, wm->gpio[0]);
780  wm97xx_reg_write(wm, AC97_MISC_AFE, wm->gpio[5]);
781 
782  if (wm->input_dev->users && !wm->pen_irq) {
785  wm->ts_reader_interval);
786  }
787 
788  return 0;
789 }
790 
791 #else
792 #define wm97xx_suspend NULL
793 #define wm97xx_resume NULL
794 #endif
795 
796 /*
797  * Machine specific operations
798  */
800  struct wm97xx_mach_ops *mach_ops)
801 {
802  mutex_lock(&wm->codec_mutex);
803  if (wm->mach_ops) {
805  return -EINVAL;
806  }
807  wm->mach_ops = mach_ops;
809 
810  return 0;
811 }
813 
815 {
816  mutex_lock(&wm->codec_mutex);
817  wm->mach_ops = NULL;
819 }
821 
822 static struct device_driver wm97xx_driver = {
823  .name = "wm97xx-ts",
824  .bus = &ac97_bus_type,
825  .owner = THIS_MODULE,
826  .probe = wm97xx_probe,
827  .remove = wm97xx_remove,
828  .suspend = wm97xx_suspend,
829  .resume = wm97xx_resume,
830 };
831 
832 static int __init wm97xx_init(void)
833 {
834  return driver_register(&wm97xx_driver);
835 }
836 
837 static void __exit wm97xx_exit(void)
838 {
839  driver_unregister(&wm97xx_driver);
840 }
841 
842 module_init(wm97xx_init);
843 module_exit(wm97xx_exit);
844 
845 /* Module information */
846 MODULE_AUTHOR("Liam Girdwood <[email protected]>");
847 MODULE_DESCRIPTION("WM97xx Core - Touch Screen / AUX ADC / GPIO Driver");
848 MODULE_LICENSE("GPL");