12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
2febf1dffSMark Brown /*
3febf1dffSMark Brown * wm97xx-core.c -- Touch screen driver core for Wolfson WM9705, WM9712
4febf1dffSMark Brown * and WM9713 AC97 Codecs.
5febf1dffSMark Brown *
6febf1dffSMark Brown * Copyright 2003, 2004, 2005, 2006, 2007, 2008 Wolfson Microelectronics PLC.
7b8d055a8SLiam Girdwood * Author: Liam Girdwood <lrg@slimlogic.co.uk>
8febf1dffSMark Brown * Parts Copyright : Ian Molton <spyro@f2s.com>
9febf1dffSMark Brown * Andrew Zabolotny <zap@homelink.ru>
10febf1dffSMark Brown * Russell King <rmk@arm.linux.org.uk>
11febf1dffSMark Brown *
12febf1dffSMark Brown * Notes:
13febf1dffSMark Brown *
14febf1dffSMark Brown * Features:
15febf1dffSMark Brown * - supports WM9705, WM9712, WM9713
16febf1dffSMark Brown * - polling mode
17febf1dffSMark Brown * - continuous mode (arch-dependent)
18febf1dffSMark Brown * - adjustable rpu/dpp settings
19febf1dffSMark Brown * - adjustable pressure current
20febf1dffSMark Brown * - adjustable sample settle delay
21febf1dffSMark Brown * - 4 and 5 wire touchscreens (5 wire is WM9712 only)
22febf1dffSMark Brown * - pen down detection
23febf1dffSMark Brown * - battery monitor
24febf1dffSMark Brown * - sample AUX adcs
25febf1dffSMark Brown * - power management
26febf1dffSMark Brown * - codec GPIO
27febf1dffSMark Brown * - codec event notification
28febf1dffSMark Brown * Todo
29febf1dffSMark Brown * - Support for async sampling control for noisy LCDs.
30febf1dffSMark Brown */
31febf1dffSMark Brown
32febf1dffSMark Brown #include <linux/module.h>
33febf1dffSMark Brown #include <linux/moduleparam.h>
34febf1dffSMark Brown #include <linux/kernel.h>
35febf1dffSMark Brown #include <linux/init.h>
36febf1dffSMark Brown #include <linux/delay.h>
37febf1dffSMark Brown #include <linux/string.h>
38febf1dffSMark Brown #include <linux/proc_fs.h>
39febf1dffSMark Brown #include <linux/pm.h>
40febf1dffSMark Brown #include <linux/interrupt.h>
41febf1dffSMark Brown #include <linux/bitops.h>
42ae9d1b5fSRobert Jarzmik #include <linux/mfd/wm97xx.h>
43febf1dffSMark Brown #include <linux/workqueue.h>
44febf1dffSMark Brown #include <linux/wm97xx.h>
45febf1dffSMark Brown #include <linux/uaccess.h>
46febf1dffSMark Brown #include <linux/io.h>
475a0e3ad6STejun Heo #include <linux/slab.h>
48febf1dffSMark Brown
49febf1dffSMark Brown #define TS_NAME "wm97xx"
50febf1dffSMark Brown #define WM_CORE_VERSION "1.00"
51febf1dffSMark Brown #define DEFAULT_PRESSURE 0xb0c0
52febf1dffSMark Brown
53febf1dffSMark Brown
54febf1dffSMark Brown /*
55febf1dffSMark Brown * Touchscreen absolute values
56febf1dffSMark Brown *
57febf1dffSMark Brown * These parameters are used to help the input layer discard out of
58febf1dffSMark Brown * range readings and reduce jitter etc.
59febf1dffSMark Brown *
60febf1dffSMark Brown * o min, max:- indicate the min and max values your touch screen returns
61febf1dffSMark Brown * o fuzz:- use a higher number to reduce jitter
62febf1dffSMark Brown *
63febf1dffSMark Brown * The default values correspond to Mainstone II in QVGA mode
64febf1dffSMark Brown *
65febf1dffSMark Brown * Please read
665fb94e9cSMauro Carvalho Chehab * Documentation/input/input-programming.rst for more details.
67febf1dffSMark Brown */
68febf1dffSMark Brown
69859abd1dSDmitry Eremin-Solenikov static int abs_x[3] = {150, 4000, 5};
70febf1dffSMark Brown module_param_array(abs_x, int, NULL, 0);
71febf1dffSMark Brown MODULE_PARM_DESC(abs_x, "Touchscreen absolute X min, max, fuzz");
72febf1dffSMark Brown
73859abd1dSDmitry Eremin-Solenikov static int abs_y[3] = {200, 4000, 40};
74febf1dffSMark Brown module_param_array(abs_y, int, NULL, 0);
75febf1dffSMark Brown MODULE_PARM_DESC(abs_y, "Touchscreen absolute Y min, max, fuzz");
76febf1dffSMark Brown
77febf1dffSMark Brown static int abs_p[3] = {0, 150, 4};
78febf1dffSMark Brown module_param_array(abs_p, int, NULL, 0);
79febf1dffSMark Brown MODULE_PARM_DESC(abs_p, "Touchscreen absolute Pressure min, max, fuzz");
80febf1dffSMark Brown
81febf1dffSMark Brown /*
82febf1dffSMark Brown * wm97xx IO access, all IO locking done by AC97 layer
83febf1dffSMark Brown */
wm97xx_reg_read(struct wm97xx * wm,u16 reg)84febf1dffSMark Brown int wm97xx_reg_read(struct wm97xx *wm, u16 reg)
85febf1dffSMark Brown {
86febf1dffSMark Brown if (wm->ac97)
87febf1dffSMark Brown return wm->ac97->bus->ops->read(wm->ac97, reg);
88febf1dffSMark Brown else
89febf1dffSMark Brown return -1;
90febf1dffSMark Brown }
91febf1dffSMark Brown EXPORT_SYMBOL_GPL(wm97xx_reg_read);
92febf1dffSMark Brown
wm97xx_reg_write(struct wm97xx * wm,u16 reg,u16 val)93febf1dffSMark Brown void wm97xx_reg_write(struct wm97xx *wm, u16 reg, u16 val)
94febf1dffSMark Brown {
95febf1dffSMark Brown /* cache digitiser registers */
96febf1dffSMark Brown if (reg >= AC97_WM9713_DIG1 && reg <= AC97_WM9713_DIG3)
97febf1dffSMark Brown wm->dig[(reg - AC97_WM9713_DIG1) >> 1] = val;
98febf1dffSMark Brown
99febf1dffSMark Brown /* cache gpio regs */
100febf1dffSMark Brown if (reg >= AC97_GPIO_CFG && reg <= AC97_MISC_AFE)
101febf1dffSMark Brown wm->gpio[(reg - AC97_GPIO_CFG) >> 1] = val;
102febf1dffSMark Brown
103febf1dffSMark Brown /* wm9713 irq reg */
104febf1dffSMark Brown if (reg == 0x5a)
105febf1dffSMark Brown wm->misc = val;
106febf1dffSMark Brown
107febf1dffSMark Brown if (wm->ac97)
108febf1dffSMark Brown wm->ac97->bus->ops->write(wm->ac97, reg, val);
109febf1dffSMark Brown }
110febf1dffSMark Brown EXPORT_SYMBOL_GPL(wm97xx_reg_write);
111febf1dffSMark Brown
112febf1dffSMark Brown /**
113febf1dffSMark Brown * wm97xx_read_aux_adc - Read the aux adc.
114febf1dffSMark Brown * @wm: wm97xx device.
115febf1dffSMark Brown * @adcsel: codec ADC to be read
116febf1dffSMark Brown *
117febf1dffSMark Brown * Reads the selected AUX ADC.
118febf1dffSMark Brown */
119febf1dffSMark Brown
wm97xx_read_aux_adc(struct wm97xx * wm,u16 adcsel)120febf1dffSMark Brown int wm97xx_read_aux_adc(struct wm97xx *wm, u16 adcsel)
121febf1dffSMark Brown {
122febf1dffSMark Brown int power_adc = 0, auxval;
123febf1dffSMark Brown u16 power = 0;
124eb54ddd4SEric Millbrandt int rc = 0;
125eb54ddd4SEric Millbrandt int timeout = 0;
126febf1dffSMark Brown
127febf1dffSMark Brown /* get codec */
128febf1dffSMark Brown mutex_lock(&wm->codec_mutex);
129febf1dffSMark Brown
130febf1dffSMark Brown /* When the touchscreen is not in use, we may have to power up
131febf1dffSMark Brown * the AUX ADC before we can use sample the AUX inputs->
132febf1dffSMark Brown */
133febf1dffSMark Brown if (wm->id == WM9713_ID2 &&
134febf1dffSMark Brown (power = wm97xx_reg_read(wm, AC97_EXTENDED_MID)) & 0x8000) {
135febf1dffSMark Brown power_adc = 1;
136febf1dffSMark Brown wm97xx_reg_write(wm, AC97_EXTENDED_MID, power & 0x7fff);
137febf1dffSMark Brown }
138febf1dffSMark Brown
139febf1dffSMark Brown /* Prepare the codec for AUX reading */
140febf1dffSMark Brown wm->codec->aux_prepare(wm);
141febf1dffSMark Brown
142febf1dffSMark Brown /* Turn polling mode on to read AUX ADC */
143febf1dffSMark Brown wm->pen_probably_down = 1;
144eb54ddd4SEric Millbrandt
145eb54ddd4SEric Millbrandt while (rc != RC_VALID && timeout++ < 5)
146eb54ddd4SEric Millbrandt rc = wm->codec->poll_sample(wm, adcsel, &auxval);
147febf1dffSMark Brown
148febf1dffSMark Brown if (power_adc)
149febf1dffSMark Brown wm97xx_reg_write(wm, AC97_EXTENDED_MID, power | 0x8000);
150febf1dffSMark Brown
151febf1dffSMark Brown wm->codec->dig_restore(wm);
152febf1dffSMark Brown
153febf1dffSMark Brown wm->pen_probably_down = 0;
154febf1dffSMark Brown
155eb54ddd4SEric Millbrandt if (timeout >= 5) {
156eb54ddd4SEric Millbrandt dev_err(wm->dev,
157eb54ddd4SEric Millbrandt "timeout reading auxadc %d, disabling digitiser\n",
158eb54ddd4SEric Millbrandt adcsel);
159eb54ddd4SEric Millbrandt wm->codec->dig_enable(wm, false);
160eb54ddd4SEric Millbrandt }
161eb54ddd4SEric Millbrandt
162febf1dffSMark Brown mutex_unlock(&wm->codec_mutex);
163eb54ddd4SEric Millbrandt return (rc == RC_VALID ? auxval & 0xfff : -EBUSY);
164febf1dffSMark Brown }
165febf1dffSMark Brown EXPORT_SYMBOL_GPL(wm97xx_read_aux_adc);
166febf1dffSMark Brown
167febf1dffSMark Brown /**
168febf1dffSMark Brown * wm97xx_get_gpio - Get the status of a codec GPIO.
169febf1dffSMark Brown * @wm: wm97xx device.
170febf1dffSMark Brown * @gpio: gpio
171febf1dffSMark Brown *
172febf1dffSMark Brown * Get the status of a codec GPIO pin
173febf1dffSMark Brown */
174febf1dffSMark Brown
wm97xx_get_gpio(struct wm97xx * wm,u32 gpio)175febf1dffSMark Brown enum wm97xx_gpio_status wm97xx_get_gpio(struct wm97xx *wm, u32 gpio)
176febf1dffSMark Brown {
177febf1dffSMark Brown u16 status;
178febf1dffSMark Brown enum wm97xx_gpio_status ret;
179febf1dffSMark Brown
180febf1dffSMark Brown mutex_lock(&wm->codec_mutex);
181febf1dffSMark Brown status = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
182febf1dffSMark Brown
183febf1dffSMark Brown if (status & gpio)
184febf1dffSMark Brown ret = WM97XX_GPIO_HIGH;
185febf1dffSMark Brown else
186febf1dffSMark Brown ret = WM97XX_GPIO_LOW;
187febf1dffSMark Brown
188febf1dffSMark Brown mutex_unlock(&wm->codec_mutex);
189febf1dffSMark Brown return ret;
190febf1dffSMark Brown }
191febf1dffSMark Brown EXPORT_SYMBOL_GPL(wm97xx_get_gpio);
192febf1dffSMark Brown
193febf1dffSMark Brown /**
194febf1dffSMark Brown * wm97xx_set_gpio - Set the status of a codec GPIO.
195febf1dffSMark Brown * @wm: wm97xx device.
196febf1dffSMark Brown * @gpio: gpio
197b324009dSLee Jones * @status: status
198febf1dffSMark Brown *
199febf1dffSMark Brown * Set the status of a codec GPIO pin
200febf1dffSMark Brown */
201febf1dffSMark Brown
wm97xx_set_gpio(struct wm97xx * wm,u32 gpio,enum wm97xx_gpio_status status)202febf1dffSMark Brown void wm97xx_set_gpio(struct wm97xx *wm, u32 gpio,
203febf1dffSMark Brown enum wm97xx_gpio_status status)
204febf1dffSMark Brown {
205febf1dffSMark Brown u16 reg;
206febf1dffSMark Brown
207febf1dffSMark Brown mutex_lock(&wm->codec_mutex);
208febf1dffSMark Brown reg = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
209febf1dffSMark Brown
210af8b01b0SManuel Lauss if (status == WM97XX_GPIO_HIGH)
211febf1dffSMark Brown reg |= gpio;
212febf1dffSMark Brown else
213febf1dffSMark Brown reg &= ~gpio;
214febf1dffSMark Brown
21599fde513SMarek Vasut if (wm->id == WM9712_ID2 && wm->variant != WM97xx_WM1613)
216febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_STATUS, reg << 1);
217febf1dffSMark Brown else
218febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_STATUS, reg);
219febf1dffSMark Brown mutex_unlock(&wm->codec_mutex);
220febf1dffSMark Brown }
221febf1dffSMark Brown EXPORT_SYMBOL_GPL(wm97xx_set_gpio);
222febf1dffSMark Brown
223febf1dffSMark Brown /*
224febf1dffSMark Brown * Codec GPIO pin configuration, this sets pin direction, polarity,
225febf1dffSMark Brown * stickyness and wake up.
226febf1dffSMark Brown */
wm97xx_config_gpio(struct wm97xx * wm,u32 gpio,enum wm97xx_gpio_dir dir,enum wm97xx_gpio_pol pol,enum wm97xx_gpio_sticky sticky,enum wm97xx_gpio_wake wake)227febf1dffSMark Brown void wm97xx_config_gpio(struct wm97xx *wm, u32 gpio, enum wm97xx_gpio_dir dir,
228febf1dffSMark Brown enum wm97xx_gpio_pol pol, enum wm97xx_gpio_sticky sticky,
229febf1dffSMark Brown enum wm97xx_gpio_wake wake)
230febf1dffSMark Brown {
231febf1dffSMark Brown u16 reg;
232febf1dffSMark Brown
233febf1dffSMark Brown mutex_lock(&wm->codec_mutex);
234febf1dffSMark Brown reg = wm97xx_reg_read(wm, AC97_GPIO_POLARITY);
235febf1dffSMark Brown
236febf1dffSMark Brown if (pol == WM97XX_GPIO_POL_HIGH)
237febf1dffSMark Brown reg |= gpio;
238febf1dffSMark Brown else
239febf1dffSMark Brown reg &= ~gpio;
240febf1dffSMark Brown
241febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_POLARITY, reg);
242febf1dffSMark Brown reg = wm97xx_reg_read(wm, AC97_GPIO_STICKY);
243febf1dffSMark Brown
244febf1dffSMark Brown if (sticky == WM97XX_GPIO_STICKY)
245febf1dffSMark Brown reg |= gpio;
246febf1dffSMark Brown else
247febf1dffSMark Brown reg &= ~gpio;
248febf1dffSMark Brown
249febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_STICKY, reg);
250febf1dffSMark Brown reg = wm97xx_reg_read(wm, AC97_GPIO_WAKEUP);
251febf1dffSMark Brown
252febf1dffSMark Brown if (wake == WM97XX_GPIO_WAKE)
253febf1dffSMark Brown reg |= gpio;
254febf1dffSMark Brown else
255febf1dffSMark Brown reg &= ~gpio;
256febf1dffSMark Brown
257febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_WAKEUP, reg);
258febf1dffSMark Brown reg = wm97xx_reg_read(wm, AC97_GPIO_CFG);
259febf1dffSMark Brown
260febf1dffSMark Brown if (dir == WM97XX_GPIO_IN)
261febf1dffSMark Brown reg |= gpio;
262febf1dffSMark Brown else
263febf1dffSMark Brown reg &= ~gpio;
264febf1dffSMark Brown
265febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_CFG, reg);
266febf1dffSMark Brown mutex_unlock(&wm->codec_mutex);
267febf1dffSMark Brown }
268febf1dffSMark Brown EXPORT_SYMBOL_GPL(wm97xx_config_gpio);
269febf1dffSMark Brown
270febf1dffSMark Brown /*
27134d27853SMark Brown * Configure the WM97XX_PRP value to use while system is suspended.
27234d27853SMark Brown * If a value other than 0 is set then WM97xx pen detection will be
27334d27853SMark Brown * left enabled in the configured mode while the system is in suspend,
27434d27853SMark Brown * the device has users and suspend has not been disabled via the
27534d27853SMark Brown * wakeup sysfs entries.
27634d27853SMark Brown *
27734d27853SMark Brown * @wm: WM97xx device to configure
27834d27853SMark Brown * @mode: WM97XX_PRP value to configure while suspended
27934d27853SMark Brown */
wm97xx_set_suspend_mode(struct wm97xx * wm,u16 mode)28034d27853SMark Brown void wm97xx_set_suspend_mode(struct wm97xx *wm, u16 mode)
28134d27853SMark Brown {
28234d27853SMark Brown wm->suspend_mode = mode;
28334d27853SMark Brown device_init_wakeup(&wm->input_dev->dev, mode != 0);
28434d27853SMark Brown }
28534d27853SMark Brown EXPORT_SYMBOL_GPL(wm97xx_set_suspend_mode);
28634d27853SMark Brown
28734d27853SMark Brown /*
288a2ef9261SDmitry Torokhov * Codec PENDOWN irq handler
289a2ef9261SDmitry Torokhov *
290febf1dffSMark Brown */
wm97xx_pen_interrupt(int irq,void * dev_id)291a2ef9261SDmitry Torokhov static irqreturn_t wm97xx_pen_interrupt(int irq, void *dev_id)
292febf1dffSMark Brown {
293a2ef9261SDmitry Torokhov struct wm97xx *wm = dev_id;
294febf1dffSMark Brown int pen_was_down = wm->pen_is_down;
295febf1dffSMark Brown
296febf1dffSMark Brown /* do we need to enable the touch panel reader */
297febf1dffSMark Brown if (wm->id == WM9705_ID2) {
298febf1dffSMark Brown if (wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER_RD) &
299febf1dffSMark Brown WM97XX_PEN_DOWN)
300febf1dffSMark Brown wm->pen_is_down = 1;
301febf1dffSMark Brown else
302febf1dffSMark Brown wm->pen_is_down = 0;
303febf1dffSMark Brown } else {
304febf1dffSMark Brown u16 status, pol;
305febf1dffSMark Brown mutex_lock(&wm->codec_mutex);
306febf1dffSMark Brown status = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
307febf1dffSMark Brown pol = wm97xx_reg_read(wm, AC97_GPIO_POLARITY);
308febf1dffSMark Brown
309febf1dffSMark Brown if (WM97XX_GPIO_13 & pol & status) {
310febf1dffSMark Brown wm->pen_is_down = 1;
311febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_POLARITY, pol &
312febf1dffSMark Brown ~WM97XX_GPIO_13);
313febf1dffSMark Brown } else {
314febf1dffSMark Brown wm->pen_is_down = 0;
315febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_POLARITY, pol |
316febf1dffSMark Brown WM97XX_GPIO_13);
317febf1dffSMark Brown }
318febf1dffSMark Brown
31999fde513SMarek Vasut if (wm->id == WM9712_ID2 && wm->variant != WM97xx_WM1613)
320febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_STATUS, (status &
321febf1dffSMark Brown ~WM97XX_GPIO_13) << 1);
322febf1dffSMark Brown else
323febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_STATUS, status &
324febf1dffSMark Brown ~WM97XX_GPIO_13);
325febf1dffSMark Brown mutex_unlock(&wm->codec_mutex);
326febf1dffSMark Brown }
327febf1dffSMark Brown
328febf1dffSMark Brown /* If the system is not using continuous mode or it provides a
329febf1dffSMark Brown * pen down operation then we need to schedule polls while the
330febf1dffSMark Brown * pen is down. Otherwise the machine driver is responsible
331febf1dffSMark Brown * for scheduling reads.
332febf1dffSMark Brown */
333febf1dffSMark Brown if (!wm->mach_ops->acc_enabled || wm->mach_ops->acc_pen_down) {
334febf1dffSMark Brown if (wm->pen_is_down && !pen_was_down) {
33525985edcSLucas De Marchi /* Data is not available immediately on pen down */
336febf1dffSMark Brown queue_delayed_work(wm->ts_workq, &wm->ts_reader, 1);
337febf1dffSMark Brown }
338febf1dffSMark Brown
339febf1dffSMark Brown /* Let ts_reader report the pen up for debounce. */
340febf1dffSMark Brown if (!wm->pen_is_down && pen_was_down)
341febf1dffSMark Brown wm->pen_is_down = 1;
342febf1dffSMark Brown }
343febf1dffSMark Brown
344febf1dffSMark Brown if (!wm->pen_is_down && wm->mach_ops->acc_enabled)
345febf1dffSMark Brown wm->mach_ops->acc_pen_up(wm);
346febf1dffSMark Brown
347febf1dffSMark Brown return IRQ_HANDLED;
348febf1dffSMark Brown }
349febf1dffSMark Brown
350febf1dffSMark Brown /*
351febf1dffSMark Brown * initialise pen IRQ handler and workqueue
352febf1dffSMark Brown */
wm97xx_init_pen_irq(struct wm97xx * wm)353febf1dffSMark Brown static int wm97xx_init_pen_irq(struct wm97xx *wm)
354febf1dffSMark Brown {
355febf1dffSMark Brown u16 reg;
356febf1dffSMark Brown
357a2ef9261SDmitry Torokhov if (request_threaded_irq(wm->pen_irq, NULL, wm97xx_pen_interrupt,
358a2ef9261SDmitry Torokhov IRQF_SHARED | IRQF_ONESHOT,
359febf1dffSMark Brown "wm97xx-pen", wm)) {
360febf1dffSMark Brown dev_err(wm->dev,
361febf1dffSMark Brown "Failed to register pen down interrupt, polling");
362febf1dffSMark Brown wm->pen_irq = 0;
363febf1dffSMark Brown return -EINVAL;
364febf1dffSMark Brown }
365febf1dffSMark Brown
366febf1dffSMark Brown /* Configure GPIO as interrupt source on WM971x */
367febf1dffSMark Brown if (wm->id != WM9705_ID2) {
368febf1dffSMark Brown BUG_ON(!wm->mach_ops->irq_gpio);
369febf1dffSMark Brown reg = wm97xx_reg_read(wm, AC97_MISC_AFE);
370febf1dffSMark Brown wm97xx_reg_write(wm, AC97_MISC_AFE,
371febf1dffSMark Brown reg & ~(wm->mach_ops->irq_gpio));
372febf1dffSMark Brown reg = wm97xx_reg_read(wm, 0x5a);
373febf1dffSMark Brown wm97xx_reg_write(wm, 0x5a, reg & ~0x0001);
374febf1dffSMark Brown }
375febf1dffSMark Brown
376febf1dffSMark Brown return 0;
377febf1dffSMark Brown }
378febf1dffSMark Brown
wm97xx_read_samples(struct wm97xx * wm)379febf1dffSMark Brown static int wm97xx_read_samples(struct wm97xx *wm)
380febf1dffSMark Brown {
381febf1dffSMark Brown struct wm97xx_data data;
382febf1dffSMark Brown int rc;
383febf1dffSMark Brown
384febf1dffSMark Brown mutex_lock(&wm->codec_mutex);
385febf1dffSMark Brown
386febf1dffSMark Brown if (wm->mach_ops && wm->mach_ops->acc_enabled)
387febf1dffSMark Brown rc = wm->mach_ops->acc_pen_down(wm);
388febf1dffSMark Brown else
389febf1dffSMark Brown rc = wm->codec->poll_touch(wm, &data);
390febf1dffSMark Brown
391febf1dffSMark Brown if (rc & RC_PENUP) {
392febf1dffSMark Brown if (wm->pen_is_down) {
393febf1dffSMark Brown wm->pen_is_down = 0;
394febf1dffSMark Brown dev_dbg(wm->dev, "pen up\n");
395febf1dffSMark Brown input_report_abs(wm->input_dev, ABS_PRESSURE, 0);
39665db86acSMike Rapoport input_report_key(wm->input_dev, BTN_TOUCH, 0);
397febf1dffSMark Brown input_sync(wm->input_dev);
398febf1dffSMark Brown } else if (!(rc & RC_AGAIN)) {
399febf1dffSMark Brown /* We need high frequency updates only while
400febf1dffSMark Brown * pen is down, the user never will be able to
401febf1dffSMark Brown * touch screen faster than a few times per
402febf1dffSMark Brown * second... On the other hand, when the user
403febf1dffSMark Brown * is actively working with the touchscreen we
404febf1dffSMark Brown * don't want to lose the quick response. So we
405febf1dffSMark Brown * will slowly increase sleep time after the
406febf1dffSMark Brown * pen is up and quicky restore it to ~one task
407febf1dffSMark Brown * switch when pen is down again.
408febf1dffSMark Brown */
409febf1dffSMark Brown if (wm->ts_reader_interval < HZ / 10)
410febf1dffSMark Brown wm->ts_reader_interval++;
411febf1dffSMark Brown }
412febf1dffSMark Brown
413febf1dffSMark Brown } else if (rc & RC_VALID) {
414febf1dffSMark Brown dev_dbg(wm->dev,
415febf1dffSMark Brown "pen down: x=%x:%d, y=%x:%d, pressure=%x:%d\n",
416febf1dffSMark Brown data.x >> 12, data.x & 0xfff, data.y >> 12,
417febf1dffSMark Brown data.y & 0xfff, data.p >> 12, data.p & 0xfff);
418cfd5d096SMarkus Pargmann
419cfd5d096SMarkus Pargmann if (abs_x[0] > (data.x & 0xfff) ||
420cfd5d096SMarkus Pargmann abs_x[1] < (data.x & 0xfff) ||
421cfd5d096SMarkus Pargmann abs_y[0] > (data.y & 0xfff) ||
422cfd5d096SMarkus Pargmann abs_y[1] < (data.y & 0xfff)) {
423cfd5d096SMarkus Pargmann dev_dbg(wm->dev, "Measurement out of range, dropping it\n");
424cfd5d096SMarkus Pargmann rc = RC_AGAIN;
425cfd5d096SMarkus Pargmann goto out;
426cfd5d096SMarkus Pargmann }
427cfd5d096SMarkus Pargmann
428febf1dffSMark Brown input_report_abs(wm->input_dev, ABS_X, data.x & 0xfff);
429febf1dffSMark Brown input_report_abs(wm->input_dev, ABS_Y, data.y & 0xfff);
430febf1dffSMark Brown input_report_abs(wm->input_dev, ABS_PRESSURE, data.p & 0xfff);
43165db86acSMike Rapoport input_report_key(wm->input_dev, BTN_TOUCH, 1);
432febf1dffSMark Brown input_sync(wm->input_dev);
433febf1dffSMark Brown wm->pen_is_down = 1;
434febf1dffSMark Brown wm->ts_reader_interval = wm->ts_reader_min_interval;
435febf1dffSMark Brown } else if (rc & RC_PENDOWN) {
436febf1dffSMark Brown dev_dbg(wm->dev, "pen down\n");
437febf1dffSMark Brown wm->pen_is_down = 1;
438febf1dffSMark Brown wm->ts_reader_interval = wm->ts_reader_min_interval;
439febf1dffSMark Brown }
440febf1dffSMark Brown
441cfd5d096SMarkus Pargmann out:
442febf1dffSMark Brown mutex_unlock(&wm->codec_mutex);
443febf1dffSMark Brown return rc;
444febf1dffSMark Brown }
445febf1dffSMark Brown
446febf1dffSMark Brown /*
447febf1dffSMark Brown * The touchscreen sample reader.
448febf1dffSMark Brown */
wm97xx_ts_reader(struct work_struct * work)449febf1dffSMark Brown static void wm97xx_ts_reader(struct work_struct *work)
450febf1dffSMark Brown {
451febf1dffSMark Brown int rc;
452febf1dffSMark Brown struct wm97xx *wm = container_of(work, struct wm97xx, ts_reader.work);
453febf1dffSMark Brown
454febf1dffSMark Brown BUG_ON(!wm->codec);
455febf1dffSMark Brown
456febf1dffSMark Brown do {
457febf1dffSMark Brown rc = wm97xx_read_samples(wm);
458febf1dffSMark Brown } while (rc & RC_AGAIN);
459febf1dffSMark Brown
460febf1dffSMark Brown if (wm->pen_is_down || !wm->pen_irq)
461febf1dffSMark Brown queue_delayed_work(wm->ts_workq, &wm->ts_reader,
462febf1dffSMark Brown wm->ts_reader_interval);
463febf1dffSMark Brown }
464febf1dffSMark Brown
465febf1dffSMark Brown /**
466febf1dffSMark Brown * wm97xx_ts_input_open - Open the touch screen input device.
467febf1dffSMark Brown * @idev: Input device to be opened.
468febf1dffSMark Brown *
469febf1dffSMark Brown * Called by the input sub system to open a wm97xx touchscreen device.
470febf1dffSMark Brown * Starts the touchscreen thread and touch digitiser.
471febf1dffSMark Brown */
wm97xx_ts_input_open(struct input_dev * idev)472febf1dffSMark Brown static int wm97xx_ts_input_open(struct input_dev *idev)
473febf1dffSMark Brown {
474febf1dffSMark Brown struct wm97xx *wm = input_get_drvdata(idev);
475febf1dffSMark Brown
476c9a3a7cfSBhaktipriya Shridhar wm->ts_workq = alloc_ordered_workqueue("kwm97xx", 0);
477febf1dffSMark Brown if (wm->ts_workq == NULL) {
478febf1dffSMark Brown dev_err(wm->dev,
479febf1dffSMark Brown "Failed to create workqueue\n");
480febf1dffSMark Brown return -EINVAL;
481febf1dffSMark Brown }
482febf1dffSMark Brown
483febf1dffSMark Brown /* start digitiser */
484febf1dffSMark Brown if (wm->mach_ops && wm->mach_ops->acc_enabled)
485febf1dffSMark Brown wm->codec->acc_enable(wm, 1);
486febf1dffSMark Brown wm->codec->dig_enable(wm, 1);
487febf1dffSMark Brown
488febf1dffSMark Brown INIT_DELAYED_WORK(&wm->ts_reader, wm97xx_ts_reader);
489febf1dffSMark Brown
490febf1dffSMark Brown wm->ts_reader_min_interval = HZ >= 100 ? HZ / 100 : 1;
491febf1dffSMark Brown if (wm->ts_reader_min_interval < 1)
492febf1dffSMark Brown wm->ts_reader_min_interval = 1;
493febf1dffSMark Brown wm->ts_reader_interval = wm->ts_reader_min_interval;
494febf1dffSMark Brown
495febf1dffSMark Brown wm->pen_is_down = 0;
496febf1dffSMark Brown if (wm->pen_irq)
497febf1dffSMark Brown wm97xx_init_pen_irq(wm);
498febf1dffSMark Brown else
499febf1dffSMark Brown dev_err(wm->dev, "No IRQ specified\n");
500febf1dffSMark Brown
501febf1dffSMark Brown /* If we either don't have an interrupt for pen down events or
502febf1dffSMark Brown * failed to acquire it then we need to poll.
503febf1dffSMark Brown */
504febf1dffSMark Brown if (wm->pen_irq == 0)
505febf1dffSMark Brown queue_delayed_work(wm->ts_workq, &wm->ts_reader,
506febf1dffSMark Brown wm->ts_reader_interval);
507febf1dffSMark Brown
508febf1dffSMark Brown return 0;
509febf1dffSMark Brown }
510febf1dffSMark Brown
511febf1dffSMark Brown /**
512febf1dffSMark Brown * wm97xx_ts_input_close - Close the touch screen input device.
513febf1dffSMark Brown * @idev: Input device to be closed.
514febf1dffSMark Brown *
515febf1dffSMark Brown * Called by the input sub system to close a wm97xx touchscreen
516febf1dffSMark Brown * device. Kills the touchscreen thread and stops the touch
517febf1dffSMark Brown * digitiser.
518febf1dffSMark Brown */
519febf1dffSMark Brown
wm97xx_ts_input_close(struct input_dev * idev)520febf1dffSMark Brown static void wm97xx_ts_input_close(struct input_dev *idev)
521febf1dffSMark Brown {
522febf1dffSMark Brown struct wm97xx *wm = input_get_drvdata(idev);
523febf1dffSMark Brown u16 reg;
524febf1dffSMark Brown
525febf1dffSMark Brown if (wm->pen_irq) {
526febf1dffSMark Brown /* Return the interrupt to GPIO usage (disabling it) */
527febf1dffSMark Brown if (wm->id != WM9705_ID2) {
528febf1dffSMark Brown BUG_ON(!wm->mach_ops->irq_gpio);
529febf1dffSMark Brown reg = wm97xx_reg_read(wm, AC97_MISC_AFE);
530febf1dffSMark Brown wm97xx_reg_write(wm, AC97_MISC_AFE,
531febf1dffSMark Brown reg | wm->mach_ops->irq_gpio);
532febf1dffSMark Brown }
533febf1dffSMark Brown
534febf1dffSMark Brown free_irq(wm->pen_irq, wm);
535febf1dffSMark Brown }
536febf1dffSMark Brown
537febf1dffSMark Brown wm->pen_is_down = 0;
538febf1dffSMark Brown
539febf1dffSMark Brown /* ts_reader rearms itself so we need to explicitly stop it
540febf1dffSMark Brown * before we destroy the workqueue.
541febf1dffSMark Brown */
542febf1dffSMark Brown cancel_delayed_work_sync(&wm->ts_reader);
543febf1dffSMark Brown
544febf1dffSMark Brown destroy_workqueue(wm->ts_workq);
545febf1dffSMark Brown
546febf1dffSMark Brown /* stop digitiser */
547febf1dffSMark Brown wm->codec->dig_enable(wm, 0);
548febf1dffSMark Brown if (wm->mach_ops && wm->mach_ops->acc_enabled)
549febf1dffSMark Brown wm->codec->acc_enable(wm, 0);
550febf1dffSMark Brown }
551febf1dffSMark Brown
wm97xx_register_touch(struct wm97xx * wm)552c72f61e7SRobert Jarzmik static int wm97xx_register_touch(struct wm97xx *wm)
553febf1dffSMark Brown {
554c72f61e7SRobert Jarzmik struct wm97xx_pdata *pdata = dev_get_platdata(wm->dev);
555c72f61e7SRobert Jarzmik int ret;
556febf1dffSMark Brown
557c72f61e7SRobert Jarzmik wm->input_dev = devm_input_allocate_device(wm->dev);
558c72f61e7SRobert Jarzmik if (wm->input_dev == NULL)
559febf1dffSMark Brown return -ENOMEM;
560febf1dffSMark Brown
561c72f61e7SRobert Jarzmik /* set up touch configuration */
562c72f61e7SRobert Jarzmik wm->input_dev->name = "wm97xx touchscreen";
563c72f61e7SRobert Jarzmik wm->input_dev->phys = "wm97xx";
564c72f61e7SRobert Jarzmik wm->input_dev->open = wm97xx_ts_input_open;
565c72f61e7SRobert Jarzmik wm->input_dev->close = wm97xx_ts_input_close;
566c72f61e7SRobert Jarzmik
567c72f61e7SRobert Jarzmik __set_bit(EV_ABS, wm->input_dev->evbit);
568c72f61e7SRobert Jarzmik __set_bit(EV_KEY, wm->input_dev->evbit);
569c72f61e7SRobert Jarzmik __set_bit(BTN_TOUCH, wm->input_dev->keybit);
570c72f61e7SRobert Jarzmik
571c72f61e7SRobert Jarzmik input_set_abs_params(wm->input_dev, ABS_X, abs_x[0], abs_x[1],
572c72f61e7SRobert Jarzmik abs_x[2], 0);
573c72f61e7SRobert Jarzmik input_set_abs_params(wm->input_dev, ABS_Y, abs_y[0], abs_y[1],
574c72f61e7SRobert Jarzmik abs_y[2], 0);
575c72f61e7SRobert Jarzmik input_set_abs_params(wm->input_dev, ABS_PRESSURE, abs_p[0], abs_p[1],
576c72f61e7SRobert Jarzmik abs_p[2], 0);
577c72f61e7SRobert Jarzmik
578c72f61e7SRobert Jarzmik input_set_drvdata(wm->input_dev, wm);
579c72f61e7SRobert Jarzmik wm->input_dev->dev.parent = wm->dev;
580c72f61e7SRobert Jarzmik
581c72f61e7SRobert Jarzmik ret = input_register_device(wm->input_dev);
582c72f61e7SRobert Jarzmik if (ret)
583c72f61e7SRobert Jarzmik return ret;
584c72f61e7SRobert Jarzmik
585c72f61e7SRobert Jarzmik /*
586c72f61e7SRobert Jarzmik * register our extended touch device (for machine specific
587c72f61e7SRobert Jarzmik * extensions)
588c72f61e7SRobert Jarzmik */
589c72f61e7SRobert Jarzmik wm->touch_dev = platform_device_alloc("wm97xx-touch", -1);
590a4f399a1SChristophe JAILLET if (!wm->touch_dev)
591a4f399a1SChristophe JAILLET return -ENOMEM;
592a4f399a1SChristophe JAILLET
593c72f61e7SRobert Jarzmik platform_set_drvdata(wm->touch_dev, wm);
594c72f61e7SRobert Jarzmik wm->touch_dev->dev.parent = wm->dev;
595c72f61e7SRobert Jarzmik wm->touch_dev->dev.platform_data = pdata;
596c72f61e7SRobert Jarzmik ret = platform_device_add(wm->touch_dev);
597c72f61e7SRobert Jarzmik if (ret < 0)
598c72f61e7SRobert Jarzmik goto touch_reg_err;
599c72f61e7SRobert Jarzmik
600c72f61e7SRobert Jarzmik return 0;
601c72f61e7SRobert Jarzmik touch_reg_err:
602c72f61e7SRobert Jarzmik platform_device_put(wm->touch_dev);
603c72f61e7SRobert Jarzmik
604c72f61e7SRobert Jarzmik return ret;
605c72f61e7SRobert Jarzmik }
606c72f61e7SRobert Jarzmik
wm97xx_unregister_touch(struct wm97xx * wm)607c72f61e7SRobert Jarzmik static void wm97xx_unregister_touch(struct wm97xx *wm)
608c72f61e7SRobert Jarzmik {
609c72f61e7SRobert Jarzmik platform_device_unregister(wm->touch_dev);
610c72f61e7SRobert Jarzmik }
611c72f61e7SRobert Jarzmik
_wm97xx_probe(struct wm97xx * wm)612c72f61e7SRobert Jarzmik static int _wm97xx_probe(struct wm97xx *wm)
613c72f61e7SRobert Jarzmik {
614c72f61e7SRobert Jarzmik int id = 0;
615c72f61e7SRobert Jarzmik
616c72f61e7SRobert Jarzmik mutex_init(&wm->codec_mutex);
617c72f61e7SRobert Jarzmik dev_set_drvdata(wm->dev, wm);
618febf1dffSMark Brown
619febf1dffSMark Brown /* check that we have a supported codec */
620febf1dffSMark Brown id = wm97xx_reg_read(wm, AC97_VENDOR_ID1);
621febf1dffSMark Brown if (id != WM97XX_ID1) {
622c72f61e7SRobert Jarzmik dev_err(wm->dev,
623c72f61e7SRobert Jarzmik "Device with vendor %04x is not a wm97xx\n", id);
624c72f61e7SRobert Jarzmik return -ENODEV;
625febf1dffSMark Brown }
626febf1dffSMark Brown
627febf1dffSMark Brown wm->id = wm97xx_reg_read(wm, AC97_VENDOR_ID2);
628febf1dffSMark Brown
62999fde513SMarek Vasut wm->variant = WM97xx_GENERIC;
63099fde513SMarek Vasut
631febf1dffSMark Brown dev_info(wm->dev, "detected a wm97%02x codec\n", wm->id & 0xff);
632febf1dffSMark Brown
633febf1dffSMark Brown switch (wm->id & 0xff) {
634febf1dffSMark Brown #ifdef CONFIG_TOUCHSCREEN_WM9705
635febf1dffSMark Brown case 0x05:
636febf1dffSMark Brown wm->codec = &wm9705_codec;
637febf1dffSMark Brown break;
638febf1dffSMark Brown #endif
639febf1dffSMark Brown #ifdef CONFIG_TOUCHSCREEN_WM9712
640febf1dffSMark Brown case 0x12:
641febf1dffSMark Brown wm->codec = &wm9712_codec;
642febf1dffSMark Brown break;
643febf1dffSMark Brown #endif
644febf1dffSMark Brown #ifdef CONFIG_TOUCHSCREEN_WM9713
645febf1dffSMark Brown case 0x13:
646febf1dffSMark Brown wm->codec = &wm9713_codec;
647febf1dffSMark Brown break;
648febf1dffSMark Brown #endif
649febf1dffSMark Brown default:
650febf1dffSMark Brown dev_err(wm->dev, "Support for wm97%02x not compiled in.\n",
651febf1dffSMark Brown wm->id & 0xff);
652c72f61e7SRobert Jarzmik return -ENODEV;
653febf1dffSMark Brown }
654febf1dffSMark Brown
6555de4cd43SMark Brown /* set up physical characteristics */
6565de4cd43SMark Brown wm->codec->phy_init(wm);
6575de4cd43SMark Brown
6585de4cd43SMark Brown /* load gpio cache */
6595de4cd43SMark Brown wm->gpio[0] = wm97xx_reg_read(wm, AC97_GPIO_CFG);
6605de4cd43SMark Brown wm->gpio[1] = wm97xx_reg_read(wm, AC97_GPIO_POLARITY);
6615de4cd43SMark Brown wm->gpio[2] = wm97xx_reg_read(wm, AC97_GPIO_STICKY);
6625de4cd43SMark Brown wm->gpio[3] = wm97xx_reg_read(wm, AC97_GPIO_WAKEUP);
6635de4cd43SMark Brown wm->gpio[4] = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
6645de4cd43SMark Brown wm->gpio[5] = wm97xx_reg_read(wm, AC97_MISC_AFE);
6655de4cd43SMark Brown
666c72f61e7SRobert Jarzmik return wm97xx_register_touch(wm);
667febf1dffSMark Brown }
668febf1dffSMark Brown
wm97xx_remove_battery(struct wm97xx * wm)669c72f61e7SRobert Jarzmik static void wm97xx_remove_battery(struct wm97xx *wm)
670c72f61e7SRobert Jarzmik {
671c72f61e7SRobert Jarzmik platform_device_unregister(wm->battery_dev);
672c72f61e7SRobert Jarzmik }
67365db86acSMike Rapoport
wm97xx_add_battery(struct wm97xx * wm,struct wm97xx_batt_pdata * pdata)674c72f61e7SRobert Jarzmik static int wm97xx_add_battery(struct wm97xx *wm,
675c72f61e7SRobert Jarzmik struct wm97xx_batt_pdata *pdata)
676c72f61e7SRobert Jarzmik {
677c72f61e7SRobert Jarzmik int ret;
67865db86acSMike Rapoport
679febf1dffSMark Brown wm->battery_dev = platform_device_alloc("wm97xx-battery", -1);
680c72f61e7SRobert Jarzmik if (!wm->battery_dev)
681c72f61e7SRobert Jarzmik return -ENOMEM;
682febf1dffSMark Brown
683c72f61e7SRobert Jarzmik platform_set_drvdata(wm->battery_dev, wm);
684c72f61e7SRobert Jarzmik wm->battery_dev->dev.parent = wm->dev;
685c72f61e7SRobert Jarzmik wm->battery_dev->dev.platform_data = pdata;
686c72f61e7SRobert Jarzmik ret = platform_device_add(wm->battery_dev);
687c72f61e7SRobert Jarzmik if (ret)
688c72f61e7SRobert Jarzmik platform_device_put(wm->battery_dev);
689c72f61e7SRobert Jarzmik
690c72f61e7SRobert Jarzmik return ret;
691febf1dffSMark Brown }
692c72f61e7SRobert Jarzmik
wm97xx_probe(struct device * dev)693c72f61e7SRobert Jarzmik static int wm97xx_probe(struct device *dev)
694c72f61e7SRobert Jarzmik {
695c72f61e7SRobert Jarzmik struct wm97xx *wm;
696c72f61e7SRobert Jarzmik int ret;
697c72f61e7SRobert Jarzmik struct wm97xx_pdata *pdata = dev_get_platdata(dev);
698c72f61e7SRobert Jarzmik
699c72f61e7SRobert Jarzmik wm = devm_kzalloc(dev, sizeof(struct wm97xx), GFP_KERNEL);
700c72f61e7SRobert Jarzmik if (!wm)
701c72f61e7SRobert Jarzmik return -ENOMEM;
702c72f61e7SRobert Jarzmik
703c72f61e7SRobert Jarzmik wm->dev = dev;
704c72f61e7SRobert Jarzmik wm->ac97 = to_ac97_t(dev);
705c72f61e7SRobert Jarzmik
706c72f61e7SRobert Jarzmik ret = _wm97xx_probe(wm);
707c72f61e7SRobert Jarzmik if (ret)
708c72f61e7SRobert Jarzmik return ret;
709c72f61e7SRobert Jarzmik
710c72f61e7SRobert Jarzmik ret = wm97xx_add_battery(wm, pdata ? pdata->batt_pdata : NULL);
711febf1dffSMark Brown if (ret < 0)
712c72f61e7SRobert Jarzmik goto batt_err;
713febf1dffSMark Brown
714febf1dffSMark Brown return ret;
715febf1dffSMark Brown
716febf1dffSMark Brown batt_err:
717c72f61e7SRobert Jarzmik wm97xx_unregister_touch(wm);
718febf1dffSMark Brown return ret;
719febf1dffSMark Brown }
720febf1dffSMark Brown
wm97xx_remove(struct device * dev)721febf1dffSMark Brown static int wm97xx_remove(struct device *dev)
722febf1dffSMark Brown {
723febf1dffSMark Brown struct wm97xx *wm = dev_get_drvdata(dev);
724febf1dffSMark Brown
725c72f61e7SRobert Jarzmik wm97xx_remove_battery(wm);
726c72f61e7SRobert Jarzmik wm97xx_unregister_touch(wm);
727febf1dffSMark Brown
728febf1dffSMark Brown return 0;
729febf1dffSMark Brown }
730febf1dffSMark Brown
wm97xx_mfd_probe(struct platform_device * pdev)731ae9d1b5fSRobert Jarzmik static int wm97xx_mfd_probe(struct platform_device *pdev)
732ae9d1b5fSRobert Jarzmik {
733ae9d1b5fSRobert Jarzmik struct wm97xx *wm;
734ae9d1b5fSRobert Jarzmik struct wm97xx_platform_data *mfd_pdata = dev_get_platdata(&pdev->dev);
735ae9d1b5fSRobert Jarzmik int ret;
736ae9d1b5fSRobert Jarzmik
737ae9d1b5fSRobert Jarzmik wm = devm_kzalloc(&pdev->dev, sizeof(struct wm97xx), GFP_KERNEL);
738ae9d1b5fSRobert Jarzmik if (!wm)
739ae9d1b5fSRobert Jarzmik return -ENOMEM;
740ae9d1b5fSRobert Jarzmik
741ae9d1b5fSRobert Jarzmik wm->dev = &pdev->dev;
742ae9d1b5fSRobert Jarzmik wm->ac97 = mfd_pdata->ac97;
743ae9d1b5fSRobert Jarzmik
744ae9d1b5fSRobert Jarzmik ret = _wm97xx_probe(wm);
745ae9d1b5fSRobert Jarzmik if (ret)
746ae9d1b5fSRobert Jarzmik return ret;
747ae9d1b5fSRobert Jarzmik
748ae9d1b5fSRobert Jarzmik ret = wm97xx_add_battery(wm, mfd_pdata->batt_pdata);
749ae9d1b5fSRobert Jarzmik if (ret < 0)
750ae9d1b5fSRobert Jarzmik goto batt_err;
751ae9d1b5fSRobert Jarzmik
752ae9d1b5fSRobert Jarzmik return ret;
753ae9d1b5fSRobert Jarzmik
754ae9d1b5fSRobert Jarzmik batt_err:
755ae9d1b5fSRobert Jarzmik wm97xx_unregister_touch(wm);
756ae9d1b5fSRobert Jarzmik return ret;
757ae9d1b5fSRobert Jarzmik }
758ae9d1b5fSRobert Jarzmik
wm97xx_mfd_remove(struct platform_device * pdev)759*c50fdc48SUwe Kleine-König static void wm97xx_mfd_remove(struct platform_device *pdev)
760ae9d1b5fSRobert Jarzmik {
76112dc6adcSUwe Kleine-König wm97xx_remove(&pdev->dev);
762ae9d1b5fSRobert Jarzmik }
763ae9d1b5fSRobert Jarzmik
wm97xx_suspend(struct device * dev)764fea26099SJonathan Cameron static int wm97xx_suspend(struct device *dev)
765febf1dffSMark Brown {
766febf1dffSMark Brown struct wm97xx *wm = dev_get_drvdata(dev);
76734d27853SMark Brown u16 reg;
76834d27853SMark Brown int suspend_mode;
76934d27853SMark Brown
77034d27853SMark Brown if (device_may_wakeup(&wm->input_dev->dev))
77134d27853SMark Brown suspend_mode = wm->suspend_mode;
77234d27853SMark Brown else
77334d27853SMark Brown suspend_mode = 0;
774febf1dffSMark Brown
775d69f0a43SAndrzej Pietrasiewicz mutex_lock(&wm->input_dev->mutex);
776d69f0a43SAndrzej Pietrasiewicz if (input_device_enabled(wm->input_dev))
777febf1dffSMark Brown cancel_delayed_work_sync(&wm->ts_reader);
778febf1dffSMark Brown
77934d27853SMark Brown /* Power down the digitiser (bypassing the cache for resume) */
78034d27853SMark Brown reg = wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER2);
78134d27853SMark Brown reg &= ~WM97XX_PRP_DET_DIG;
782d69f0a43SAndrzej Pietrasiewicz if (input_device_enabled(wm->input_dev))
78334d27853SMark Brown reg |= suspend_mode;
78434d27853SMark Brown wm->ac97->bus->ops->write(wm->ac97, AC97_WM97XX_DIGITISER2, reg);
78534d27853SMark Brown
78634d27853SMark Brown /* WM9713 has an additional power bit - turn it off if there
78734d27853SMark Brown * are no users or if suspend mode is zero. */
78834d27853SMark Brown if (wm->id == WM9713_ID2 &&
789d69f0a43SAndrzej Pietrasiewicz (!input_device_enabled(wm->input_dev) || !suspend_mode)) {
79034d27853SMark Brown reg = wm97xx_reg_read(wm, AC97_EXTENDED_MID) | 0x8000;
79134d27853SMark Brown wm97xx_reg_write(wm, AC97_EXTENDED_MID, reg);
79234d27853SMark Brown }
793d69f0a43SAndrzej Pietrasiewicz mutex_unlock(&wm->input_dev->mutex);
79434d27853SMark Brown
795febf1dffSMark Brown return 0;
796febf1dffSMark Brown }
797febf1dffSMark Brown
wm97xx_resume(struct device * dev)798fea26099SJonathan Cameron static int wm97xx_resume(struct device *dev)
799febf1dffSMark Brown {
800febf1dffSMark Brown struct wm97xx *wm = dev_get_drvdata(dev);
801febf1dffSMark Brown
802d69f0a43SAndrzej Pietrasiewicz mutex_lock(&wm->input_dev->mutex);
803febf1dffSMark Brown /* restore digitiser and gpios */
804febf1dffSMark Brown if (wm->id == WM9713_ID2) {
805febf1dffSMark Brown wm97xx_reg_write(wm, AC97_WM9713_DIG1, wm->dig[0]);
806febf1dffSMark Brown wm97xx_reg_write(wm, 0x5a, wm->misc);
807d69f0a43SAndrzej Pietrasiewicz if (input_device_enabled(wm->input_dev)) {
808febf1dffSMark Brown u16 reg;
809febf1dffSMark Brown reg = wm97xx_reg_read(wm, AC97_EXTENDED_MID) & 0x7fff;
810febf1dffSMark Brown wm97xx_reg_write(wm, AC97_EXTENDED_MID, reg);
811febf1dffSMark Brown }
812febf1dffSMark Brown }
813febf1dffSMark Brown
814febf1dffSMark Brown wm97xx_reg_write(wm, AC97_WM9713_DIG2, wm->dig[1]);
815febf1dffSMark Brown wm97xx_reg_write(wm, AC97_WM9713_DIG3, wm->dig[2]);
816febf1dffSMark Brown
817febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_CFG, wm->gpio[0]);
818febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_POLARITY, wm->gpio[1]);
819febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_STICKY, wm->gpio[2]);
820febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_WAKEUP, wm->gpio[3]);
821febf1dffSMark Brown wm97xx_reg_write(wm, AC97_GPIO_STATUS, wm->gpio[4]);
822febf1dffSMark Brown wm97xx_reg_write(wm, AC97_MISC_AFE, wm->gpio[5]);
823febf1dffSMark Brown
824d69f0a43SAndrzej Pietrasiewicz if (input_device_enabled(wm->input_dev) && !wm->pen_irq) {
825febf1dffSMark Brown wm->ts_reader_interval = wm->ts_reader_min_interval;
826febf1dffSMark Brown queue_delayed_work(wm->ts_workq, &wm->ts_reader,
827febf1dffSMark Brown wm->ts_reader_interval);
828febf1dffSMark Brown }
829d69f0a43SAndrzej Pietrasiewicz mutex_unlock(&wm->input_dev->mutex);
830febf1dffSMark Brown
831febf1dffSMark Brown return 0;
832febf1dffSMark Brown }
833febf1dffSMark Brown
834fea26099SJonathan Cameron static DEFINE_SIMPLE_DEV_PM_OPS(wm97xx_pm_ops, wm97xx_suspend, wm97xx_resume);
835febf1dffSMark Brown
836febf1dffSMark Brown /*
837febf1dffSMark Brown * Machine specific operations
838febf1dffSMark Brown */
wm97xx_register_mach_ops(struct wm97xx * wm,struct wm97xx_mach_ops * mach_ops)839febf1dffSMark Brown int wm97xx_register_mach_ops(struct wm97xx *wm,
840febf1dffSMark Brown struct wm97xx_mach_ops *mach_ops)
841febf1dffSMark Brown {
842febf1dffSMark Brown mutex_lock(&wm->codec_mutex);
843febf1dffSMark Brown if (wm->mach_ops) {
844febf1dffSMark Brown mutex_unlock(&wm->codec_mutex);
845febf1dffSMark Brown return -EINVAL;
846febf1dffSMark Brown }
847febf1dffSMark Brown wm->mach_ops = mach_ops;
848febf1dffSMark Brown mutex_unlock(&wm->codec_mutex);
849febf1dffSMark Brown
850febf1dffSMark Brown return 0;
851febf1dffSMark Brown }
852febf1dffSMark Brown EXPORT_SYMBOL_GPL(wm97xx_register_mach_ops);
853febf1dffSMark Brown
wm97xx_unregister_mach_ops(struct wm97xx * wm)854febf1dffSMark Brown void wm97xx_unregister_mach_ops(struct wm97xx *wm)
855febf1dffSMark Brown {
856febf1dffSMark Brown mutex_lock(&wm->codec_mutex);
857febf1dffSMark Brown wm->mach_ops = NULL;
858febf1dffSMark Brown mutex_unlock(&wm->codec_mutex);
859febf1dffSMark Brown }
860febf1dffSMark Brown EXPORT_SYMBOL_GPL(wm97xx_unregister_mach_ops);
861febf1dffSMark Brown
862febf1dffSMark Brown static struct device_driver wm97xx_driver = {
863ef9db492SMark Brown .name = "wm97xx-ts",
864ae9d1b5fSRobert Jarzmik #ifdef CONFIG_AC97_BUS
865febf1dffSMark Brown .bus = &ac97_bus_type,
866ae9d1b5fSRobert Jarzmik #endif
867febf1dffSMark Brown .owner = THIS_MODULE,
868febf1dffSMark Brown .probe = wm97xx_probe,
869febf1dffSMark Brown .remove = wm97xx_remove,
870fea26099SJonathan Cameron .pm = pm_sleep_ptr(&wm97xx_pm_ops),
871febf1dffSMark Brown };
872febf1dffSMark Brown
873ae9d1b5fSRobert Jarzmik static struct platform_driver wm97xx_mfd_driver = {
874ae9d1b5fSRobert Jarzmik .driver = {
875ae9d1b5fSRobert Jarzmik .name = "wm97xx-ts",
876fea26099SJonathan Cameron .pm = pm_sleep_ptr(&wm97xx_pm_ops),
877ae9d1b5fSRobert Jarzmik },
878ae9d1b5fSRobert Jarzmik .probe = wm97xx_mfd_probe,
879*c50fdc48SUwe Kleine-König .remove_new = wm97xx_mfd_remove,
880ae9d1b5fSRobert Jarzmik };
881ae9d1b5fSRobert Jarzmik
wm97xx_init(void)882febf1dffSMark Brown static int __init wm97xx_init(void)
883febf1dffSMark Brown {
884ae9d1b5fSRobert Jarzmik int ret;
885ae9d1b5fSRobert Jarzmik
886ae9d1b5fSRobert Jarzmik ret = platform_driver_register(&wm97xx_mfd_driver);
887ae9d1b5fSRobert Jarzmik if (ret)
888ae9d1b5fSRobert Jarzmik return ret;
889ae9d1b5fSRobert Jarzmik
890ae9d1b5fSRobert Jarzmik if (IS_BUILTIN(CONFIG_AC97_BUS))
891ae9d1b5fSRobert Jarzmik ret = driver_register(&wm97xx_driver);
892ae9d1b5fSRobert Jarzmik return ret;
893febf1dffSMark Brown }
894febf1dffSMark Brown
wm97xx_exit(void)895febf1dffSMark Brown static void __exit wm97xx_exit(void)
896febf1dffSMark Brown {
897a3f7c3fcSRandy Dunlap if (IS_BUILTIN(CONFIG_AC97_BUS))
898febf1dffSMark Brown driver_unregister(&wm97xx_driver);
899ae9d1b5fSRobert Jarzmik platform_driver_unregister(&wm97xx_mfd_driver);
900febf1dffSMark Brown }
901febf1dffSMark Brown
902febf1dffSMark Brown module_init(wm97xx_init);
903febf1dffSMark Brown module_exit(wm97xx_exit);
904febf1dffSMark Brown
905febf1dffSMark Brown /* Module information */
906b8d055a8SLiam Girdwood MODULE_AUTHOR("Liam Girdwood <lrg@slimlogic.co.uk>");
907febf1dffSMark Brown MODULE_DESCRIPTION("WM97xx Core - Touch Screen / AUX ADC / GPIO Driver");
908febf1dffSMark Brown MODULE_LICENSE("GPL");
909