blob: 5d6ba132837e8efb5f470d48784d5bb5f9809509 [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;
376
Mark Brown9e501082010-01-29 18:20:29 +0000377 dev_set_drvdata(wm8994->dev, wm8994);
378
379 /* Add the on-chip regulators first for bootstrapping */
380 ret = mfd_add_devices(wm8994->dev, -1,
381 wm8994_regulator_devs,
382 ARRAY_SIZE(wm8994_regulator_devs),
383 NULL, 0);
384 if (ret != 0) {
385 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
Mark Brownd6c645fc2011-06-17 13:02:27 +0100386 goto err_regmap;
Mark Brown9e501082010-01-29 18:20:29 +0000387 }
388
Mark Brown559e0df2010-08-31 19:25:12 +0100389 switch (wm8994->type) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800390 case WM1811:
391 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
392 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100393 case WM8994:
394 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
395 break;
396 case WM8958:
397 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
398 break;
399 default:
400 BUG();
Mark Brownd6c645fc2011-06-17 13:02:27 +0100401 goto err_regmap;
Mark Brown559e0df2010-08-31 19:25:12 +0100402 }
403
Mark Brown9e501082010-01-29 18:20:29 +0000404 wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
Mark Brown559e0df2010-08-31 19:25:12 +0100405 wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000406 GFP_KERNEL);
Axel Linfccbd212010-08-04 09:44:47 +0800407 if (!wm8994->supplies) {
408 ret = -ENOMEM;
Mark Brownd6c645fc2011-06-17 13:02:27 +0100409 goto err_regmap;
Axel Linfccbd212010-08-04 09:44:47 +0800410 }
Mark Brown9e501082010-01-29 18:20:29 +0000411
Mark Brown559e0df2010-08-31 19:25:12 +0100412 switch (wm8994->type) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800413 case WM1811:
414 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
415 wm8994->supplies[i].supply = wm1811_main_supplies[i];
416 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100417 case WM8994:
418 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
419 wm8994->supplies[i].supply = wm8994_main_supplies[i];
420 break;
421 case WM8958:
422 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
423 wm8994->supplies[i].supply = wm8958_main_supplies[i];
424 break;
425 default:
426 BUG();
Mark Brownd6c645fc2011-06-17 13:02:27 +0100427 goto err_regmap;
Mark Brown559e0df2010-08-31 19:25:12 +0100428 }
429
430 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000431 wm8994->supplies);
432 if (ret != 0) {
433 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
Joonyoung Shim77310742010-02-07 10:16:14 +0900434 goto err_supplies;
Mark Brown9e501082010-01-29 18:20:29 +0000435 }
436
Mark Brown559e0df2010-08-31 19:25:12 +0100437 ret = regulator_bulk_enable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000438 wm8994->supplies);
439 if (ret != 0) {
440 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
Joonyoung Shim77310742010-02-07 10:16:14 +0900441 goto err_get;
Mark Brown9e501082010-01-29 18:20:29 +0000442 }
443
444 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
445 if (ret < 0) {
446 dev_err(wm8994->dev, "Failed to read ID register\n");
447 goto err_enable;
448 }
Mark Brown559e0df2010-08-31 19:25:12 +0100449 switch (ret) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800450 case 0x1811:
451 devname = "WM1811";
452 if (wm8994->type != WM1811)
453 dev_warn(wm8994->dev, "Device registered as type %d\n",
454 wm8994->type);
455 wm8994->type = WM1811;
456 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100457 case 0x8994:
458 devname = "WM8994";
459 if (wm8994->type != WM8994)
460 dev_warn(wm8994->dev, "Device registered as type %d\n",
461 wm8994->type);
462 wm8994->type = WM8994;
463 break;
464 case 0x8958:
465 devname = "WM8958";
466 if (wm8994->type != WM8958)
467 dev_warn(wm8994->dev, "Device registered as type %d\n",
468 wm8994->type);
469 wm8994->type = WM8958;
470 break;
471 default:
Mark Brown9e501082010-01-29 18:20:29 +0000472 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
473 ret);
474 ret = -EINVAL;
475 goto err_enable;
476 }
477
478 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
479 if (ret < 0) {
480 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
481 ret);
482 goto err_enable;
483 }
484
Mark Browna2495bc2011-06-02 19:18:55 +0100485 switch (wm8994->type) {
486 case WM8994:
487 switch (ret) {
488 case 0:
489 case 1:
Mark Brown559e0df2010-08-31 19:25:12 +0100490 dev_warn(wm8994->dev,
491 "revision %c not fully supported\n",
492 'A' + ret);
Mark Browna2495bc2011-06-02 19:18:55 +0100493 break;
494 default:
495 break;
496 }
Mark Brown9e501082010-01-29 18:20:29 +0000497 break;
498 default:
Mark Brown9e501082010-01-29 18:20:29 +0000499 break;
500 }
501
Mark Brown559e0df2010-08-31 19:25:12 +0100502 dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
Mark Brown9e501082010-01-29 18:20:29 +0000503
504 if (pdata) {
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000505 wm8994->irq_base = pdata->irq_base;
Mark Brown9e501082010-01-29 18:20:29 +0000506 wm8994->gpio_base = pdata->gpio_base;
507
508 /* GPIO configuration is only applied if it's non-zero */
509 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
510 if (pdata->gpio_defaults[i]) {
511 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
512 0xffff,
513 pdata->gpio_defaults[i]);
514 }
515 }
Mark Brown881de672011-08-22 15:43:55 +0200516
517 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
Mark Brown9e501082010-01-29 18:20:29 +0000518 }
519
Mark Brown881de672011-08-22 15:43:55 +0200520 /* Disable LDO pulldowns while the device is active */
521 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
522 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
523 0);
524
Mark Brown9e501082010-01-29 18:20:29 +0000525 /* In some system designs where the regulators are not in use,
526 * we can achieve a small reduction in leakage currents by
527 * floating LDO outputs. This bit makes no difference if the
528 * LDOs are enabled, it only affects cases where the LDOs were
529 * in operation and are then disabled.
530 */
531 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
532 if (wm8994_ldo_in_use(pdata, i))
533 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
534 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
535 else
536 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
537 WM8994_LDO1_DISCH, 0);
538 }
539
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000540 wm8994_irq_init(wm8994);
541
Mark Brown9e501082010-01-29 18:20:29 +0000542 ret = mfd_add_devices(wm8994->dev, -1,
543 wm8994_devs, ARRAY_SIZE(wm8994_devs),
544 NULL, 0);
545 if (ret != 0) {
546 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000547 goto err_irq;
Mark Brown9e501082010-01-29 18:20:29 +0000548 }
549
Mark Brownd450f192010-11-26 17:19:35 +0000550 pm_runtime_enable(wm8994->dev);
551 pm_runtime_resume(wm8994->dev);
552
Mark Brown9e501082010-01-29 18:20:29 +0000553 return 0;
554
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000555err_irq:
556 wm8994_irq_exit(wm8994);
Mark Brown9e501082010-01-29 18:20:29 +0000557err_enable:
Mark Brown559e0df2010-08-31 19:25:12 +0100558 regulator_bulk_disable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000559 wm8994->supplies);
560err_get:
Mark Brown559e0df2010-08-31 19:25:12 +0100561 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
Mark Brown9e501082010-01-29 18:20:29 +0000562err_supplies:
563 kfree(wm8994->supplies);
Mark Brownd6c645fc2011-06-17 13:02:27 +0100564err_regmap:
565 regmap_exit(wm8994->regmap);
Mark Brown9e501082010-01-29 18:20:29 +0000566 mfd_remove_devices(wm8994->dev);
567 kfree(wm8994);
568 return ret;
569}
570
571static void wm8994_device_exit(struct wm8994 *wm8994)
572{
Mark Brownd450f192010-11-26 17:19:35 +0000573 pm_runtime_disable(wm8994->dev);
Mark Brown9e501082010-01-29 18:20:29 +0000574 mfd_remove_devices(wm8994->dev);
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000575 wm8994_irq_exit(wm8994);
Mark Brown559e0df2010-08-31 19:25:12 +0100576 regulator_bulk_disable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000577 wm8994->supplies);
Mark Brown559e0df2010-08-31 19:25:12 +0100578 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
Mark Brown9e501082010-01-29 18:20:29 +0000579 kfree(wm8994->supplies);
Mark Brownd6c645fc2011-06-17 13:02:27 +0100580 regmap_exit(wm8994->regmap);
Mark Brown9e501082010-01-29 18:20:29 +0000581 kfree(wm8994);
582}
583
Mark Brown9e501082010-01-29 18:20:29 +0000584static int wm8994_i2c_probe(struct i2c_client *i2c,
585 const struct i2c_device_id *id)
586{
587 struct wm8994 *wm8994;
Mark Brownd6c645fc2011-06-17 13:02:27 +0100588 int ret;
Mark Brown9e501082010-01-29 18:20:29 +0000589
590 wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
Axel Lind0a11692010-08-09 14:52:16 +0800591 if (wm8994 == NULL)
Mark Brown9e501082010-01-29 18:20:29 +0000592 return -ENOMEM;
Mark Brown9e501082010-01-29 18:20:29 +0000593
594 i2c_set_clientdata(i2c, wm8994);
595 wm8994->dev = &i2c->dev;
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000596 wm8994->irq = i2c->irq;
Mark Brown559e0df2010-08-31 19:25:12 +0100597 wm8994->type = id->driver_data;
Mark Brown9e501082010-01-29 18:20:29 +0000598
Mark Brownd6c645fc2011-06-17 13:02:27 +0100599 wm8994->regmap = regmap_init_i2c(i2c, &wm8994_regmap_config);
600 if (IS_ERR(wm8994->regmap)) {
601 ret = PTR_ERR(wm8994->regmap);
602 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
603 ret);
604 kfree(wm8994);
605 return ret;
606 }
607
Mark Brown559e0df2010-08-31 19:25:12 +0100608 return wm8994_device_init(wm8994, i2c->irq);
Mark Brown9e501082010-01-29 18:20:29 +0000609}
610
611static int wm8994_i2c_remove(struct i2c_client *i2c)
612{
613 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
614
615 wm8994_device_exit(wm8994);
616
617 return 0;
618}
619
Mark Brown9e501082010-01-29 18:20:29 +0000620static const struct i2c_device_id wm8994_i2c_id[] = {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800621 { "wm1811", WM1811 },
Mark Brown559e0df2010-08-31 19:25:12 +0100622 { "wm8994", WM8994 },
623 { "wm8958", WM8958 },
Mark Brown9e501082010-01-29 18:20:29 +0000624 { }
625};
626MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
627
Mark Brownaad34312011-03-17 16:33:49 +0000628static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
629 NULL);
Mark Brownd450f192010-11-26 17:19:35 +0000630
Mark Brown9e501082010-01-29 18:20:29 +0000631static struct i2c_driver wm8994_i2c_driver = {
632 .driver = {
Mark Brownd450f192010-11-26 17:19:35 +0000633 .name = "wm8994",
634 .owner = THIS_MODULE,
635 .pm = &wm8994_pm_ops,
Mark Brown9e501082010-01-29 18:20:29 +0000636 },
637 .probe = wm8994_i2c_probe,
638 .remove = wm8994_i2c_remove,
Mark Brown9e501082010-01-29 18:20:29 +0000639 .id_table = wm8994_i2c_id,
640};
641
642static int __init wm8994_i2c_init(void)
643{
644 int ret;
645
646 ret = i2c_add_driver(&wm8994_i2c_driver);
647 if (ret != 0)
648 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
649
650 return ret;
651}
652module_init(wm8994_i2c_init);
653
654static void __exit wm8994_i2c_exit(void)
655{
656 i2c_del_driver(&wm8994_i2c_driver);
657}
658module_exit(wm8994_i2c_exit);
659
660MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
661MODULE_LICENSE("GPL");
662MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");