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 <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>
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/mfd/wm97xx.h>
48 #include <linux/workqueue.h>
49 #include <linux/wm97xx.h>
50 #include <linux/uaccess.h>
51 #include <linux/io.h>
52 #include <linux/slab.h>
53 
54 #define TS_NAME			"wm97xx"
55 #define WM_CORE_VERSION		"1.00"
56 #define DEFAULT_PRESSURE	0xb0c0
57 
58 
59 /*
60  * Touchscreen absolute values
61  *
62  * These parameters are used to help the input layer discard out of
63  * range readings and reduce jitter etc.
64  *
65  *   o min, max:- indicate the min and max values your touch screen returns
66  *   o fuzz:- use a higher number to reduce jitter
67  *
68  * The default values correspond to Mainstone II in QVGA mode
69  *
70  * Please read
71  * Documentation/input/input-programming.rst for more details.
72  */
73 
74 static int abs_x[3] = {150, 4000, 5};
75 module_param_array(abs_x, int, NULL, 0);
76 MODULE_PARM_DESC(abs_x, "Touchscreen absolute X min, max, fuzz");
77 
78 static int abs_y[3] = {200, 4000, 40};
79 module_param_array(abs_y, int, NULL, 0);
80 MODULE_PARM_DESC(abs_y, "Touchscreen absolute Y min, max, fuzz");
81 
82 static int abs_p[3] = {0, 150, 4};
83 module_param_array(abs_p, int, NULL, 0);
84 MODULE_PARM_DESC(abs_p, "Touchscreen absolute Pressure min, max, fuzz");
85 
86 /*
87  * wm97xx IO access, all IO locking done by AC97 layer
88  */
89 int wm97xx_reg_read(struct wm97xx *wm, u16 reg)
90 {
91 	if (wm->ac97)
92 		return wm->ac97->bus->ops->read(wm->ac97, reg);
93 	else
94 		return -1;
95 }
96 EXPORT_SYMBOL_GPL(wm97xx_reg_read);
97 
98 void wm97xx_reg_write(struct wm97xx *wm, u16 reg, u16 val)
99 {
100 	/* cache digitiser registers */
101 	if (reg >= AC97_WM9713_DIG1 && reg <= AC97_WM9713_DIG3)
102 		wm->dig[(reg - AC97_WM9713_DIG1) >> 1] = val;
103 
104 	/* cache gpio regs */
105 	if (reg >= AC97_GPIO_CFG && reg <= AC97_MISC_AFE)
106 		wm->gpio[(reg - AC97_GPIO_CFG) >> 1] = val;
107 
108 	/* wm9713 irq reg */
109 	if (reg == 0x5a)
110 		wm->misc = val;
111 
112 	if (wm->ac97)
113 		wm->ac97->bus->ops->write(wm->ac97, reg, val);
114 }
115 EXPORT_SYMBOL_GPL(wm97xx_reg_write);
116 
117 /**
118  * wm97xx_read_aux_adc - Read the aux adc.
119  * @wm: wm97xx device.
120  * @adcsel: codec ADC to be read
121  *
122  * Reads the selected AUX ADC.
123  */
124 
125 int wm97xx_read_aux_adc(struct wm97xx *wm, u16 adcsel)
126 {
127 	int power_adc = 0, auxval;
128 	u16 power = 0;
129 	int rc = 0;
130 	int timeout = 0;
131 
132 	/* get codec */
133 	mutex_lock(&wm->codec_mutex);
134 
135 	/* When the touchscreen is not in use, we may have to power up
136 	 * the AUX ADC before we can use sample the AUX inputs->
137 	 */
138 	if (wm->id == WM9713_ID2 &&
139 	    (power = wm97xx_reg_read(wm, AC97_EXTENDED_MID)) & 0x8000) {
140 		power_adc = 1;
141 		wm97xx_reg_write(wm, AC97_EXTENDED_MID, power & 0x7fff);
142 	}
143 
144 	/* Prepare the codec for AUX reading */
145 	wm->codec->aux_prepare(wm);
146 
147 	/* Turn polling mode on to read AUX ADC */
148 	wm->pen_probably_down = 1;
149 
150 	while (rc != RC_VALID && timeout++ < 5)
151 		rc = wm->codec->poll_sample(wm, adcsel, &auxval);
152 
153 	if (power_adc)
154 		wm97xx_reg_write(wm, AC97_EXTENDED_MID, power | 0x8000);
155 
156 	wm->codec->dig_restore(wm);
157 
158 	wm->pen_probably_down = 0;
159 
160 	if (timeout >= 5) {
161 		dev_err(wm->dev,
162 			"timeout reading auxadc %d, disabling digitiser\n",
163 			adcsel);
164 		wm->codec->dig_enable(wm, false);
165 	}
166 
167 	mutex_unlock(&wm->codec_mutex);
168 	return (rc == RC_VALID ? auxval & 0xfff : -EBUSY);
169 }
170 EXPORT_SYMBOL_GPL(wm97xx_read_aux_adc);
171 
172 /**
173  * wm97xx_get_gpio - Get the status of a codec GPIO.
174  * @wm: wm97xx device.
175  * @gpio: gpio
176  *
177  * Get the status of a codec GPIO pin
178  */
179 
180 enum wm97xx_gpio_status wm97xx_get_gpio(struct wm97xx *wm, u32 gpio)
181 {
182 	u16 status;
183 	enum wm97xx_gpio_status ret;
184 
185 	mutex_lock(&wm->codec_mutex);
186 	status = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
187 
188 	if (status & gpio)
189 		ret = WM97XX_GPIO_HIGH;
190 	else
191 		ret = WM97XX_GPIO_LOW;
192 
193 	mutex_unlock(&wm->codec_mutex);
194 	return ret;
195 }
196 EXPORT_SYMBOL_GPL(wm97xx_get_gpio);
197 
198 /**
199  * wm97xx_set_gpio - Set the status of a codec GPIO.
200  * @wm: wm97xx device.
201  * @gpio: gpio
202  *
203  *
204  * Set the status of a codec GPIO pin
205  */
206 
207 void wm97xx_set_gpio(struct wm97xx *wm, u32 gpio,
208 				enum wm97xx_gpio_status status)
209 {
210 	u16 reg;
211 
212 	mutex_lock(&wm->codec_mutex);
213 	reg = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
214 
215 	if (status == WM97XX_GPIO_HIGH)
216 		reg |= gpio;
217 	else
218 		reg &= ~gpio;
219 
220 	if (wm->id == WM9712_ID2 && wm->variant != WM97xx_WM1613)
221 		wm97xx_reg_write(wm, AC97_GPIO_STATUS, reg << 1);
222 	else
223 		wm97xx_reg_write(wm, AC97_GPIO_STATUS, reg);
224 	mutex_unlock(&wm->codec_mutex);
225 }
226 EXPORT_SYMBOL_GPL(wm97xx_set_gpio);
227 
228 /*
229  * Codec GPIO pin configuration, this sets pin direction, polarity,
230  * stickyness and wake up.
231  */
232 void wm97xx_config_gpio(struct wm97xx *wm, u32 gpio, enum wm97xx_gpio_dir dir,
233 		   enum wm97xx_gpio_pol pol, enum wm97xx_gpio_sticky sticky,
234 		   enum wm97xx_gpio_wake wake)
235 {
236 	u16 reg;
237 
238 	mutex_lock(&wm->codec_mutex);
239 	reg = wm97xx_reg_read(wm, AC97_GPIO_POLARITY);
240 
241 	if (pol == WM97XX_GPIO_POL_HIGH)
242 		reg |= gpio;
243 	else
244 		reg &= ~gpio;
245 
246 	wm97xx_reg_write(wm, AC97_GPIO_POLARITY, reg);
247 	reg = wm97xx_reg_read(wm, AC97_GPIO_STICKY);
248 
249 	if (sticky == WM97XX_GPIO_STICKY)
250 		reg |= gpio;
251 	else
252 		reg &= ~gpio;
253 
254 	wm97xx_reg_write(wm, AC97_GPIO_STICKY, reg);
255 	reg = wm97xx_reg_read(wm, AC97_GPIO_WAKEUP);
256 
257 	if (wake == WM97XX_GPIO_WAKE)
258 		reg |= gpio;
259 	else
260 		reg &= ~gpio;
261 
262 	wm97xx_reg_write(wm, AC97_GPIO_WAKEUP, reg);
263 	reg = wm97xx_reg_read(wm, AC97_GPIO_CFG);
264 
265 	if (dir == WM97XX_GPIO_IN)
266 		reg |= gpio;
267 	else
268 		reg &= ~gpio;
269 
270 	wm97xx_reg_write(wm, AC97_GPIO_CFG, reg);
271 	mutex_unlock(&wm->codec_mutex);
272 }
273 EXPORT_SYMBOL_GPL(wm97xx_config_gpio);
274 
275 /*
276  * Configure the WM97XX_PRP value to use while system is suspended.
277  * If a value other than 0 is set then WM97xx pen detection will be
278  * left enabled in the configured mode while the system is in suspend,
279  * the device has users and suspend has not been disabled via the
280  * wakeup sysfs entries.
281  *
282  * @wm:   WM97xx device to configure
283  * @mode: WM97XX_PRP value to configure while suspended
284  */
285 void wm97xx_set_suspend_mode(struct wm97xx *wm, u16 mode)
286 {
287 	wm->suspend_mode = mode;
288 	device_init_wakeup(&wm->input_dev->dev, mode != 0);
289 }
290 EXPORT_SYMBOL_GPL(wm97xx_set_suspend_mode);
291 
292 /*
293  * Handle a pen down interrupt.
294  */
295 static void wm97xx_pen_irq_worker(struct work_struct *work)
296 {
297 	struct wm97xx *wm = container_of(work, struct wm97xx, pen_event_work);
298 	int pen_was_down = wm->pen_is_down;
299 
300 	/* do we need to enable the touch panel reader */
301 	if (wm->id == WM9705_ID2) {
302 		if (wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER_RD) &
303 					WM97XX_PEN_DOWN)
304 			wm->pen_is_down = 1;
305 		else
306 			wm->pen_is_down = 0;
307 	} else {
308 		u16 status, pol;
309 		mutex_lock(&wm->codec_mutex);
310 		status = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
311 		pol = wm97xx_reg_read(wm, AC97_GPIO_POLARITY);
312 
313 		if (WM97XX_GPIO_13 & pol & status) {
314 			wm->pen_is_down = 1;
315 			wm97xx_reg_write(wm, AC97_GPIO_POLARITY, pol &
316 						~WM97XX_GPIO_13);
317 		} else {
318 			wm->pen_is_down = 0;
319 			wm97xx_reg_write(wm, AC97_GPIO_POLARITY, pol |
320 					 WM97XX_GPIO_13);
321 		}
322 
323 		if (wm->id == WM9712_ID2 && wm->variant != WM97xx_WM1613)
324 			wm97xx_reg_write(wm, AC97_GPIO_STATUS, (status &
325 						~WM97XX_GPIO_13) << 1);
326 		else
327 			wm97xx_reg_write(wm, AC97_GPIO_STATUS, status &
328 						~WM97XX_GPIO_13);
329 		mutex_unlock(&wm->codec_mutex);
330 	}
331 
332 	/* If the system is not using continuous mode or it provides a
333 	 * pen down operation then we need to schedule polls while the
334 	 * pen is down.  Otherwise the machine driver is responsible
335 	 * for scheduling reads.
336 	 */
337 	if (!wm->mach_ops->acc_enabled || wm->mach_ops->acc_pen_down) {
338 		if (wm->pen_is_down && !pen_was_down) {
339 			/* Data is not available immediately on pen down */
340 			queue_delayed_work(wm->ts_workq, &wm->ts_reader, 1);
341 		}
342 
343 		/* Let ts_reader report the pen up for debounce. */
344 		if (!wm->pen_is_down && pen_was_down)
345 			wm->pen_is_down = 1;
346 	}
347 
348 	if (!wm->pen_is_down && wm->mach_ops->acc_enabled)
349 		wm->mach_ops->acc_pen_up(wm);
350 
351 	wm->mach_ops->irq_enable(wm, 1);
352 }
353 
354 /*
355  * Codec PENDOWN irq handler
356  *
357  * We have to disable the codec interrupt in the handler because it
358  * can take up to 1ms to clear the interrupt source. We schedule a task
359  * in a work queue to do the actual interaction with the chip.  The
360  * interrupt is then enabled again in the slow handler when the source
361  * has been cleared.
362  */
363 static irqreturn_t wm97xx_pen_interrupt(int irq, void *dev_id)
364 {
365 	struct wm97xx *wm = dev_id;
366 
367 	if (!work_pending(&wm->pen_event_work)) {
368 		wm->mach_ops->irq_enable(wm, 0);
369 		queue_work(wm->ts_workq, &wm->pen_event_work);
370 	}
371 
372 	return IRQ_HANDLED;
373 }
374 
375 /*
376  * initialise pen IRQ handler and workqueue
377  */
378 static int wm97xx_init_pen_irq(struct wm97xx *wm)
379 {
380 	u16 reg;
381 
382 	/* If an interrupt is supplied an IRQ enable operation must also be
383 	 * provided. */
384 	BUG_ON(!wm->mach_ops->irq_enable);
385 
386 	if (request_irq(wm->pen_irq, wm97xx_pen_interrupt, IRQF_SHARED,
387 			"wm97xx-pen", wm)) {
388 		dev_err(wm->dev,
389 			"Failed to register pen down interrupt, polling");
390 		wm->pen_irq = 0;
391 		return -EINVAL;
392 	}
393 
394 	/* Configure GPIO as interrupt source on WM971x */
395 	if (wm->id != WM9705_ID2) {
396 		BUG_ON(!wm->mach_ops->irq_gpio);
397 		reg = wm97xx_reg_read(wm, AC97_MISC_AFE);
398 		wm97xx_reg_write(wm, AC97_MISC_AFE,
399 				reg & ~(wm->mach_ops->irq_gpio));
400 		reg = wm97xx_reg_read(wm, 0x5a);
401 		wm97xx_reg_write(wm, 0x5a, reg & ~0x0001);
402 	}
403 
404 	return 0;
405 }
406 
407 static int wm97xx_read_samples(struct wm97xx *wm)
408 {
409 	struct wm97xx_data data;
410 	int rc;
411 
412 	mutex_lock(&wm->codec_mutex);
413 
414 	if (wm->mach_ops && wm->mach_ops->acc_enabled)
415 		rc = wm->mach_ops->acc_pen_down(wm);
416 	else
417 		rc = wm->codec->poll_touch(wm, &data);
418 
419 	if (rc & RC_PENUP) {
420 		if (wm->pen_is_down) {
421 			wm->pen_is_down = 0;
422 			dev_dbg(wm->dev, "pen up\n");
423 			input_report_abs(wm->input_dev, ABS_PRESSURE, 0);
424 			input_report_key(wm->input_dev, BTN_TOUCH, 0);
425 			input_sync(wm->input_dev);
426 		} else if (!(rc & RC_AGAIN)) {
427 			/* We need high frequency updates only while
428 			* pen is down, the user never will be able to
429 			* touch screen faster than a few times per
430 			* second... On the other hand, when the user
431 			* is actively working with the touchscreen we
432 			* don't want to lose the quick response. So we
433 			* will slowly increase sleep time after the
434 			* pen is up and quicky restore it to ~one task
435 			* switch when pen is down again.
436 			*/
437 			if (wm->ts_reader_interval < HZ / 10)
438 				wm->ts_reader_interval++;
439 		}
440 
441 	} else if (rc & RC_VALID) {
442 		dev_dbg(wm->dev,
443 			"pen down: x=%x:%d, y=%x:%d, pressure=%x:%d\n",
444 			data.x >> 12, data.x & 0xfff, data.y >> 12,
445 			data.y & 0xfff, data.p >> 12, data.p & 0xfff);
446 
447 		if (abs_x[0] > (data.x & 0xfff) ||
448 		    abs_x[1] < (data.x & 0xfff) ||
449 		    abs_y[0] > (data.y & 0xfff) ||
450 		    abs_y[1] < (data.y & 0xfff)) {
451 			dev_dbg(wm->dev, "Measurement out of range, dropping it\n");
452 			rc = RC_AGAIN;
453 			goto out;
454 		}
455 
456 		input_report_abs(wm->input_dev, ABS_X, data.x & 0xfff);
457 		input_report_abs(wm->input_dev, ABS_Y, data.y & 0xfff);
458 		input_report_abs(wm->input_dev, ABS_PRESSURE, data.p & 0xfff);
459 		input_report_key(wm->input_dev, BTN_TOUCH, 1);
460 		input_sync(wm->input_dev);
461 		wm->pen_is_down = 1;
462 		wm->ts_reader_interval = wm->ts_reader_min_interval;
463 	} else if (rc & RC_PENDOWN) {
464 		dev_dbg(wm->dev, "pen down\n");
465 		wm->pen_is_down = 1;
466 		wm->ts_reader_interval = wm->ts_reader_min_interval;
467 	}
468 
469 out:
470 	mutex_unlock(&wm->codec_mutex);
471 	return rc;
472 }
473 
474 /*
475 * The touchscreen sample reader.
476 */
477 static void wm97xx_ts_reader(struct work_struct *work)
478 {
479 	int rc;
480 	struct wm97xx *wm = container_of(work, struct wm97xx, ts_reader.work);
481 
482 	BUG_ON(!wm->codec);
483 
484 	do {
485 		rc = wm97xx_read_samples(wm);
486 	} while (rc & RC_AGAIN);
487 
488 	if (wm->pen_is_down || !wm->pen_irq)
489 		queue_delayed_work(wm->ts_workq, &wm->ts_reader,
490 				   wm->ts_reader_interval);
491 }
492 
493 /**
494  * wm97xx_ts_input_open - Open the touch screen input device.
495  * @idev:	Input device to be opened.
496  *
497  * Called by the input sub system to open a wm97xx touchscreen device.
498  * Starts the touchscreen thread and touch digitiser.
499  */
500 static int wm97xx_ts_input_open(struct input_dev *idev)
501 {
502 	struct wm97xx *wm = input_get_drvdata(idev);
503 
504 	wm->ts_workq = alloc_ordered_workqueue("kwm97xx", 0);
505 	if (wm->ts_workq == NULL) {
506 		dev_err(wm->dev,
507 			"Failed to create workqueue\n");
508 		return -EINVAL;
509 	}
510 
511 	/* start digitiser */
512 	if (wm->mach_ops && wm->mach_ops->acc_enabled)
513 		wm->codec->acc_enable(wm, 1);
514 	wm->codec->dig_enable(wm, 1);
515 
516 	INIT_DELAYED_WORK(&wm->ts_reader, wm97xx_ts_reader);
517 	INIT_WORK(&wm->pen_event_work, wm97xx_pen_irq_worker);
518 
519 	wm->ts_reader_min_interval = HZ >= 100 ? HZ / 100 : 1;
520 	if (wm->ts_reader_min_interval < 1)
521 		wm->ts_reader_min_interval = 1;
522 	wm->ts_reader_interval = wm->ts_reader_min_interval;
523 
524 	wm->pen_is_down = 0;
525 	if (wm->pen_irq)
526 		wm97xx_init_pen_irq(wm);
527 	else
528 		dev_err(wm->dev, "No IRQ specified\n");
529 
530 	/* If we either don't have an interrupt for pen down events or
531 	 * failed to acquire it then we need to poll.
532 	 */
533 	if (wm->pen_irq == 0)
534 		queue_delayed_work(wm->ts_workq, &wm->ts_reader,
535 				   wm->ts_reader_interval);
536 
537 	return 0;
538 }
539 
540 /**
541  * wm97xx_ts_input_close - Close the touch screen input device.
542  * @idev:	Input device to be closed.
543  *
544  * Called by the input sub system to close a wm97xx touchscreen
545  * device.  Kills the touchscreen thread and stops the touch
546  * digitiser.
547  */
548 
549 static void wm97xx_ts_input_close(struct input_dev *idev)
550 {
551 	struct wm97xx *wm = input_get_drvdata(idev);
552 	u16 reg;
553 
554 	if (wm->pen_irq) {
555 		/* Return the interrupt to GPIO usage (disabling it) */
556 		if (wm->id != WM9705_ID2) {
557 			BUG_ON(!wm->mach_ops->irq_gpio);
558 			reg = wm97xx_reg_read(wm, AC97_MISC_AFE);
559 			wm97xx_reg_write(wm, AC97_MISC_AFE,
560 					 reg | wm->mach_ops->irq_gpio);
561 		}
562 
563 		free_irq(wm->pen_irq, wm);
564 	}
565 
566 	wm->pen_is_down = 0;
567 
568 	/* Balance out interrupt disables/enables */
569 	if (cancel_work_sync(&wm->pen_event_work))
570 		wm->mach_ops->irq_enable(wm, 1);
571 
572 	/* ts_reader rearms itself so we need to explicitly stop it
573 	 * before we destroy the workqueue.
574 	 */
575 	cancel_delayed_work_sync(&wm->ts_reader);
576 
577 	destroy_workqueue(wm->ts_workq);
578 
579 	/* stop digitiser */
580 	wm->codec->dig_enable(wm, 0);
581 	if (wm->mach_ops && wm->mach_ops->acc_enabled)
582 		wm->codec->acc_enable(wm, 0);
583 }
584 
585 static int wm97xx_register_touch(struct wm97xx *wm)
586 {
587 	struct wm97xx_pdata *pdata = dev_get_platdata(wm->dev);
588 	int ret;
589 
590 	wm->input_dev = devm_input_allocate_device(wm->dev);
591 	if (wm->input_dev == NULL)
592 		return -ENOMEM;
593 
594 	/* set up touch configuration */
595 	wm->input_dev->name = "wm97xx touchscreen";
596 	wm->input_dev->phys = "wm97xx";
597 	wm->input_dev->open = wm97xx_ts_input_open;
598 	wm->input_dev->close = wm97xx_ts_input_close;
599 
600 	__set_bit(EV_ABS, wm->input_dev->evbit);
601 	__set_bit(EV_KEY, wm->input_dev->evbit);
602 	__set_bit(BTN_TOUCH, wm->input_dev->keybit);
603 
604 	input_set_abs_params(wm->input_dev, ABS_X, abs_x[0], abs_x[1],
605 			     abs_x[2], 0);
606 	input_set_abs_params(wm->input_dev, ABS_Y, abs_y[0], abs_y[1],
607 			     abs_y[2], 0);
608 	input_set_abs_params(wm->input_dev, ABS_PRESSURE, abs_p[0], abs_p[1],
609 			     abs_p[2], 0);
610 
611 	input_set_drvdata(wm->input_dev, wm);
612 	wm->input_dev->dev.parent = wm->dev;
613 
614 	ret = input_register_device(wm->input_dev);
615 	if (ret)
616 		return ret;
617 
618 	/*
619 	 * register our extended touch device (for machine specific
620 	 * extensions)
621 	 */
622 	wm->touch_dev = platform_device_alloc("wm97xx-touch", -1);
623 	if (!wm->touch_dev) {
624 		ret = -ENOMEM;
625 		goto touch_err;
626 	}
627 	platform_set_drvdata(wm->touch_dev, wm);
628 	wm->touch_dev->dev.parent = wm->dev;
629 	wm->touch_dev->dev.platform_data = pdata;
630 	ret = platform_device_add(wm->touch_dev);
631 	if (ret < 0)
632 		goto touch_reg_err;
633 
634 	return 0;
635 touch_reg_err:
636 	platform_device_put(wm->touch_dev);
637 touch_err:
638 	input_unregister_device(wm->input_dev);
639 	wm->input_dev = NULL;
640 
641 	return ret;
642 }
643 
644 static void wm97xx_unregister_touch(struct wm97xx *wm)
645 {
646 	platform_device_unregister(wm->touch_dev);
647 	input_unregister_device(wm->input_dev);
648 	wm->input_dev = NULL;
649 }
650 
651 static int _wm97xx_probe(struct wm97xx *wm)
652 {
653 	int id = 0;
654 
655 	mutex_init(&wm->codec_mutex);
656 	dev_set_drvdata(wm->dev, wm);
657 
658 	/* check that we have a supported codec */
659 	id = wm97xx_reg_read(wm, AC97_VENDOR_ID1);
660 	if (id != WM97XX_ID1) {
661 		dev_err(wm->dev,
662 			"Device with vendor %04x is not a wm97xx\n", id);
663 		return -ENODEV;
664 	}
665 
666 	wm->id = wm97xx_reg_read(wm, AC97_VENDOR_ID2);
667 
668 	wm->variant = WM97xx_GENERIC;
669 
670 	dev_info(wm->dev, "detected a wm97%02x codec\n", wm->id & 0xff);
671 
672 	switch (wm->id & 0xff) {
673 #ifdef CONFIG_TOUCHSCREEN_WM9705
674 	case 0x05:
675 		wm->codec = &wm9705_codec;
676 		break;
677 #endif
678 #ifdef CONFIG_TOUCHSCREEN_WM9712
679 	case 0x12:
680 		wm->codec = &wm9712_codec;
681 		break;
682 #endif
683 #ifdef CONFIG_TOUCHSCREEN_WM9713
684 	case 0x13:
685 		wm->codec = &wm9713_codec;
686 		break;
687 #endif
688 	default:
689 		dev_err(wm->dev, "Support for wm97%02x not compiled in.\n",
690 			wm->id & 0xff);
691 		return -ENODEV;
692 	}
693 
694 	/* set up physical characteristics */
695 	wm->codec->phy_init(wm);
696 
697 	/* load gpio cache */
698 	wm->gpio[0] = wm97xx_reg_read(wm, AC97_GPIO_CFG);
699 	wm->gpio[1] = wm97xx_reg_read(wm, AC97_GPIO_POLARITY);
700 	wm->gpio[2] = wm97xx_reg_read(wm, AC97_GPIO_STICKY);
701 	wm->gpio[3] = wm97xx_reg_read(wm, AC97_GPIO_WAKEUP);
702 	wm->gpio[4] = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
703 	wm->gpio[5] = wm97xx_reg_read(wm, AC97_MISC_AFE);
704 
705 	return wm97xx_register_touch(wm);
706 }
707 
708 static void wm97xx_remove_battery(struct wm97xx *wm)
709 {
710 	platform_device_unregister(wm->battery_dev);
711 }
712 
713 static int wm97xx_add_battery(struct wm97xx *wm,
714 			      struct wm97xx_batt_pdata *pdata)
715 {
716 	int ret;
717 
718 	wm->battery_dev = platform_device_alloc("wm97xx-battery", -1);
719 	if (!wm->battery_dev)
720 		return -ENOMEM;
721 
722 	platform_set_drvdata(wm->battery_dev, wm);
723 	wm->battery_dev->dev.parent = wm->dev;
724 	wm->battery_dev->dev.platform_data = pdata;
725 	ret = platform_device_add(wm->battery_dev);
726 	if (ret)
727 		platform_device_put(wm->battery_dev);
728 
729 	return ret;
730 }
731 
732 static int wm97xx_probe(struct device *dev)
733 {
734 	struct wm97xx *wm;
735 	int ret;
736 	struct wm97xx_pdata *pdata = dev_get_platdata(dev);
737 
738 	wm = devm_kzalloc(dev, sizeof(struct wm97xx), GFP_KERNEL);
739 	if (!wm)
740 		return -ENOMEM;
741 
742 	wm->dev = dev;
743 	wm->ac97 = to_ac97_t(dev);
744 
745 	ret =  _wm97xx_probe(wm);
746 	if (ret)
747 		return ret;
748 
749 	ret = wm97xx_add_battery(wm, pdata ? pdata->batt_pdata : NULL);
750 	if (ret < 0)
751 		goto batt_err;
752 
753 	return ret;
754 
755 batt_err:
756 	wm97xx_unregister_touch(wm);
757 	return ret;
758 }
759 
760 static int wm97xx_remove(struct device *dev)
761 {
762 	struct wm97xx *wm = dev_get_drvdata(dev);
763 
764 	wm97xx_remove_battery(wm);
765 	wm97xx_unregister_touch(wm);
766 
767 	return 0;
768 }
769 
770 static int wm97xx_mfd_probe(struct platform_device *pdev)
771 {
772 	struct wm97xx *wm;
773 	struct wm97xx_platform_data *mfd_pdata = dev_get_platdata(&pdev->dev);
774 	int ret;
775 
776 	wm = devm_kzalloc(&pdev->dev, sizeof(struct wm97xx), GFP_KERNEL);
777 	if (!wm)
778 		return -ENOMEM;
779 
780 	wm->dev = &pdev->dev;
781 	wm->ac97 = mfd_pdata->ac97;
782 
783 	ret =  _wm97xx_probe(wm);
784 	if (ret)
785 		return ret;
786 
787 	ret = wm97xx_add_battery(wm, mfd_pdata->batt_pdata);
788 	if (ret < 0)
789 		goto batt_err;
790 
791 	return ret;
792 
793 batt_err:
794 	wm97xx_unregister_touch(wm);
795 	return ret;
796 }
797 
798 static int wm97xx_mfd_remove(struct platform_device *pdev)
799 {
800 	return wm97xx_remove(&pdev->dev);
801 }
802 
803 static int __maybe_unused wm97xx_suspend(struct device *dev)
804 {
805 	struct wm97xx *wm = dev_get_drvdata(dev);
806 	u16 reg;
807 	int suspend_mode;
808 
809 	if (device_may_wakeup(&wm->input_dev->dev))
810 		suspend_mode = wm->suspend_mode;
811 	else
812 		suspend_mode = 0;
813 
814 	if (wm->input_dev->users)
815 		cancel_delayed_work_sync(&wm->ts_reader);
816 
817 	/* Power down the digitiser (bypassing the cache for resume) */
818 	reg = wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER2);
819 	reg &= ~WM97XX_PRP_DET_DIG;
820 	if (wm->input_dev->users)
821 		reg |= suspend_mode;
822 	wm->ac97->bus->ops->write(wm->ac97, AC97_WM97XX_DIGITISER2, reg);
823 
824 	/* WM9713 has an additional power bit - turn it off if there
825 	 * are no users or if suspend mode is zero. */
826 	if (wm->id == WM9713_ID2 &&
827 	    (!wm->input_dev->users || !suspend_mode)) {
828 		reg = wm97xx_reg_read(wm, AC97_EXTENDED_MID) | 0x8000;
829 		wm97xx_reg_write(wm, AC97_EXTENDED_MID, reg);
830 	}
831 
832 	return 0;
833 }
834 
835 static int __maybe_unused wm97xx_resume(struct device *dev)
836 {
837 	struct wm97xx *wm = dev_get_drvdata(dev);
838 
839 	/* restore digitiser and gpios */
840 	if (wm->id == WM9713_ID2) {
841 		wm97xx_reg_write(wm, AC97_WM9713_DIG1, wm->dig[0]);
842 		wm97xx_reg_write(wm, 0x5a, wm->misc);
843 		if (wm->input_dev->users) {
844 			u16 reg;
845 			reg = wm97xx_reg_read(wm, AC97_EXTENDED_MID) & 0x7fff;
846 			wm97xx_reg_write(wm, AC97_EXTENDED_MID, reg);
847 		}
848 	}
849 
850 	wm97xx_reg_write(wm, AC97_WM9713_DIG2, wm->dig[1]);
851 	wm97xx_reg_write(wm, AC97_WM9713_DIG3, wm->dig[2]);
852 
853 	wm97xx_reg_write(wm, AC97_GPIO_CFG, wm->gpio[0]);
854 	wm97xx_reg_write(wm, AC97_GPIO_POLARITY, wm->gpio[1]);
855 	wm97xx_reg_write(wm, AC97_GPIO_STICKY, wm->gpio[2]);
856 	wm97xx_reg_write(wm, AC97_GPIO_WAKEUP, wm->gpio[3]);
857 	wm97xx_reg_write(wm, AC97_GPIO_STATUS, wm->gpio[4]);
858 	wm97xx_reg_write(wm, AC97_MISC_AFE, wm->gpio[5]);
859 
860 	if (wm->input_dev->users && !wm->pen_irq) {
861 		wm->ts_reader_interval = wm->ts_reader_min_interval;
862 		queue_delayed_work(wm->ts_workq, &wm->ts_reader,
863 				   wm->ts_reader_interval);
864 	}
865 
866 	return 0;
867 }
868 
869 static SIMPLE_DEV_PM_OPS(wm97xx_pm_ops, wm97xx_suspend, wm97xx_resume);
870 
871 /*
872  * Machine specific operations
873  */
874 int wm97xx_register_mach_ops(struct wm97xx *wm,
875 			     struct wm97xx_mach_ops *mach_ops)
876 {
877 	mutex_lock(&wm->codec_mutex);
878 	if (wm->mach_ops) {
879 		mutex_unlock(&wm->codec_mutex);
880 		return -EINVAL;
881 	}
882 	wm->mach_ops = mach_ops;
883 	mutex_unlock(&wm->codec_mutex);
884 
885 	return 0;
886 }
887 EXPORT_SYMBOL_GPL(wm97xx_register_mach_ops);
888 
889 void wm97xx_unregister_mach_ops(struct wm97xx *wm)
890 {
891 	mutex_lock(&wm->codec_mutex);
892 	wm->mach_ops = NULL;
893 	mutex_unlock(&wm->codec_mutex);
894 }
895 EXPORT_SYMBOL_GPL(wm97xx_unregister_mach_ops);
896 
897 static struct device_driver wm97xx_driver = {
898 	.name =		"wm97xx-ts",
899 #ifdef CONFIG_AC97_BUS
900 	.bus =		&ac97_bus_type,
901 #endif
902 	.owner =	THIS_MODULE,
903 	.probe =	wm97xx_probe,
904 	.remove =	wm97xx_remove,
905 	.pm =		&wm97xx_pm_ops,
906 };
907 
908 static struct platform_driver wm97xx_mfd_driver = {
909 	.driver = {
910 		.name =		"wm97xx-ts",
911 		.pm =		&wm97xx_pm_ops,
912 	},
913 	.probe =	wm97xx_mfd_probe,
914 	.remove =	wm97xx_mfd_remove,
915 };
916 
917 static int __init wm97xx_init(void)
918 {
919 	int ret;
920 
921 	ret = platform_driver_register(&wm97xx_mfd_driver);
922 	if (ret)
923 		return ret;
924 
925 	if (IS_BUILTIN(CONFIG_AC97_BUS))
926 		ret =  driver_register(&wm97xx_driver);
927 	return ret;
928 }
929 
930 static void __exit wm97xx_exit(void)
931 {
932 	if (IS_BUILTIN(CONFIG_AC97_BUS))
933 		driver_unregister(&wm97xx_driver);
934 	platform_driver_unregister(&wm97xx_mfd_driver);
935 }
936 
937 module_init(wm97xx_init);
938 module_exit(wm97xx_exit);
939 
940 /* Module information */
941 MODULE_AUTHOR("Liam Girdwood <lrg@slimlogic.co.uk>");
942 MODULE_DESCRIPTION("WM97xx Core - Touch Screen / AUX ADC / GPIO Driver");
943 MODULE_LICENSE("GPL");
944