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