wm8994-core.c revision d6c645fc00777a6f8a7df1f580065ec30c71be7b 
1/*
2 * wm8994-core.c  --  Device access for Wolfson WM8994
3 *
4 * Copyright 2009 Wolfson Microelectronics PLC.
5 *
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7 *
8 *  This program is free software; you can redistribute  it and/or modify it
9 *  under  the terms of  the GNU General  Public License as published by the
10 *  Free Software Foundation;  either version 2 of the  License, or (at your
11 *  option) any later version.
12 *
13 */
14
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/slab.h>
18#include <linux/i2c.h>
19#include <linux/err.h>
20#include <linux/delay.h>
21#include <linux/mfd/core.h>
22#include <linux/pm_runtime.h>
23#include <linux/regmap.h>
24#include <linux/regulator/consumer.h>
25#include <linux/regulator/machine.h>
26
27#include <linux/mfd/wm8994/core.h>
28#include <linux/mfd/wm8994/pdata.h>
29#include <linux/mfd/wm8994/registers.h>
30
31static int wm8994_read(struct wm8994 *wm8994, unsigned short reg,
32		       int bytes, void *dest)
33{
34	return regmap_raw_read(wm8994->regmap, reg, dest, bytes);
35}
36
37/**
38 * wm8994_reg_read: Read a single WM8994 register.
39 *
40 * @wm8994: Device to read from.
41 * @reg: Register to read.
42 */
43int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
44{
45	unsigned int val;
46	int ret;
47
48	ret = regmap_read(wm8994->regmap, reg, &val);
49
50	if (ret < 0)
51		return ret;
52	else
53		return val;
54}
55EXPORT_SYMBOL_GPL(wm8994_reg_read);
56
57/**
58 * wm8994_bulk_read: Read multiple WM8994 registers
59 *
60 * @wm8994: Device to read from
61 * @reg: First register
62 * @count: Number of registers
63 * @buf: Buffer to fill.  The data will be returned big endian.
64 */
65int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
66		     int count, u16 *buf)
67{
68	return regmap_bulk_read(wm8994->regmap, reg, buf, count);
69}
70
71static int wm8994_write(struct wm8994 *wm8994, unsigned short reg,
72			int bytes, const void *src)
73{
74	return regmap_raw_write(wm8994->regmap, reg, src, bytes);
75}
76
77/**
78 * wm8994_reg_write: Write a single WM8994 register.
79 *
80 * @wm8994: Device to write to.
81 * @reg: Register to write to.
82 * @val: Value to write.
83 */
84int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
85		     unsigned short val)
86{
87	return regmap_write(wm8994->regmap, reg, val);
88}
89EXPORT_SYMBOL_GPL(wm8994_reg_write);
90
91/**
92 * wm8994_bulk_write: Write multiple WM8994 registers
93 *
94 * @wm8994: Device to write to
95 * @reg: First register
96 * @count: Number of registers
97 * @buf: Buffer to write from.  Data must be big-endian formatted.
98 */
99int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
100		      int count, const u16 *buf)
101{
102	return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16));
103}
104EXPORT_SYMBOL_GPL(wm8994_bulk_write);
105
106/**
107 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
108 *
109 * @wm8994: Device to write to.
110 * @reg: Register to write to.
111 * @mask: Mask of bits to set.
112 * @val: Value to set (unshifted)
113 */
114int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
115		    unsigned short mask, unsigned short val)
116{
117	return regmap_update_bits(wm8994->regmap, reg, mask, val);
118}
119EXPORT_SYMBOL_GPL(wm8994_set_bits);
120
121static struct mfd_cell wm8994_regulator_devs[] = {
122	{
123		.name = "wm8994-ldo",
124		.id = 1,
125		.pm_runtime_no_callbacks = true,
126	},
127	{
128		.name = "wm8994-ldo",
129		.id = 2,
130		.pm_runtime_no_callbacks = true,
131	},
132};
133
134static struct resource wm8994_codec_resources[] = {
135	{
136		.start = WM8994_IRQ_TEMP_SHUT,
137		.end   = WM8994_IRQ_TEMP_WARN,
138		.flags = IORESOURCE_IRQ,
139	},
140};
141
142static struct resource wm8994_gpio_resources[] = {
143	{
144		.start = WM8994_IRQ_GPIO(1),
145		.end   = WM8994_IRQ_GPIO(11),
146		.flags = IORESOURCE_IRQ,
147	},
148};
149
150static struct mfd_cell wm8994_devs[] = {
151	{
152		.name = "wm8994-codec",
153		.num_resources = ARRAY_SIZE(wm8994_codec_resources),
154		.resources = wm8994_codec_resources,
155	},
156
157	{
158		.name = "wm8994-gpio",
159		.num_resources = ARRAY_SIZE(wm8994_gpio_resources),
160		.resources = wm8994_gpio_resources,
161		.pm_runtime_no_callbacks = true,
162	},
163};
164
165/*
166 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
167 * and should be handled via the standard regulator API supply
168 * management.
169 */
170static const char *wm8994_main_supplies[] = {
171	"DBVDD",
172	"DCVDD",
173	"AVDD1",
174	"AVDD2",
175	"CPVDD",
176	"SPKVDD1",
177	"SPKVDD2",
178};
179
180static const char *wm8958_main_supplies[] = {
181	"DBVDD1",
182	"DBVDD2",
183	"DBVDD3",
184	"DCVDD",
185	"AVDD1",
186	"AVDD2",
187	"CPVDD",
188	"SPKVDD1",
189	"SPKVDD2",
190};
191
192#ifdef CONFIG_PM
193static int wm8994_suspend(struct device *dev)
194{
195	struct wm8994 *wm8994 = dev_get_drvdata(dev);
196	int ret;
197
198	/* Don't actually go through with the suspend if the CODEC is
199	 * still active (eg, for audio passthrough from CP. */
200	ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
201	if (ret < 0) {
202		dev_err(dev, "Failed to read power status: %d\n", ret);
203	} else if (ret & WM8994_VMID_SEL_MASK) {
204		dev_dbg(dev, "CODEC still active, ignoring suspend\n");
205		return 0;
206	}
207
208	/* GPIO configuration state is saved here since we may be configuring
209	 * the GPIO alternate functions even if we're not using the gpiolib
210	 * driver for them.
211	 */
212	ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
213			  &wm8994->gpio_regs);
214	if (ret < 0)
215		dev_err(dev, "Failed to save GPIO registers: %d\n", ret);
216
217	/* For similar reasons we also stash the regulator states */
218	ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
219			  &wm8994->ldo_regs);
220	if (ret < 0)
221		dev_err(dev, "Failed to save LDO registers: %d\n", ret);
222
223	/* Explicitly put the device into reset in case regulators
224	 * don't get disabled in order to ensure consistent restart.
225	 */
226	wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 0x8994);
227
228	wm8994->suspended = true;
229
230	ret = regulator_bulk_disable(wm8994->num_supplies,
231				     wm8994->supplies);
232	if (ret != 0) {
233		dev_err(dev, "Failed to disable supplies: %d\n", ret);
234		return ret;
235	}
236
237	return 0;
238}
239
240static int wm8994_resume(struct device *dev)
241{
242	struct wm8994 *wm8994 = dev_get_drvdata(dev);
243	int ret, i;
244
245	/* We may have lied to the PM core about suspending */
246	if (!wm8994->suspended)
247		return 0;
248
249	ret = regulator_bulk_enable(wm8994->num_supplies,
250				    wm8994->supplies);
251	if (ret != 0) {
252		dev_err(dev, "Failed to enable supplies: %d\n", ret);
253		return ret;
254	}
255
256	/* Write register at a time as we use the cache on the CPU so store
257	 * it in native endian.
258	 */
259	for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
260		ret = wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK
261				       + i, wm8994->irq_masks_cur[i]);
262		if (ret < 0)
263			dev_err(dev, "Failed to restore interrupt masks: %d\n",
264				ret);
265	}
266
267	ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
268			   &wm8994->ldo_regs);
269	if (ret < 0)
270		dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
271
272	ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
273			   &wm8994->gpio_regs);
274	if (ret < 0)
275		dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
276
277	wm8994->suspended = false;
278
279	return 0;
280}
281#endif
282
283#ifdef CONFIG_REGULATOR
284static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
285{
286	struct wm8994_ldo_pdata *ldo_pdata;
287
288	if (!pdata)
289		return 0;
290
291	ldo_pdata = &pdata->ldo[ldo];
292
293	if (!ldo_pdata->init_data)
294		return 0;
295
296	return ldo_pdata->init_data->num_consumer_supplies != 0;
297}
298#else
299static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
300{
301	return 0;
302}
303#endif
304
305static struct regmap_config wm8994_regmap_config = {
306	.reg_bits = 16,
307	.val_bits = 16,
308};
309
310/*
311 * Instantiate the generic non-control parts of the device.
312 */
313static int wm8994_device_init(struct wm8994 *wm8994, int irq)
314{
315	struct wm8994_pdata *pdata = wm8994->dev->platform_data;
316	const char *devname;
317	int ret, i;
318
319	dev_set_drvdata(wm8994->dev, wm8994);
320
321	/* Add the on-chip regulators first for bootstrapping */
322	ret = mfd_add_devices(wm8994->dev, -1,
323			      wm8994_regulator_devs,
324			      ARRAY_SIZE(wm8994_regulator_devs),
325			      NULL, 0);
326	if (ret != 0) {
327		dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
328		goto err_regmap;
329	}
330
331	switch (wm8994->type) {
332	case WM8994:
333		wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
334		break;
335	case WM8958:
336		wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
337		break;
338	default:
339		BUG();
340		goto err_regmap;
341	}
342
343	wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
344				   wm8994->num_supplies,
345				   GFP_KERNEL);
346	if (!wm8994->supplies) {
347		ret = -ENOMEM;
348		goto err_regmap;
349	}
350
351	switch (wm8994->type) {
352	case WM8994:
353		for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
354			wm8994->supplies[i].supply = wm8994_main_supplies[i];
355		break;
356	case WM8958:
357		for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
358			wm8994->supplies[i].supply = wm8958_main_supplies[i];
359		break;
360	default:
361		BUG();
362		goto err_regmap;
363	}
364
365	ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
366				 wm8994->supplies);
367	if (ret != 0) {
368		dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
369		goto err_supplies;
370	}
371
372	ret = regulator_bulk_enable(wm8994->num_supplies,
373				    wm8994->supplies);
374	if (ret != 0) {
375		dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
376		goto err_get;
377	}
378
379	ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
380	if (ret < 0) {
381		dev_err(wm8994->dev, "Failed to read ID register\n");
382		goto err_enable;
383	}
384	switch (ret) {
385	case 0x8994:
386		devname = "WM8994";
387		if (wm8994->type != WM8994)
388			dev_warn(wm8994->dev, "Device registered as type %d\n",
389				 wm8994->type);
390		wm8994->type = WM8994;
391		break;
392	case 0x8958:
393		devname = "WM8958";
394		if (wm8994->type != WM8958)
395			dev_warn(wm8994->dev, "Device registered as type %d\n",
396				 wm8994->type);
397		wm8994->type = WM8958;
398		break;
399	default:
400		dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
401			ret);
402		ret = -EINVAL;
403		goto err_enable;
404	}
405
406	ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
407	if (ret < 0) {
408		dev_err(wm8994->dev, "Failed to read revision register: %d\n",
409			ret);
410		goto err_enable;
411	}
412
413	switch (wm8994->type) {
414	case WM8994:
415		switch (ret) {
416		case 0:
417		case 1:
418			dev_warn(wm8994->dev,
419				 "revision %c not fully supported\n",
420				 'A' + ret);
421			break;
422		default:
423			break;
424		}
425		break;
426	default:
427		break;
428	}
429
430	dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
431
432	if (pdata) {
433		wm8994->irq_base = pdata->irq_base;
434		wm8994->gpio_base = pdata->gpio_base;
435
436		/* GPIO configuration is only applied if it's non-zero */
437		for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
438			if (pdata->gpio_defaults[i]) {
439				wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
440						0xffff,
441						pdata->gpio_defaults[i]);
442			}
443		}
444	}
445
446	/* In some system designs where the regulators are not in use,
447	 * we can achieve a small reduction in leakage currents by
448	 * floating LDO outputs.  This bit makes no difference if the
449	 * LDOs are enabled, it only affects cases where the LDOs were
450	 * in operation and are then disabled.
451	 */
452	for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
453		if (wm8994_ldo_in_use(pdata, i))
454			wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
455					WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
456		else
457			wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
458					WM8994_LDO1_DISCH, 0);
459	}
460
461	wm8994_irq_init(wm8994);
462
463	ret = mfd_add_devices(wm8994->dev, -1,
464			      wm8994_devs, ARRAY_SIZE(wm8994_devs),
465			      NULL, 0);
466	if (ret != 0) {
467		dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
468		goto err_irq;
469	}
470
471	pm_runtime_enable(wm8994->dev);
472	pm_runtime_resume(wm8994->dev);
473
474	return 0;
475
476err_irq:
477	wm8994_irq_exit(wm8994);
478err_enable:
479	regulator_bulk_disable(wm8994->num_supplies,
480			       wm8994->supplies);
481err_get:
482	regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
483err_supplies:
484	kfree(wm8994->supplies);
485err_regmap:
486	regmap_exit(wm8994->regmap);
487	mfd_remove_devices(wm8994->dev);
488	kfree(wm8994);
489	return ret;
490}
491
492static void wm8994_device_exit(struct wm8994 *wm8994)
493{
494	pm_runtime_disable(wm8994->dev);
495	mfd_remove_devices(wm8994->dev);
496	wm8994_irq_exit(wm8994);
497	regulator_bulk_disable(wm8994->num_supplies,
498			       wm8994->supplies);
499	regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
500	kfree(wm8994->supplies);
501	regmap_exit(wm8994->regmap);
502	kfree(wm8994);
503}
504
505static int wm8994_i2c_probe(struct i2c_client *i2c,
506			    const struct i2c_device_id *id)
507{
508	struct wm8994 *wm8994;
509	int ret;
510
511	wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
512	if (wm8994 == NULL)
513		return -ENOMEM;
514
515	i2c_set_clientdata(i2c, wm8994);
516	wm8994->dev = &i2c->dev;
517	wm8994->irq = i2c->irq;
518	wm8994->type = id->driver_data;
519
520	wm8994->regmap = regmap_init_i2c(i2c, &wm8994_regmap_config);
521	if (IS_ERR(wm8994->regmap)) {
522		ret = PTR_ERR(wm8994->regmap);
523		dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
524			ret);
525		kfree(wm8994);
526		return ret;
527	}
528
529	return wm8994_device_init(wm8994, i2c->irq);
530}
531
532static int wm8994_i2c_remove(struct i2c_client *i2c)
533{
534	struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
535
536	wm8994_device_exit(wm8994);
537
538	return 0;
539}
540
541static const struct i2c_device_id wm8994_i2c_id[] = {
542	{ "wm8994", WM8994 },
543	{ "wm8958", WM8958 },
544	{ }
545};
546MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
547
548static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
549			    NULL);
550
551static struct i2c_driver wm8994_i2c_driver = {
552	.driver = {
553		.name = "wm8994",
554		.owner = THIS_MODULE,
555		.pm = &wm8994_pm_ops,
556	},
557	.probe = wm8994_i2c_probe,
558	.remove = wm8994_i2c_remove,
559	.id_table = wm8994_i2c_id,
560};
561
562static int __init wm8994_i2c_init(void)
563{
564	int ret;
565
566	ret = i2c_add_driver(&wm8994_i2c_driver);
567	if (ret != 0)
568		pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
569
570	return ret;
571}
572module_init(wm8994_i2c_init);
573
574static void __exit wm8994_i2c_exit(void)
575{
576	i2c_del_driver(&wm8994_i2c_driver);
577}
578module_exit(wm8994_i2c_exit);
579
580MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
581MODULE_LICENSE("GPL");
582MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
583