blob: c8956f2cd28064d137e23a6fa814a477e8fe95c2 [file] [log] [blame]
Mark Brown9e501082010-01-29 18:20:29 +00001/*
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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Mark Brown9e501082010-01-29 18:20:29 +000018#include <linux/i2c.h>
Mark Brownd6c645fc2011-06-17 13:02:27 +010019#include <linux/err.h>
Mark Brown9e501082010-01-29 18:20:29 +000020#include <linux/delay.h>
21#include <linux/mfd/core.h>
Mark Brownd450f192010-11-26 17:19:35 +000022#include <linux/pm_runtime.h>
Mark Brownd6c645fc2011-06-17 13:02:27 +010023#include <linux/regmap.h>
Mark Brown9e501082010-01-29 18:20:29 +000024#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{
Mark Brownd6c645fc2011-06-17 13:02:27 +010034 return regmap_raw_read(wm8994->regmap, reg, dest, bytes);
Mark Brown9e501082010-01-29 18:20:29 +000035}
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{
Mark Brownd6c645fc2011-06-17 13:02:27 +010045 unsigned int val;
Mark Brown9e501082010-01-29 18:20:29 +000046 int ret;
47
Mark Brownd6c645fc2011-06-17 13:02:27 +010048 ret = regmap_read(wm8994->regmap, reg, &val);
Mark Brown9e501082010-01-29 18:20:29 +000049
50 if (ret < 0)
51 return ret;
52 else
Mark Brownd6c645fc2011-06-17 13:02:27 +010053 return val;
Mark Brown9e501082010-01-29 18:20:29 +000054}
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
Mark Brown316b6cc2011-03-18 12:50:10 +000063 * @buf: Buffer to fill. The data will be returned big endian.
Mark Brown9e501082010-01-29 18:20:29 +000064 */
65int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
66 int count, u16 *buf)
67{
Mark Brownd6c645fc2011-06-17 13:02:27 +010068 return regmap_bulk_read(wm8994->regmap, reg, buf, count);
Mark Brown9e501082010-01-29 18:20:29 +000069}
Mark Brown9e501082010-01-29 18:20:29 +000070
71static int wm8994_write(struct wm8994 *wm8994, unsigned short reg,
Mark Brown07e73fb2011-03-17 21:42:30 +000072 int bytes, const void *src)
Mark Brown9e501082010-01-29 18:20:29 +000073{
Mark Brownd6c645fc2011-06-17 13:02:27 +010074 return regmap_raw_write(wm8994->regmap, reg, src, bytes);
Mark Brown9e501082010-01-29 18:20:29 +000075}
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{
Mark Brownd6c645fc2011-06-17 13:02:27 +010087 return regmap_write(wm8994->regmap, reg, val);
Mark Brown9e501082010-01-29 18:20:29 +000088}
89EXPORT_SYMBOL_GPL(wm8994_reg_write);
90
91/**
Mark Browne93c5382011-03-10 13:54:07 +000092 * wm8994_bulk_write: Write multiple WM8994 registers
93 *
94 * @wm8994: Device to write to
95 * @reg: First register
96 * @count: Number of registers
Mark Brown42771632011-03-17 21:42:29 +000097 * @buf: Buffer to write from. Data must be big-endian formatted.
Mark Browne93c5382011-03-10 13:54:07 +000098 */
99int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
Mark Brown07e73fb2011-03-17 21:42:30 +0000100 int count, const u16 *buf)
Mark Browne93c5382011-03-10 13:54:07 +0000101{
Mark Brownd6c645fc2011-06-17 13:02:27 +0100102 return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16));
Mark Browne93c5382011-03-10 13:54:07 +0000103}
104EXPORT_SYMBOL_GPL(wm8994_bulk_write);
105
106/**
Mark Brown9e501082010-01-29 18:20:29 +0000107 * 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{
Mark Brownd6c645fc2011-06-17 13:02:27 +0100117 return regmap_update_bits(wm8994->regmap, reg, mask, val);
Mark Brown9e501082010-01-29 18:20:29 +0000118}
119EXPORT_SYMBOL_GPL(wm8994_set_bits);
120
121static struct mfd_cell wm8994_regulator_devs[] = {
Mark Brownd450f192010-11-26 17:19:35 +0000122 {
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 },
Mark Brown9e501082010-01-29 18:20:29 +0000132};
133
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000134static 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
Mark Brown9e501082010-01-29 18:20:29 +0000150static struct mfd_cell wm8994_devs[] = {
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000151 {
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,
Mark Brownd450f192010-11-26 17:19:35 +0000161 .pm_runtime_no_callbacks = true,
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000162 },
Mark Brown9e501082010-01-29 18:20:29 +0000163};
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 */
Mark Brownb1f43bf2011-05-24 17:35:40 +0800170static const char *wm1811_main_supplies[] = {
171 "DBVDD1",
172 "DBVDD2",
173 "DBVDD3",
174 "DCVDD",
175 "AVDD1",
176 "AVDD2",
177 "CPVDD",
178 "SPKVDD1",
179 "SPKVDD2",
180};
181
Mark Brown9e501082010-01-29 18:20:29 +0000182static const char *wm8994_main_supplies[] = {
183 "DBVDD",
184 "DCVDD",
185 "AVDD1",
186 "AVDD2",
187 "CPVDD",
188 "SPKVDD1",
189 "SPKVDD2",
190};
191
Mark Brown559e0df2010-08-31 19:25:12 +0100192static const char *wm8958_main_supplies[] = {
193 "DBVDD1",
194 "DBVDD2",
195 "DBVDD3",
196 "DCVDD",
197 "AVDD1",
198 "AVDD2",
199 "CPVDD",
200 "SPKVDD1",
201 "SPKVDD2",
202};
203
Mark Brown9e501082010-01-29 18:20:29 +0000204#ifdef CONFIG_PM
Mark Brownd450f192010-11-26 17:19:35 +0000205static int wm8994_suspend(struct device *dev)
Mark Brown9e501082010-01-29 18:20:29 +0000206{
207 struct wm8994 *wm8994 = dev_get_drvdata(dev);
208 int ret;
209
Mark Brown77bd70e2011-02-04 14:57:43 +0000210 /* Don't actually go through with the suspend if the CODEC is
211 * still active (eg, for audio passthrough from CP. */
212 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
213 if (ret < 0) {
214 dev_err(dev, "Failed to read power status: %d\n", ret);
215 } else if (ret & WM8994_VMID_SEL_MASK) {
216 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
217 return 0;
218 }
219
Mark Brown5f40c6b2011-08-13 14:37:48 +0900220 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_4);
221 if (ret < 0) {
222 dev_err(dev, "Failed to read power status: %d\n", ret);
223 } else if (ret & (WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA |
224 WM8994_AIF1ADC2L_ENA | WM8994_AIF1ADC2R_ENA |
225 WM8994_AIF1ADC1L_ENA | WM8994_AIF1ADC1R_ENA)) {
226 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
227 return 0;
228 }
229
230 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_5);
231 if (ret < 0) {
232 dev_err(dev, "Failed to read power status: %d\n", ret);
233 } else if (ret & (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA |
234 WM8994_AIF1DAC2L_ENA | WM8994_AIF1DAC2R_ENA |
235 WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA)) {
236 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
237 return 0;
238 }
239
240 switch (wm8994->type) {
241 case WM8958:
242 ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1);
243 if (ret < 0) {
244 dev_err(dev, "Failed to read power status: %d\n", ret);
245 } else if (ret & WM8958_MICD_ENA) {
246 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
247 return 0;
248 }
249 break;
250 default:
251 break;
252 }
253
Mark Brown881de672011-08-22 15:43:55 +0200254 /* Disable LDO pulldowns while the device is suspended if we
255 * don't know that something will be driving them. */
256 if (!wm8994->ldo_ena_always_driven)
257 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
258 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
259 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD);
260
Mark Brown9e501082010-01-29 18:20:29 +0000261 /* GPIO configuration state is saved here since we may be configuring
262 * the GPIO alternate functions even if we're not using the gpiolib
263 * driver for them.
264 */
265 ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
266 &wm8994->gpio_regs);
267 if (ret < 0)
268 dev_err(dev, "Failed to save GPIO registers: %d\n", ret);
269
270 /* For similar reasons we also stash the regulator states */
271 ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
272 &wm8994->ldo_regs);
273 if (ret < 0)
274 dev_err(dev, "Failed to save LDO registers: %d\n", ret);
275
Mark Brownf40dff92011-02-21 18:30:31 +0000276 /* Explicitly put the device into reset in case regulators
277 * don't get disabled in order to ensure consistent restart.
278 */
279 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 0x8994);
280
Mark Brown77bd70e2011-02-04 14:57:43 +0000281 wm8994->suspended = true;
282
Mark Brown559e0df2010-08-31 19:25:12 +0100283 ret = regulator_bulk_disable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000284 wm8994->supplies);
285 if (ret != 0) {
286 dev_err(dev, "Failed to disable supplies: %d\n", ret);
287 return ret;
288 }
289
290 return 0;
291}
292
Mark Brownd450f192010-11-26 17:19:35 +0000293static int wm8994_resume(struct device *dev)
Mark Brown9e501082010-01-29 18:20:29 +0000294{
295 struct wm8994 *wm8994 = dev_get_drvdata(dev);
Mark Brown98ae1cc2011-06-07 11:49:42 +0100296 int ret, i;
Mark Brown9e501082010-01-29 18:20:29 +0000297
Mark Brown77bd70e2011-02-04 14:57:43 +0000298 /* We may have lied to the PM core about suspending */
299 if (!wm8994->suspended)
300 return 0;
301
Mark Brown559e0df2010-08-31 19:25:12 +0100302 ret = regulator_bulk_enable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000303 wm8994->supplies);
304 if (ret != 0) {
305 dev_err(dev, "Failed to enable supplies: %d\n", ret);
306 return ret;
307 }
308
Mark Brown98ae1cc2011-06-07 11:49:42 +0100309 /* Write register at a time as we use the cache on the CPU so store
310 * it in native endian.
311 */
312 for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
313 ret = wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK
314 + i, wm8994->irq_masks_cur[i]);
315 if (ret < 0)
316 dev_err(dev, "Failed to restore interrupt masks: %d\n",
317 ret);
318 }
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000319
Mark Brown9e501082010-01-29 18:20:29 +0000320 ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
321 &wm8994->ldo_regs);
322 if (ret < 0)
323 dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
324
325 ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
326 &wm8994->gpio_regs);
327 if (ret < 0)
328 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
329
Mark Brown881de672011-08-22 15:43:55 +0200330 /* Disable LDO pulldowns while the device is active */
331 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
332 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
333 0);
334
Mark Brown77bd70e2011-02-04 14:57:43 +0000335 wm8994->suspended = false;
336
Mark Brown9e501082010-01-29 18:20:29 +0000337 return 0;
338}
339#endif
340
341#ifdef CONFIG_REGULATOR
342static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
343{
344 struct wm8994_ldo_pdata *ldo_pdata;
345
346 if (!pdata)
347 return 0;
348
349 ldo_pdata = &pdata->ldo[ldo];
350
351 if (!ldo_pdata->init_data)
352 return 0;
353
354 return ldo_pdata->init_data->num_consumer_supplies != 0;
355}
356#else
357static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
358{
359 return 0;
360}
361#endif
362
Mark Brownd6c645fc2011-06-17 13:02:27 +0100363static struct regmap_config wm8994_regmap_config = {
364 .reg_bits = 16,
365 .val_bits = 16,
366};
367
Mark Brown9e501082010-01-29 18:20:29 +0000368/*
369 * Instantiate the generic non-control parts of the device.
370 */
Mark Brown559e0df2010-08-31 19:25:12 +0100371static int wm8994_device_init(struct wm8994 *wm8994, int irq)
Mark Brown9e501082010-01-29 18:20:29 +0000372{
373 struct wm8994_pdata *pdata = wm8994->dev->platform_data;
Mark Brown559e0df2010-08-31 19:25:12 +0100374 const char *devname;
Mark Brown9e501082010-01-29 18:20:29 +0000375 int ret, i;
Mark Brown26c34c22011-11-03 13:20:38 +0000376 int pulls = 0;
Mark Brown9e501082010-01-29 18:20:29 +0000377
Mark Brown9e501082010-01-29 18:20:29 +0000378 dev_set_drvdata(wm8994->dev, wm8994);
379
380 /* Add the on-chip regulators first for bootstrapping */
381 ret = mfd_add_devices(wm8994->dev, -1,
382 wm8994_regulator_devs,
383 ARRAY_SIZE(wm8994_regulator_devs),
384 NULL, 0);
385 if (ret != 0) {
386 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
Mark Brownd6c645fc2011-06-17 13:02:27 +0100387 goto err_regmap;
Mark Brown9e501082010-01-29 18:20:29 +0000388 }
389
Mark Brown559e0df2010-08-31 19:25:12 +0100390 switch (wm8994->type) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800391 case WM1811:
392 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
393 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100394 case WM8994:
395 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
396 break;
397 case WM8958:
398 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
399 break;
400 default:
401 BUG();
Mark Brownd6c645fc2011-06-17 13:02:27 +0100402 goto err_regmap;
Mark Brown559e0df2010-08-31 19:25:12 +0100403 }
404
Mark Brown2fa33492011-10-25 13:45:40 +0200405 wm8994->supplies = devm_kzalloc(wm8994->dev,
406 sizeof(struct regulator_bulk_data) *
407 wm8994->num_supplies, GFP_KERNEL);
Axel Linfccbd212010-08-04 09:44:47 +0800408 if (!wm8994->supplies) {
409 ret = -ENOMEM;
Mark Brownd6c645fc2011-06-17 13:02:27 +0100410 goto err_regmap;
Axel Linfccbd212010-08-04 09:44:47 +0800411 }
Mark Brown9e501082010-01-29 18:20:29 +0000412
Mark Brown559e0df2010-08-31 19:25:12 +0100413 switch (wm8994->type) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800414 case WM1811:
415 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
416 wm8994->supplies[i].supply = wm1811_main_supplies[i];
417 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100418 case WM8994:
419 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
420 wm8994->supplies[i].supply = wm8994_main_supplies[i];
421 break;
422 case WM8958:
423 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
424 wm8994->supplies[i].supply = wm8958_main_supplies[i];
425 break;
426 default:
427 BUG();
Mark Brownd6c645fc2011-06-17 13:02:27 +0100428 goto err_regmap;
Mark Brown559e0df2010-08-31 19:25:12 +0100429 }
430
431 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000432 wm8994->supplies);
433 if (ret != 0) {
434 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
Mark Brown2fa33492011-10-25 13:45:40 +0200435 goto err_regmap;
Mark Brown9e501082010-01-29 18:20:29 +0000436 }
437
Mark Brown559e0df2010-08-31 19:25:12 +0100438 ret = regulator_bulk_enable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000439 wm8994->supplies);
440 if (ret != 0) {
441 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
Joonyoung Shim77310742010-02-07 10:16:14 +0900442 goto err_get;
Mark Brown9e501082010-01-29 18:20:29 +0000443 }
444
445 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
446 if (ret < 0) {
447 dev_err(wm8994->dev, "Failed to read ID register\n");
448 goto err_enable;
449 }
Mark Brown559e0df2010-08-31 19:25:12 +0100450 switch (ret) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800451 case 0x1811:
452 devname = "WM1811";
453 if (wm8994->type != WM1811)
454 dev_warn(wm8994->dev, "Device registered as type %d\n",
455 wm8994->type);
456 wm8994->type = WM1811;
457 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100458 case 0x8994:
459 devname = "WM8994";
460 if (wm8994->type != WM8994)
461 dev_warn(wm8994->dev, "Device registered as type %d\n",
462 wm8994->type);
463 wm8994->type = WM8994;
464 break;
465 case 0x8958:
466 devname = "WM8958";
467 if (wm8994->type != WM8958)
468 dev_warn(wm8994->dev, "Device registered as type %d\n",
469 wm8994->type);
470 wm8994->type = WM8958;
471 break;
472 default:
Mark Brown9e501082010-01-29 18:20:29 +0000473 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
474 ret);
475 ret = -EINVAL;
476 goto err_enable;
477 }
478
479 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
480 if (ret < 0) {
481 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
482 ret);
483 goto err_enable;
484 }
485
Mark Browna2495bc2011-06-02 19:18:55 +0100486 switch (wm8994->type) {
487 case WM8994:
488 switch (ret) {
489 case 0:
490 case 1:
Mark Brown559e0df2010-08-31 19:25:12 +0100491 dev_warn(wm8994->dev,
492 "revision %c not fully supported\n",
493 'A' + ret);
Mark Browna2495bc2011-06-02 19:18:55 +0100494 break;
495 default:
496 break;
497 }
Mark Brown9e501082010-01-29 18:20:29 +0000498 break;
499 default:
Mark Brown9e501082010-01-29 18:20:29 +0000500 break;
501 }
502
Mark Brown559e0df2010-08-31 19:25:12 +0100503 dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
Mark Brown9e501082010-01-29 18:20:29 +0000504
505 if (pdata) {
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000506 wm8994->irq_base = pdata->irq_base;
Mark Brown9e501082010-01-29 18:20:29 +0000507 wm8994->gpio_base = pdata->gpio_base;
508
509 /* GPIO configuration is only applied if it's non-zero */
510 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
511 if (pdata->gpio_defaults[i]) {
512 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
513 0xffff,
514 pdata->gpio_defaults[i]);
515 }
516 }
Mark Brown881de672011-08-22 15:43:55 +0200517
518 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
Mark Brown26c34c22011-11-03 13:20:38 +0000519
520 if (pdata->spkmode_pu)
521 pulls |= WM8994_SPKMODE_PU;
Mark Brown9e501082010-01-29 18:20:29 +0000522 }
523
Mark Brown26c34c22011-11-03 13:20:38 +0000524 /* Disable unneeded pulls */
Mark Brown881de672011-08-22 15:43:55 +0200525 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
Mark Brown26c34c22011-11-03 13:20:38 +0000526 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD |
527 WM8994_SPKMODE_PU | WM8994_CSNADDR_PD,
528 pulls);
Mark Brown881de672011-08-22 15:43:55 +0200529
Mark Brown9e501082010-01-29 18:20:29 +0000530 /* In some system designs where the regulators are not in use,
531 * we can achieve a small reduction in leakage currents by
532 * floating LDO outputs. This bit makes no difference if the
533 * LDOs are enabled, it only affects cases where the LDOs were
534 * in operation and are then disabled.
535 */
536 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
537 if (wm8994_ldo_in_use(pdata, i))
538 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
539 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
540 else
541 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
542 WM8994_LDO1_DISCH, 0);
543 }
544
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000545 wm8994_irq_init(wm8994);
546
Mark Brown9e501082010-01-29 18:20:29 +0000547 ret = mfd_add_devices(wm8994->dev, -1,
548 wm8994_devs, ARRAY_SIZE(wm8994_devs),
549 NULL, 0);
550 if (ret != 0) {
551 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000552 goto err_irq;
Mark Brown9e501082010-01-29 18:20:29 +0000553 }
554
Mark Brownd450f192010-11-26 17:19:35 +0000555 pm_runtime_enable(wm8994->dev);
556 pm_runtime_resume(wm8994->dev);
557
Mark Brown9e501082010-01-29 18:20:29 +0000558 return 0;
559
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000560err_irq:
561 wm8994_irq_exit(wm8994);
Mark Brown9e501082010-01-29 18:20:29 +0000562err_enable:
Mark Brown559e0df2010-08-31 19:25:12 +0100563 regulator_bulk_disable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000564 wm8994->supplies);
565err_get:
Mark Brown559e0df2010-08-31 19:25:12 +0100566 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
Mark Brownd6c645fc2011-06-17 13:02:27 +0100567err_regmap:
568 regmap_exit(wm8994->regmap);
Mark Brown9e501082010-01-29 18:20:29 +0000569 mfd_remove_devices(wm8994->dev);
Mark Brown9e501082010-01-29 18:20:29 +0000570 return ret;
571}
572
573static void wm8994_device_exit(struct wm8994 *wm8994)
574{
Mark Brownd450f192010-11-26 17:19:35 +0000575 pm_runtime_disable(wm8994->dev);
Mark Brown9e501082010-01-29 18:20:29 +0000576 mfd_remove_devices(wm8994->dev);
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000577 wm8994_irq_exit(wm8994);
Mark Brown559e0df2010-08-31 19:25:12 +0100578 regulator_bulk_disable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000579 wm8994->supplies);
Mark Brown559e0df2010-08-31 19:25:12 +0100580 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
Mark Brownd6c645fc2011-06-17 13:02:27 +0100581 regmap_exit(wm8994->regmap);
Mark Brown9e501082010-01-29 18:20:29 +0000582}
583
Mark Browncf763c22011-11-22 18:22:29 +0000584static const struct of_device_id wm8994_of_match[] = {
585 { .compatible = "wlf,wm1811", },
586 { .compatible = "wlf,wm8994", },
587 { .compatible = "wlf,wm8958", },
588 { }
589};
590MODULE_DEVICE_TABLE(of, wm8994_of_match);
591
Mark Brown9e501082010-01-29 18:20:29 +0000592static int wm8994_i2c_probe(struct i2c_client *i2c,
593 const struct i2c_device_id *id)
594{
595 struct wm8994 *wm8994;
Mark Brownd6c645fc2011-06-17 13:02:27 +0100596 int ret;
Mark Brown9e501082010-01-29 18:20:29 +0000597
Mark Brown2fa33492011-10-25 13:45:40 +0200598 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL);
Axel Lind0a11692010-08-09 14:52:16 +0800599 if (wm8994 == NULL)
Mark Brown9e501082010-01-29 18:20:29 +0000600 return -ENOMEM;
Mark Brown9e501082010-01-29 18:20:29 +0000601
602 i2c_set_clientdata(i2c, wm8994);
603 wm8994->dev = &i2c->dev;
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000604 wm8994->irq = i2c->irq;
Mark Brown559e0df2010-08-31 19:25:12 +0100605 wm8994->type = id->driver_data;
Mark Brown9e501082010-01-29 18:20:29 +0000606
Mark Brownd6c645fc2011-06-17 13:02:27 +0100607 wm8994->regmap = regmap_init_i2c(i2c, &wm8994_regmap_config);
608 if (IS_ERR(wm8994->regmap)) {
609 ret = PTR_ERR(wm8994->regmap);
610 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
611 ret);
Mark Brownd6c645fc2011-06-17 13:02:27 +0100612 return ret;
613 }
614
Mark Brown559e0df2010-08-31 19:25:12 +0100615 return wm8994_device_init(wm8994, i2c->irq);
Mark Brown9e501082010-01-29 18:20:29 +0000616}
617
618static int wm8994_i2c_remove(struct i2c_client *i2c)
619{
620 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
621
622 wm8994_device_exit(wm8994);
623
624 return 0;
625}
626
Mark Brown9e501082010-01-29 18:20:29 +0000627static const struct i2c_device_id wm8994_i2c_id[] = {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800628 { "wm1811", WM1811 },
Mark Brown559e0df2010-08-31 19:25:12 +0100629 { "wm8994", WM8994 },
630 { "wm8958", WM8958 },
Mark Brown9e501082010-01-29 18:20:29 +0000631 { }
632};
633MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
634
Mark Brownaad34312011-03-17 16:33:49 +0000635static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
636 NULL);
Mark Brownd450f192010-11-26 17:19:35 +0000637
Mark Brown9e501082010-01-29 18:20:29 +0000638static struct i2c_driver wm8994_i2c_driver = {
639 .driver = {
Mark Brownd450f192010-11-26 17:19:35 +0000640 .name = "wm8994",
641 .owner = THIS_MODULE,
642 .pm = &wm8994_pm_ops,
Mark Browncf763c22011-11-22 18:22:29 +0000643 .of_match_table = wm8994_of_match,
Mark Brown9e501082010-01-29 18:20:29 +0000644 },
645 .probe = wm8994_i2c_probe,
646 .remove = wm8994_i2c_remove,
Mark Brown9e501082010-01-29 18:20:29 +0000647 .id_table = wm8994_i2c_id,
648};
649
650static int __init wm8994_i2c_init(void)
651{
652 int ret;
653
654 ret = i2c_add_driver(&wm8994_i2c_driver);
655 if (ret != 0)
656 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
657
658 return ret;
659}
660module_init(wm8994_i2c_init);
661
662static void __exit wm8994_i2c_exit(void)
663{
664 i2c_del_driver(&wm8994_i2c_driver);
665}
666module_exit(wm8994_i2c_exit);
667
668MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
669MODULE_LICENSE("GPL");
670MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");