2 * wm97xx-core.c -- Touch screen driver core for Wolfson WM9705, WM9712
3 * and WM9713 AC97 Codecs.
5 * Copyright 2003, 2004, 2005, 2006, 2007, 2008 Wolfson Microelectronics PLC.
6 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
7 * Parts Copyright : Ian Molton <spyro@f2s.com>
8 * Andrew Zabolotny <zap@homelink.ru>
9 * Russell King <rmk@arm.linux.org.uk>
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.
19 * - supports WM9705, WM9712, WM9713
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
31 * - codec event notification
33 * - Support for async sampling control for noisy LCDs.
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>
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>
52 #define TS_NAME "wm97xx"
53 #define WM_CORE_VERSION "1.00"
54 #define DEFAULT_PRESSURE 0xb0c0
58 * Touchscreen absolute values
60 * These parameters are used to help the input layer discard out of
61 * range readings and reduce jitter etc.
63 * o min, max:- indicate the min and max values your touch screen returns
64 * o fuzz:- use a higher number to reduce jitter
66 * The default values correspond to Mainstone II in QVGA mode
69 * Documentation/input/input-programming.txt for more details.
72 static int abs_x
[3] = {350, 3900, 5};
73 module_param_array(abs_x
, int, NULL
, 0);
74 MODULE_PARM_DESC(abs_x
, "Touchscreen absolute X min, max, fuzz");
76 static int abs_y
[3] = {320, 3750, 40};
77 module_param_array(abs_y
, int, NULL
, 0);
78 MODULE_PARM_DESC(abs_y
, "Touchscreen absolute Y min, max, fuzz");
80 static int abs_p
[3] = {0, 150, 4};
81 module_param_array(abs_p
, int, NULL
, 0);
82 MODULE_PARM_DESC(abs_p
, "Touchscreen absolute Pressure min, max, fuzz");
85 * wm97xx IO access, all IO locking done by AC97 layer
87 int wm97xx_reg_read(struct wm97xx
*wm
, u16 reg
)
90 return wm
->ac97
->bus
->ops
->read(wm
->ac97
, reg
);
94 EXPORT_SYMBOL_GPL(wm97xx_reg_read
);
96 void wm97xx_reg_write(struct wm97xx
*wm
, u16 reg
, u16 val
)
98 /* cache digitiser registers */
99 if (reg
>= AC97_WM9713_DIG1
&& reg
<= AC97_WM9713_DIG3
)
100 wm
->dig
[(reg
- AC97_WM9713_DIG1
) >> 1] = val
;
102 /* cache gpio regs */
103 if (reg
>= AC97_GPIO_CFG
&& reg
<= AC97_MISC_AFE
)
104 wm
->gpio
[(reg
- AC97_GPIO_CFG
) >> 1] = val
;
111 wm
->ac97
->bus
->ops
->write(wm
->ac97
, reg
, val
);
113 EXPORT_SYMBOL_GPL(wm97xx_reg_write
);
116 * wm97xx_read_aux_adc - Read the aux adc.
117 * @wm: wm97xx device.
118 * @adcsel: codec ADC to be read
120 * Reads the selected AUX ADC.
123 int wm97xx_read_aux_adc(struct wm97xx
*wm
, u16 adcsel
)
125 int power_adc
= 0, auxval
;
129 mutex_lock(&wm
->codec_mutex
);
131 /* When the touchscreen is not in use, we may have to power up
132 * the AUX ADC before we can use sample the AUX inputs->
134 if (wm
->id
== WM9713_ID2
&&
135 (power
= wm97xx_reg_read(wm
, AC97_EXTENDED_MID
)) & 0x8000) {
137 wm97xx_reg_write(wm
, AC97_EXTENDED_MID
, power
& 0x7fff);
140 /* Prepare the codec for AUX reading */
141 wm
->codec
->aux_prepare(wm
);
143 /* Turn polling mode on to read AUX ADC */
144 wm
->pen_probably_down
= 1;
145 wm
->codec
->poll_sample(wm
, adcsel
, &auxval
);
148 wm97xx_reg_write(wm
, AC97_EXTENDED_MID
, power
| 0x8000);
150 wm
->codec
->dig_restore(wm
);
152 wm
->pen_probably_down
= 0;
154 mutex_unlock(&wm
->codec_mutex
);
155 return auxval
& 0xfff;
157 EXPORT_SYMBOL_GPL(wm97xx_read_aux_adc
);
160 * wm97xx_get_gpio - Get the status of a codec GPIO.
161 * @wm: wm97xx device.
164 * Get the status of a codec GPIO pin
167 enum wm97xx_gpio_status
wm97xx_get_gpio(struct wm97xx
*wm
, u32 gpio
)
170 enum wm97xx_gpio_status ret
;
172 mutex_lock(&wm
->codec_mutex
);
173 status
= wm97xx_reg_read(wm
, AC97_GPIO_STATUS
);
176 ret
= WM97XX_GPIO_HIGH
;
178 ret
= WM97XX_GPIO_LOW
;
180 mutex_unlock(&wm
->codec_mutex
);
183 EXPORT_SYMBOL_GPL(wm97xx_get_gpio
);
186 * wm97xx_set_gpio - Set the status of a codec GPIO.
187 * @wm: wm97xx device.
191 * Set the status of a codec GPIO pin
194 void wm97xx_set_gpio(struct wm97xx
*wm
, u32 gpio
,
195 enum wm97xx_gpio_status status
)
199 mutex_lock(&wm
->codec_mutex
);
200 reg
= wm97xx_reg_read(wm
, AC97_GPIO_STATUS
);
202 if (status
& WM97XX_GPIO_HIGH
)
207 if (wm
->id
== WM9712_ID2
)
208 wm97xx_reg_write(wm
, AC97_GPIO_STATUS
, reg
<< 1);
210 wm97xx_reg_write(wm
, AC97_GPIO_STATUS
, reg
);
211 mutex_unlock(&wm
->codec_mutex
);
213 EXPORT_SYMBOL_GPL(wm97xx_set_gpio
);
216 * Codec GPIO pin configuration, this sets pin direction, polarity,
217 * stickyness and wake up.
219 void wm97xx_config_gpio(struct wm97xx
*wm
, u32 gpio
, enum wm97xx_gpio_dir dir
,
220 enum wm97xx_gpio_pol pol
, enum wm97xx_gpio_sticky sticky
,
221 enum wm97xx_gpio_wake wake
)
225 mutex_lock(&wm
->codec_mutex
);
226 reg
= wm97xx_reg_read(wm
, AC97_GPIO_POLARITY
);
228 if (pol
== WM97XX_GPIO_POL_HIGH
)
233 wm97xx_reg_write(wm
, AC97_GPIO_POLARITY
, reg
);
234 reg
= wm97xx_reg_read(wm
, AC97_GPIO_STICKY
);
236 if (sticky
== WM97XX_GPIO_STICKY
)
241 wm97xx_reg_write(wm
, AC97_GPIO_STICKY
, reg
);
242 reg
= wm97xx_reg_read(wm
, AC97_GPIO_WAKEUP
);
244 if (wake
== WM97XX_GPIO_WAKE
)
249 wm97xx_reg_write(wm
, AC97_GPIO_WAKEUP
, reg
);
250 reg
= wm97xx_reg_read(wm
, AC97_GPIO_CFG
);
252 if (dir
== WM97XX_GPIO_IN
)
257 wm97xx_reg_write(wm
, AC97_GPIO_CFG
, reg
);
258 mutex_unlock(&wm
->codec_mutex
);
260 EXPORT_SYMBOL_GPL(wm97xx_config_gpio
);
263 * Configure the WM97XX_PRP value to use while system is suspended.
264 * If a value other than 0 is set then WM97xx pen detection will be
265 * left enabled in the configured mode while the system is in suspend,
266 * the device has users and suspend has not been disabled via the
267 * wakeup sysfs entries.
269 * @wm: WM97xx device to configure
270 * @mode: WM97XX_PRP value to configure while suspended
272 void wm97xx_set_suspend_mode(struct wm97xx
*wm
, u16 mode
)
274 wm
->suspend_mode
= mode
;
275 device_init_wakeup(&wm
->input_dev
->dev
, mode
!= 0);
277 EXPORT_SYMBOL_GPL(wm97xx_set_suspend_mode
);
280 * Handle a pen down interrupt.
282 static void wm97xx_pen_irq_worker(struct work_struct
*work
)
284 struct wm97xx
*wm
= container_of(work
, struct wm97xx
, pen_event_work
);
285 int pen_was_down
= wm
->pen_is_down
;
287 /* do we need to enable the touch panel reader */
288 if (wm
->id
== WM9705_ID2
) {
289 if (wm97xx_reg_read(wm
, AC97_WM97XX_DIGITISER_RD
) &
296 mutex_lock(&wm
->codec_mutex
);
297 status
= wm97xx_reg_read(wm
, AC97_GPIO_STATUS
);
298 pol
= wm97xx_reg_read(wm
, AC97_GPIO_POLARITY
);
300 if (WM97XX_GPIO_13
& pol
& status
) {
302 wm97xx_reg_write(wm
, AC97_GPIO_POLARITY
, pol
&
306 wm97xx_reg_write(wm
, AC97_GPIO_POLARITY
, pol
|
310 if (wm
->id
== WM9712_ID2
)
311 wm97xx_reg_write(wm
, AC97_GPIO_STATUS
, (status
&
312 ~WM97XX_GPIO_13
) << 1);
314 wm97xx_reg_write(wm
, AC97_GPIO_STATUS
, status
&
316 mutex_unlock(&wm
->codec_mutex
);
319 /* If the system is not using continuous mode or it provides a
320 * pen down operation then we need to schedule polls while the
321 * pen is down. Otherwise the machine driver is responsible
322 * for scheduling reads.
324 if (!wm
->mach_ops
->acc_enabled
|| wm
->mach_ops
->acc_pen_down
) {
325 if (wm
->pen_is_down
&& !pen_was_down
) {
326 /* Data is not availiable immediately on pen down */
327 queue_delayed_work(wm
->ts_workq
, &wm
->ts_reader
, 1);
330 /* Let ts_reader report the pen up for debounce. */
331 if (!wm
->pen_is_down
&& pen_was_down
)
335 if (!wm
->pen_is_down
&& wm
->mach_ops
->acc_enabled
)
336 wm
->mach_ops
->acc_pen_up(wm
);
338 wm
->mach_ops
->irq_enable(wm
, 1);
342 * Codec PENDOWN irq handler
344 * We have to disable the codec interrupt in the handler because it
345 * can take upto 1ms to clear the interrupt source. We schedule a task
346 * in a work queue to do the actual interaction with the chip. The
347 * interrupt is then enabled again in the slow handler when the source
350 static irqreturn_t
wm97xx_pen_interrupt(int irq
, void *dev_id
)
352 struct wm97xx
*wm
= dev_id
;
354 if (!work_pending(&wm
->pen_event_work
)) {
355 wm
->mach_ops
->irq_enable(wm
, 0);
356 queue_work(wm
->ts_workq
, &wm
->pen_event_work
);
363 * initialise pen IRQ handler and workqueue
365 static int wm97xx_init_pen_irq(struct wm97xx
*wm
)
369 /* If an interrupt is supplied an IRQ enable operation must also be
371 BUG_ON(!wm
->mach_ops
->irq_enable
);
373 if (request_irq(wm
->pen_irq
, wm97xx_pen_interrupt
,
374 IRQF_SHARED
| IRQF_SAMPLE_RANDOM
,
377 "Failed to register pen down interrupt, polling");
382 /* Configure GPIO as interrupt source on WM971x */
383 if (wm
->id
!= WM9705_ID2
) {
384 BUG_ON(!wm
->mach_ops
->irq_gpio
);
385 reg
= wm97xx_reg_read(wm
, AC97_MISC_AFE
);
386 wm97xx_reg_write(wm
, AC97_MISC_AFE
,
387 reg
& ~(wm
->mach_ops
->irq_gpio
));
388 reg
= wm97xx_reg_read(wm
, 0x5a);
389 wm97xx_reg_write(wm
, 0x5a, reg
& ~0x0001);
395 static int wm97xx_read_samples(struct wm97xx
*wm
)
397 struct wm97xx_data data
;
400 mutex_lock(&wm
->codec_mutex
);
402 if (wm
->mach_ops
&& wm
->mach_ops
->acc_enabled
)
403 rc
= wm
->mach_ops
->acc_pen_down(wm
);
405 rc
= wm
->codec
->poll_touch(wm
, &data
);
408 if (wm
->pen_is_down
) {
410 dev_dbg(wm
->dev
, "pen up\n");
411 input_report_abs(wm
->input_dev
, ABS_PRESSURE
, 0);
412 input_report_key(wm
->input_dev
, BTN_TOUCH
, 0);
413 input_sync(wm
->input_dev
);
414 } else if (!(rc
& RC_AGAIN
)) {
415 /* We need high frequency updates only while
416 * pen is down, the user never will be able to
417 * touch screen faster than a few times per
418 * second... On the other hand, when the user
419 * is actively working with the touchscreen we
420 * don't want to lose the quick response. So we
421 * will slowly increase sleep time after the
422 * pen is up and quicky restore it to ~one task
423 * switch when pen is down again.
425 if (wm
->ts_reader_interval
< HZ
/ 10)
426 wm
->ts_reader_interval
++;
429 } else if (rc
& RC_VALID
) {
431 "pen down: x=%x:%d, y=%x:%d, pressure=%x:%d\n",
432 data
.x
>> 12, data
.x
& 0xfff, data
.y
>> 12,
433 data
.y
& 0xfff, data
.p
>> 12, data
.p
& 0xfff);
434 input_report_abs(wm
->input_dev
, ABS_X
, data
.x
& 0xfff);
435 input_report_abs(wm
->input_dev
, ABS_Y
, data
.y
& 0xfff);
436 input_report_abs(wm
->input_dev
, ABS_PRESSURE
, data
.p
& 0xfff);
437 input_report_key(wm
->input_dev
, BTN_TOUCH
, 1);
438 input_sync(wm
->input_dev
);
440 wm
->ts_reader_interval
= wm
->ts_reader_min_interval
;
441 } else if (rc
& RC_PENDOWN
) {
442 dev_dbg(wm
->dev
, "pen down\n");
444 wm
->ts_reader_interval
= wm
->ts_reader_min_interval
;
447 mutex_unlock(&wm
->codec_mutex
);
452 * The touchscreen sample reader.
454 static void wm97xx_ts_reader(struct work_struct
*work
)
457 struct wm97xx
*wm
= container_of(work
, struct wm97xx
, ts_reader
.work
);
462 rc
= wm97xx_read_samples(wm
);
463 } while (rc
& RC_AGAIN
);
465 if (wm
->pen_is_down
|| !wm
->pen_irq
)
466 queue_delayed_work(wm
->ts_workq
, &wm
->ts_reader
,
467 wm
->ts_reader_interval
);
471 * wm97xx_ts_input_open - Open the touch screen input device.
472 * @idev: Input device to be opened.
474 * Called by the input sub system to open a wm97xx touchscreen device.
475 * Starts the touchscreen thread and touch digitiser.
477 static int wm97xx_ts_input_open(struct input_dev
*idev
)
479 struct wm97xx
*wm
= input_get_drvdata(idev
);
481 wm
->ts_workq
= create_singlethread_workqueue("kwm97xx");
482 if (wm
->ts_workq
== NULL
) {
484 "Failed to create workqueue\n");
488 /* start digitiser */
489 if (wm
->mach_ops
&& wm
->mach_ops
->acc_enabled
)
490 wm
->codec
->acc_enable(wm
, 1);
491 wm
->codec
->dig_enable(wm
, 1);
493 INIT_DELAYED_WORK(&wm
->ts_reader
, wm97xx_ts_reader
);
494 INIT_WORK(&wm
->pen_event_work
, wm97xx_pen_irq_worker
);
496 wm
->ts_reader_min_interval
= HZ
>= 100 ? HZ
/ 100 : 1;
497 if (wm
->ts_reader_min_interval
< 1)
498 wm
->ts_reader_min_interval
= 1;
499 wm
->ts_reader_interval
= wm
->ts_reader_min_interval
;
503 wm97xx_init_pen_irq(wm
);
505 dev_err(wm
->dev
, "No IRQ specified\n");
507 /* If we either don't have an interrupt for pen down events or
508 * failed to acquire it then we need to poll.
510 if (wm
->pen_irq
== 0)
511 queue_delayed_work(wm
->ts_workq
, &wm
->ts_reader
,
512 wm
->ts_reader_interval
);
518 * wm97xx_ts_input_close - Close the touch screen input device.
519 * @idev: Input device to be closed.
521 * Called by the input sub system to close a wm97xx touchscreen
522 * device. Kills the touchscreen thread and stops the touch
526 static void wm97xx_ts_input_close(struct input_dev
*idev
)
528 struct wm97xx
*wm
= input_get_drvdata(idev
);
532 /* Return the interrupt to GPIO usage (disabling it) */
533 if (wm
->id
!= WM9705_ID2
) {
534 BUG_ON(!wm
->mach_ops
->irq_gpio
);
535 reg
= wm97xx_reg_read(wm
, AC97_MISC_AFE
);
536 wm97xx_reg_write(wm
, AC97_MISC_AFE
,
537 reg
| wm
->mach_ops
->irq_gpio
);
540 free_irq(wm
->pen_irq
, wm
);
545 /* Balance out interrupt disables/enables */
546 if (cancel_work_sync(&wm
->pen_event_work
))
547 wm
->mach_ops
->irq_enable(wm
, 1);
549 /* ts_reader rearms itself so we need to explicitly stop it
550 * before we destroy the workqueue.
552 cancel_delayed_work_sync(&wm
->ts_reader
);
554 destroy_workqueue(wm
->ts_workq
);
557 wm
->codec
->dig_enable(wm
, 0);
558 if (wm
->mach_ops
&& wm
->mach_ops
->acc_enabled
)
559 wm
->codec
->acc_enable(wm
, 0);
562 static int wm97xx_probe(struct device
*dev
)
567 wm
= kzalloc(sizeof(struct wm97xx
), GFP_KERNEL
);
570 mutex_init(&wm
->codec_mutex
);
573 dev
->driver_data
= wm
;
574 wm
->ac97
= to_ac97_t(dev
);
576 /* check that we have a supported codec */
577 id
= wm97xx_reg_read(wm
, AC97_VENDOR_ID1
);
578 if (id
!= WM97XX_ID1
) {
579 dev_err(dev
, "Device with vendor %04x is not a wm97xx\n", id
);
584 wm
->id
= wm97xx_reg_read(wm
, AC97_VENDOR_ID2
);
586 dev_info(wm
->dev
, "detected a wm97%02x codec\n", wm
->id
& 0xff);
588 switch (wm
->id
& 0xff) {
589 #ifdef CONFIG_TOUCHSCREEN_WM9705
591 wm
->codec
= &wm9705_codec
;
594 #ifdef CONFIG_TOUCHSCREEN_WM9712
596 wm
->codec
= &wm9712_codec
;
599 #ifdef CONFIG_TOUCHSCREEN_WM9713
601 wm
->codec
= &wm9713_codec
;
605 dev_err(wm
->dev
, "Support for wm97%02x not compiled in.\n",
611 /* set up physical characteristics */
612 wm
->codec
->phy_init(wm
);
614 /* load gpio cache */
615 wm
->gpio
[0] = wm97xx_reg_read(wm
, AC97_GPIO_CFG
);
616 wm
->gpio
[1] = wm97xx_reg_read(wm
, AC97_GPIO_POLARITY
);
617 wm
->gpio
[2] = wm97xx_reg_read(wm
, AC97_GPIO_STICKY
);
618 wm
->gpio
[3] = wm97xx_reg_read(wm
, AC97_GPIO_WAKEUP
);
619 wm
->gpio
[4] = wm97xx_reg_read(wm
, AC97_GPIO_STATUS
);
620 wm
->gpio
[5] = wm97xx_reg_read(wm
, AC97_MISC_AFE
);
622 wm
->input_dev
= input_allocate_device();
623 if (wm
->input_dev
== NULL
) {
628 /* set up touch configuration */
629 wm
->input_dev
->name
= "wm97xx touchscreen";
630 wm
->input_dev
->phys
= "wm97xx";
631 wm
->input_dev
->open
= wm97xx_ts_input_open
;
632 wm
->input_dev
->close
= wm97xx_ts_input_close
;
634 __set_bit(EV_ABS
, wm
->input_dev
->evbit
);
635 __set_bit(EV_KEY
, wm
->input_dev
->evbit
);
636 __set_bit(BTN_TOUCH
, wm
->input_dev
->keybit
);
638 input_set_abs_params(wm
->input_dev
, ABS_X
, abs_x
[0], abs_x
[1],
640 input_set_abs_params(wm
->input_dev
, ABS_Y
, abs_y
[0], abs_y
[1],
642 input_set_abs_params(wm
->input_dev
, ABS_PRESSURE
, abs_p
[0], abs_p
[1],
645 input_set_drvdata(wm
->input_dev
, wm
);
646 wm
->input_dev
->dev
.parent
= dev
;
648 ret
= input_register_device(wm
->input_dev
);
652 /* register our battery device */
653 wm
->battery_dev
= platform_device_alloc("wm97xx-battery", -1);
654 if (!wm
->battery_dev
) {
658 platform_set_drvdata(wm
->battery_dev
, wm
);
659 wm
->battery_dev
->dev
.parent
= dev
;
660 ret
= platform_device_add(wm
->battery_dev
);
664 /* register our extended touch device (for machine specific
666 wm
->touch_dev
= platform_device_alloc("wm97xx-touch", -1);
667 if (!wm
->touch_dev
) {
671 platform_set_drvdata(wm
->touch_dev
, wm
);
672 wm
->touch_dev
->dev
.parent
= dev
;
673 ret
= platform_device_add(wm
->touch_dev
);
680 platform_device_put(wm
->touch_dev
);
682 platform_device_unregister(wm
->battery_dev
);
683 wm
->battery_dev
= NULL
;
685 platform_device_put(wm
->battery_dev
);
687 input_unregister_device(wm
->input_dev
);
688 wm
->input_dev
= NULL
;
690 input_free_device(wm
->input_dev
);
697 static int wm97xx_remove(struct device
*dev
)
699 struct wm97xx
*wm
= dev_get_drvdata(dev
);
701 platform_device_unregister(wm
->battery_dev
);
702 platform_device_unregister(wm
->touch_dev
);
703 input_unregister_device(wm
->input_dev
);
710 static int wm97xx_suspend(struct device
*dev
, pm_message_t state
)
712 struct wm97xx
*wm
= dev_get_drvdata(dev
);
716 if (device_may_wakeup(&wm
->input_dev
->dev
))
717 suspend_mode
= wm
->suspend_mode
;
721 if (wm
->input_dev
->users
)
722 cancel_delayed_work_sync(&wm
->ts_reader
);
724 /* Power down the digitiser (bypassing the cache for resume) */
725 reg
= wm97xx_reg_read(wm
, AC97_WM97XX_DIGITISER2
);
726 reg
&= ~WM97XX_PRP_DET_DIG
;
727 if (wm
->input_dev
->users
)
729 wm
->ac97
->bus
->ops
->write(wm
->ac97
, AC97_WM97XX_DIGITISER2
, reg
);
731 /* WM9713 has an additional power bit - turn it off if there
732 * are no users or if suspend mode is zero. */
733 if (wm
->id
== WM9713_ID2
&&
734 (!wm
->input_dev
->users
|| !suspend_mode
)) {
735 reg
= wm97xx_reg_read(wm
, AC97_EXTENDED_MID
) | 0x8000;
736 wm97xx_reg_write(wm
, AC97_EXTENDED_MID
, reg
);
742 static int wm97xx_resume(struct device
*dev
)
744 struct wm97xx
*wm
= dev_get_drvdata(dev
);
746 /* restore digitiser and gpios */
747 if (wm
->id
== WM9713_ID2
) {
748 wm97xx_reg_write(wm
, AC97_WM9713_DIG1
, wm
->dig
[0]);
749 wm97xx_reg_write(wm
, 0x5a, wm
->misc
);
750 if (wm
->input_dev
->users
) {
752 reg
= wm97xx_reg_read(wm
, AC97_EXTENDED_MID
) & 0x7fff;
753 wm97xx_reg_write(wm
, AC97_EXTENDED_MID
, reg
);
757 wm97xx_reg_write(wm
, AC97_WM9713_DIG2
, wm
->dig
[1]);
758 wm97xx_reg_write(wm
, AC97_WM9713_DIG3
, wm
->dig
[2]);
760 wm97xx_reg_write(wm
, AC97_GPIO_CFG
, wm
->gpio
[0]);
761 wm97xx_reg_write(wm
, AC97_GPIO_POLARITY
, wm
->gpio
[1]);
762 wm97xx_reg_write(wm
, AC97_GPIO_STICKY
, wm
->gpio
[2]);
763 wm97xx_reg_write(wm
, AC97_GPIO_WAKEUP
, wm
->gpio
[3]);
764 wm97xx_reg_write(wm
, AC97_GPIO_STATUS
, wm
->gpio
[4]);
765 wm97xx_reg_write(wm
, AC97_MISC_AFE
, wm
->gpio
[5]);
767 if (wm
->input_dev
->users
&& !wm
->pen_irq
) {
768 wm
->ts_reader_interval
= wm
->ts_reader_min_interval
;
769 queue_delayed_work(wm
->ts_workq
, &wm
->ts_reader
,
770 wm
->ts_reader_interval
);
777 #define wm97xx_suspend NULL
778 #define wm97xx_resume NULL
782 * Machine specific operations
784 int wm97xx_register_mach_ops(struct wm97xx
*wm
,
785 struct wm97xx_mach_ops
*mach_ops
)
787 mutex_lock(&wm
->codec_mutex
);
789 mutex_unlock(&wm
->codec_mutex
);
792 wm
->mach_ops
= mach_ops
;
793 mutex_unlock(&wm
->codec_mutex
);
797 EXPORT_SYMBOL_GPL(wm97xx_register_mach_ops
);
799 void wm97xx_unregister_mach_ops(struct wm97xx
*wm
)
801 mutex_lock(&wm
->codec_mutex
);
803 mutex_unlock(&wm
->codec_mutex
);
805 EXPORT_SYMBOL_GPL(wm97xx_unregister_mach_ops
);
807 static struct device_driver wm97xx_driver
= {
809 .bus
= &ac97_bus_type
,
810 .owner
= THIS_MODULE
,
811 .probe
= wm97xx_probe
,
812 .remove
= wm97xx_remove
,
813 .suspend
= wm97xx_suspend
,
814 .resume
= wm97xx_resume
,
817 static int __init
wm97xx_init(void)
819 return driver_register(&wm97xx_driver
);
822 static void __exit
wm97xx_exit(void)
824 driver_unregister(&wm97xx_driver
);
827 module_init(wm97xx_init
);
828 module_exit(wm97xx_exit
);
830 /* Module information */
831 MODULE_AUTHOR("Liam Girdwood <lrg@slimlogic.co.uk>");
832 MODULE_DESCRIPTION("WM97xx Core - Touch Screen / AUX ADC / GPIO Driver");
833 MODULE_LICENSE("GPL");