blob: cdea84e727e57f16bd7cc9e847622c24c8700383 [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
Mark Brownc3f13862011-10-25 14:23:53 +020031#include "wm8994.h"
Mark Brown9e501082010-01-29 18:20:29 +000032
33/**
34 * wm8994_reg_read: Read a single WM8994 register.
35 *
36 * @wm8994: Device to read from.
37 * @reg: Register to read.
38 */
39int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
40{
Mark Brownd6c645fc2011-06-17 13:02:27 +010041 unsigned int val;
Mark Brown9e501082010-01-29 18:20:29 +000042 int ret;
43
Mark Brownd6c645fc2011-06-17 13:02:27 +010044 ret = regmap_read(wm8994->regmap, reg, &val);
Mark Brown9e501082010-01-29 18:20:29 +000045
46 if (ret < 0)
47 return ret;
48 else
Mark Brownd6c645fc2011-06-17 13:02:27 +010049 return val;
Mark Brown9e501082010-01-29 18:20:29 +000050}
51EXPORT_SYMBOL_GPL(wm8994_reg_read);
52
53/**
54 * wm8994_bulk_read: Read multiple WM8994 registers
55 *
56 * @wm8994: Device to read from
57 * @reg: First register
58 * @count: Number of registers
Mark Brown316b6cc2011-03-18 12:50:10 +000059 * @buf: Buffer to fill. The data will be returned big endian.
Mark Brown9e501082010-01-29 18:20:29 +000060 */
61int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
62 int count, u16 *buf)
63{
Mark Brownd6c645fc2011-06-17 13:02:27 +010064 return regmap_bulk_read(wm8994->regmap, reg, buf, count);
Mark Brown9e501082010-01-29 18:20:29 +000065}
Mark Brown9e501082010-01-29 18:20:29 +000066
Mark Brown9e501082010-01-29 18:20:29 +000067/**
68 * wm8994_reg_write: Write a single WM8994 register.
69 *
70 * @wm8994: Device to write to.
71 * @reg: Register to write to.
72 * @val: Value to write.
73 */
74int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
75 unsigned short val)
76{
Mark Brownd6c645fc2011-06-17 13:02:27 +010077 return regmap_write(wm8994->regmap, reg, val);
Mark Brown9e501082010-01-29 18:20:29 +000078}
79EXPORT_SYMBOL_GPL(wm8994_reg_write);
80
81/**
Mark Browne93c5382011-03-10 13:54:07 +000082 * wm8994_bulk_write: Write multiple WM8994 registers
83 *
84 * @wm8994: Device to write to
85 * @reg: First register
86 * @count: Number of registers
Mark Brown42771632011-03-17 21:42:29 +000087 * @buf: Buffer to write from. Data must be big-endian formatted.
Mark Browne93c5382011-03-10 13:54:07 +000088 */
89int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
Mark Brown07e73fb2011-03-17 21:42:30 +000090 int count, const u16 *buf)
Mark Browne93c5382011-03-10 13:54:07 +000091{
Mark Brownd6c645fc2011-06-17 13:02:27 +010092 return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16));
Mark Browne93c5382011-03-10 13:54:07 +000093}
94EXPORT_SYMBOL_GPL(wm8994_bulk_write);
95
96/**
Mark Brown9e501082010-01-29 18:20:29 +000097 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
98 *
99 * @wm8994: Device to write to.
100 * @reg: Register to write to.
101 * @mask: Mask of bits to set.
102 * @val: Value to set (unshifted)
103 */
104int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
105 unsigned short mask, unsigned short val)
106{
Mark Brownd6c645fc2011-06-17 13:02:27 +0100107 return regmap_update_bits(wm8994->regmap, reg, mask, val);
Mark Brown9e501082010-01-29 18:20:29 +0000108}
109EXPORT_SYMBOL_GPL(wm8994_set_bits);
110
111static struct mfd_cell wm8994_regulator_devs[] = {
Mark Brownd450f192010-11-26 17:19:35 +0000112 {
113 .name = "wm8994-ldo",
114 .id = 1,
115 .pm_runtime_no_callbacks = true,
116 },
117 {
118 .name = "wm8994-ldo",
119 .id = 2,
120 .pm_runtime_no_callbacks = true,
121 },
Mark Brown9e501082010-01-29 18:20:29 +0000122};
123
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000124static struct resource wm8994_codec_resources[] = {
125 {
126 .start = WM8994_IRQ_TEMP_SHUT,
127 .end = WM8994_IRQ_TEMP_WARN,
128 .flags = IORESOURCE_IRQ,
129 },
130};
131
132static struct resource wm8994_gpio_resources[] = {
133 {
134 .start = WM8994_IRQ_GPIO(1),
135 .end = WM8994_IRQ_GPIO(11),
136 .flags = IORESOURCE_IRQ,
137 },
138};
139
Mark Brown9e501082010-01-29 18:20:29 +0000140static struct mfd_cell wm8994_devs[] = {
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000141 {
142 .name = "wm8994-codec",
143 .num_resources = ARRAY_SIZE(wm8994_codec_resources),
144 .resources = wm8994_codec_resources,
145 },
146
147 {
148 .name = "wm8994-gpio",
149 .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
150 .resources = wm8994_gpio_resources,
Mark Brownd450f192010-11-26 17:19:35 +0000151 .pm_runtime_no_callbacks = true,
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000152 },
Mark Brown9e501082010-01-29 18:20:29 +0000153};
154
155/*
156 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
157 * and should be handled via the standard regulator API supply
158 * management.
159 */
Mark Brownb1f43bf2011-05-24 17:35:40 +0800160static const char *wm1811_main_supplies[] = {
161 "DBVDD1",
162 "DBVDD2",
163 "DBVDD3",
164 "DCVDD",
165 "AVDD1",
166 "AVDD2",
167 "CPVDD",
168 "SPKVDD1",
169 "SPKVDD2",
170};
171
Mark Brown9e501082010-01-29 18:20:29 +0000172static const char *wm8994_main_supplies[] = {
173 "DBVDD",
174 "DCVDD",
175 "AVDD1",
176 "AVDD2",
177 "CPVDD",
178 "SPKVDD1",
179 "SPKVDD2",
180};
181
Mark Brown559e0df2010-08-31 19:25:12 +0100182static const char *wm8958_main_supplies[] = {
183 "DBVDD1",
184 "DBVDD2",
185 "DBVDD3",
186 "DCVDD",
187 "AVDD1",
188 "AVDD2",
189 "CPVDD",
190 "SPKVDD1",
191 "SPKVDD2",
192};
193
Mark Brown63946782013-03-22 12:40:22 +0100194#ifdef CONFIG_PM_RUNTIME
Mark Brownd450f192010-11-26 17:19:35 +0000195static int wm8994_suspend(struct device *dev)
Mark Brown9e501082010-01-29 18:20:29 +0000196{
197 struct wm8994 *wm8994 = dev_get_drvdata(dev);
198 int ret;
199
Mark Brown77bd70e2011-02-04 14:57:43 +0000200 /* Don't actually go through with the suspend if the CODEC is
201 * still active (eg, for audio passthrough from CP. */
202 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
203 if (ret < 0) {
204 dev_err(dev, "Failed to read power status: %d\n", ret);
205 } else if (ret & WM8994_VMID_SEL_MASK) {
206 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
207 return 0;
208 }
209
Mark Brown5f40c6b2011-08-13 14:37:48 +0900210 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_4);
211 if (ret < 0) {
212 dev_err(dev, "Failed to read power status: %d\n", ret);
213 } else if (ret & (WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA |
214 WM8994_AIF1ADC2L_ENA | WM8994_AIF1ADC2R_ENA |
215 WM8994_AIF1ADC1L_ENA | WM8994_AIF1ADC1R_ENA)) {
216 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
217 return 0;
218 }
219
220 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_5);
221 if (ret < 0) {
222 dev_err(dev, "Failed to read power status: %d\n", ret);
223 } else if (ret & (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA |
224 WM8994_AIF1DAC2L_ENA | WM8994_AIF1DAC2R_ENA |
225 WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA)) {
226 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
227 return 0;
228 }
229
230 switch (wm8994->type) {
231 case WM8958:
Mark Brownb5488b62011-11-04 23:14:46 +0000232 case WM1811:
Mark Brown5f40c6b2011-08-13 14:37:48 +0900233 ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1);
234 if (ret < 0) {
235 dev_err(dev, "Failed to read power status: %d\n", ret);
236 } else if (ret & WM8958_MICD_ENA) {
237 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
238 return 0;
239 }
240 break;
241 default:
242 break;
243 }
244
Mark Browna3462492011-12-01 17:19:44 +0000245 switch (wm8994->type) {
246 case WM1811:
247 ret = wm8994_reg_read(wm8994, WM8994_ANTIPOP_2);
248 if (ret < 0) {
249 dev_err(dev, "Failed to read jackdet: %d\n", ret);
250 } else if (ret & WM1811_JACKDET_MODE_MASK) {
251 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
252 return 0;
253 }
254 break;
255 default:
256 break;
257 }
258
Mark Browne7c248a2012-02-20 21:32:32 +0000259 switch (wm8994->type) {
260 case WM1811:
261 ret = wm8994_reg_read(wm8994, WM8994_ANTIPOP_2);
262 if (ret < 0) {
263 dev_err(dev, "Failed to read jackdet: %d\n", ret);
264 } else if (ret & WM1811_JACKDET_MODE_MASK) {
265 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
266 return 0;
267 }
268 break;
269 default:
270 break;
271 }
272
Mark Brown881de672011-08-22 15:43:55 +0200273 /* Disable LDO pulldowns while the device is suspended if we
274 * don't know that something will be driving them. */
275 if (!wm8994->ldo_ena_always_driven)
276 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
277 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
278 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD);
279
Mark Brownf40dff92011-02-21 18:30:31 +0000280 /* Explicitly put the device into reset in case regulators
281 * don't get disabled in order to ensure consistent restart.
282 */
Mark Brownbe79cf22011-10-25 13:25:43 +0200283 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET,
284 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
Mark Brownf40dff92011-02-21 18:30:31 +0000285
Mark Browned393dc2012-06-29 14:55:39 +0100286 regcache_mark_dirty(wm8994->regmap);
287
Chris Rattray78a27cd2012-06-12 00:43:35 +0800288 /* Restore GPIO registers to prevent problems with mismatched
289 * pin configurations.
290 */
Mark Browned393dc2012-06-29 14:55:39 +0100291 ret = regcache_sync_region(wm8994->regmap, WM8994_GPIO_1,
292 WM8994_GPIO_11);
Chris Rattray78a27cd2012-06-12 00:43:35 +0800293 if (ret != 0)
294 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
295
Mark Brown1a2017b2012-06-29 14:55:40 +0100296 /* In case one of the GPIOs is used as a wake input. */
297 ret = regcache_sync_region(wm8994->regmap,
298 WM8994_INTERRUPT_STATUS_1_MASK,
299 WM8994_INTERRUPT_STATUS_1_MASK);
300 if (ret != 0)
301 dev_err(dev, "Failed to restore interrupt mask: %d\n", ret);
302
Mark Brown3befc922012-01-09 00:36:42 -0800303 regcache_cache_only(wm8994->regmap, true);
Mark Brown77bd70e2011-02-04 14:57:43 +0000304 wm8994->suspended = true;
305
Mark Brown559e0df2010-08-31 19:25:12 +0100306 ret = regulator_bulk_disable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000307 wm8994->supplies);
308 if (ret != 0) {
309 dev_err(dev, "Failed to disable supplies: %d\n", ret);
310 return ret;
311 }
312
313 return 0;
314}
315
Mark Brownd450f192010-11-26 17:19:35 +0000316static int wm8994_resume(struct device *dev)
Mark Brown9e501082010-01-29 18:20:29 +0000317{
318 struct wm8994 *wm8994 = dev_get_drvdata(dev);
Mark Brownc3f13862011-10-25 14:23:53 +0200319 int ret;
Mark Brown9e501082010-01-29 18:20:29 +0000320
Mark Brown77bd70e2011-02-04 14:57:43 +0000321 /* We may have lied to the PM core about suspending */
322 if (!wm8994->suspended)
323 return 0;
324
Mark Brown559e0df2010-08-31 19:25:12 +0100325 ret = regulator_bulk_enable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000326 wm8994->supplies);
327 if (ret != 0) {
328 dev_err(dev, "Failed to enable supplies: %d\n", ret);
329 return ret;
330 }
331
Mark Brown3befc922012-01-09 00:36:42 -0800332 regcache_cache_only(wm8994->regmap, false);
Mark Brownc3f13862011-10-25 14:23:53 +0200333 ret = regcache_sync(wm8994->regmap);
334 if (ret != 0) {
335 dev_err(dev, "Failed to restore register map: %d\n", ret);
336 goto err_enable;
Mark Brown98ae1cc2011-06-07 11:49:42 +0100337 }
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000338
Mark Brown881de672011-08-22 15:43:55 +0200339 /* Disable LDO pulldowns while the device is active */
340 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
341 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
342 0);
343
Mark Brown77bd70e2011-02-04 14:57:43 +0000344 wm8994->suspended = false;
345
Mark Brown9e501082010-01-29 18:20:29 +0000346 return 0;
Mark Brownc3f13862011-10-25 14:23:53 +0200347
348err_enable:
349 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies);
350
351 return ret;
Mark Brown9e501082010-01-29 18:20:29 +0000352}
353#endif
354
355#ifdef CONFIG_REGULATOR
356static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
357{
358 struct wm8994_ldo_pdata *ldo_pdata;
359
360 if (!pdata)
361 return 0;
362
363 ldo_pdata = &pdata->ldo[ldo];
364
365 if (!ldo_pdata->init_data)
366 return 0;
367
368 return ldo_pdata->init_data->num_consumer_supplies != 0;
369}
370#else
371static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
372{
373 return 0;
374}
375#endif
376
Bill Pembertona73e5df2012-11-19 13:25:09 -0500377static const struct reg_default wm8994_revc_patch[] = {
Mark Brown462835e2012-01-21 12:11:53 +0000378 { 0x102, 0x3 },
379 { 0x56, 0x3 },
380 { 0x817, 0x0 },
381 { 0x102, 0x0 },
382};
383
Bill Pembertona73e5df2012-11-19 13:25:09 -0500384static const struct reg_default wm8958_reva_patch[] = {
Mark Brown462835e2012-01-21 12:11:53 +0000385 { 0x102, 0x3 },
386 { 0xcb, 0x81 },
387 { 0x817, 0x0 },
388 { 0x102, 0x0 },
389};
390
Bill Pembertona73e5df2012-11-19 13:25:09 -0500391static const struct reg_default wm1811_reva_patch[] = {
Mark Brown462835e2012-01-21 12:11:53 +0000392 { 0x102, 0x3 },
Mark Brown9282a7b2012-08-23 16:10:29 +0100393 { 0x56, 0xc07 },
Mark Brown462835e2012-01-21 12:11:53 +0000394 { 0x5d, 0x7e },
395 { 0x5e, 0x0 },
396 { 0x102, 0x0 },
397};
398
Mark Brown9e501082010-01-29 18:20:29 +0000399/*
400 * Instantiate the generic non-control parts of the device.
401 */
Bill Pembertonf791be42012-11-19 13:23:04 -0500402static int wm8994_device_init(struct wm8994 *wm8994, int irq)
Mark Brown9e501082010-01-29 18:20:29 +0000403{
Mark Browna8a8fc22012-10-08 11:21:09 +0900404 struct wm8994_pdata *pdata;
Mark Brown34697892011-12-03 17:10:32 +0000405 struct regmap_config *regmap_config;
Mark Brown462835e2012-01-21 12:11:53 +0000406 const struct reg_default *regmap_patch = NULL;
Mark Brown559e0df2010-08-31 19:25:12 +0100407 const char *devname;
Jingoo Han222bc782013-02-20 11:53:36 +0900408 int ret, i, patch_regs = 0;
Mark Brown26c34c22011-11-03 13:20:38 +0000409 int pulls = 0;
Mark Brown9e501082010-01-29 18:20:29 +0000410
Mark Browna8a8fc22012-10-08 11:21:09 +0900411 if (dev_get_platdata(wm8994->dev)) {
412 pdata = dev_get_platdata(wm8994->dev);
413 wm8994->pdata = *pdata;
414 }
415 pdata = &wm8994->pdata;
416
Mark Brown9e501082010-01-29 18:20:29 +0000417 dev_set_drvdata(wm8994->dev, wm8994);
418
419 /* Add the on-chip regulators first for bootstrapping */
420 ret = mfd_add_devices(wm8994->dev, -1,
421 wm8994_regulator_devs,
422 ARRAY_SIZE(wm8994_regulator_devs),
Mark Brown55692af2012-09-11 15:16:36 +0800423 NULL, 0, NULL);
Mark Brown9e501082010-01-29 18:20:29 +0000424 if (ret != 0) {
425 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
Mark Brown9db42492012-01-30 20:06:05 +0000426 goto err;
Mark Brown9e501082010-01-29 18:20:29 +0000427 }
428
Mark Brown559e0df2010-08-31 19:25:12 +0100429 switch (wm8994->type) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800430 case WM1811:
431 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
432 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100433 case WM8994:
434 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
435 break;
436 case WM8958:
437 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
438 break;
439 default:
440 BUG();
Mark Brown9db42492012-01-30 20:06:05 +0000441 goto err;
Mark Brown559e0df2010-08-31 19:25:12 +0100442 }
443
Mark Brown2fa33492011-10-25 13:45:40 +0200444 wm8994->supplies = devm_kzalloc(wm8994->dev,
445 sizeof(struct regulator_bulk_data) *
446 wm8994->num_supplies, GFP_KERNEL);
Axel Linfccbd212010-08-04 09:44:47 +0800447 if (!wm8994->supplies) {
448 ret = -ENOMEM;
Mark Brown9db42492012-01-30 20:06:05 +0000449 goto err;
Axel Linfccbd212010-08-04 09:44:47 +0800450 }
Mark Brown9e501082010-01-29 18:20:29 +0000451
Mark Brown559e0df2010-08-31 19:25:12 +0100452 switch (wm8994->type) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800453 case WM1811:
454 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
455 wm8994->supplies[i].supply = wm1811_main_supplies[i];
456 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100457 case WM8994:
458 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
459 wm8994->supplies[i].supply = wm8994_main_supplies[i];
460 break;
461 case WM8958:
462 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
463 wm8994->supplies[i].supply = wm8958_main_supplies[i];
464 break;
465 default:
466 BUG();
Mark Brown9db42492012-01-30 20:06:05 +0000467 goto err;
Mark Brown559e0df2010-08-31 19:25:12 +0100468 }
469
Sachin Kamatf1c68e42013-01-08 14:01:22 +0530470 ret = devm_regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000471 wm8994->supplies);
472 if (ret != 0) {
473 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
Mark Brown9db42492012-01-30 20:06:05 +0000474 goto err;
Mark Brown9e501082010-01-29 18:20:29 +0000475 }
476
Mark Brown559e0df2010-08-31 19:25:12 +0100477 ret = regulator_bulk_enable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000478 wm8994->supplies);
479 if (ret != 0) {
480 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
Sachin Kamatf1c68e42013-01-08 14:01:22 +0530481 goto err;
Mark Brown9e501082010-01-29 18:20:29 +0000482 }
483
484 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
485 if (ret < 0) {
486 dev_err(wm8994->dev, "Failed to read ID register\n");
487 goto err_enable;
488 }
Mark Brown559e0df2010-08-31 19:25:12 +0100489 switch (ret) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800490 case 0x1811:
491 devname = "WM1811";
492 if (wm8994->type != WM1811)
493 dev_warn(wm8994->dev, "Device registered as type %d\n",
494 wm8994->type);
495 wm8994->type = WM1811;
496 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100497 case 0x8994:
498 devname = "WM8994";
499 if (wm8994->type != WM8994)
500 dev_warn(wm8994->dev, "Device registered as type %d\n",
501 wm8994->type);
502 wm8994->type = WM8994;
503 break;
504 case 0x8958:
505 devname = "WM8958";
506 if (wm8994->type != WM8958)
507 dev_warn(wm8994->dev, "Device registered as type %d\n",
508 wm8994->type);
509 wm8994->type = WM8958;
510 break;
511 default:
Mark Brown9e501082010-01-29 18:20:29 +0000512 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
513 ret);
514 ret = -EINVAL;
515 goto err_enable;
516 }
517
518 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
519 if (ret < 0) {
520 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
521 ret);
522 goto err_enable;
523 }
Mark Browncc7a7272012-05-07 10:03:22 +0100524 wm8994->revision = ret & WM8994_CHIP_REV_MASK;
525 wm8994->cust_id = (ret & WM8994_CUST_ID_MASK) >> WM8994_CUST_ID_SHIFT;
Mark Brown9e501082010-01-29 18:20:29 +0000526
Mark Browna2495bc2011-06-02 19:18:55 +0100527 switch (wm8994->type) {
528 case WM8994:
Mark Brown7ed58492011-12-01 13:55:49 +0000529 switch (wm8994->revision) {
Mark Browna2495bc2011-06-02 19:18:55 +0100530 case 0:
531 case 1:
Mark Brown559e0df2010-08-31 19:25:12 +0100532 dev_warn(wm8994->dev,
533 "revision %c not fully supported\n",
Mark Brown7ed58492011-12-01 13:55:49 +0000534 'A' + wm8994->revision);
Mark Browna2495bc2011-06-02 19:18:55 +0100535 break;
Mark Brown462835e2012-01-21 12:11:53 +0000536 case 2:
537 case 3:
Mark Brownd54e17f2012-11-27 15:23:30 +0000538 default:
Mark Brown462835e2012-01-21 12:11:53 +0000539 regmap_patch = wm8994_revc_patch;
540 patch_regs = ARRAY_SIZE(wm8994_revc_patch);
541 break;
Mark Browna2495bc2011-06-02 19:18:55 +0100542 }
Mark Brown9e501082010-01-29 18:20:29 +0000543 break;
Mark Brown462835e2012-01-21 12:11:53 +0000544
545 case WM8958:
546 switch (wm8994->revision) {
547 case 0:
548 regmap_patch = wm8958_reva_patch;
549 patch_regs = ARRAY_SIZE(wm8958_reva_patch);
550 break;
551 default:
552 break;
553 }
554 break;
555
Mark Brown443e67e2011-11-30 16:51:04 +0000556 case WM1811:
557 /* Revision C did not change the relevant layer */
Mark Brown7ed58492011-12-01 13:55:49 +0000558 if (wm8994->revision > 1)
559 wm8994->revision++;
Mark Brownd54e17f2012-11-27 15:23:30 +0000560
561 regmap_patch = wm1811_reva_patch;
562 patch_regs = ARRAY_SIZE(wm1811_reva_patch);
Mark Brown443e67e2011-11-30 16:51:04 +0000563 break;
Mark Brown462835e2012-01-21 12:11:53 +0000564
Mark Brown9e501082010-01-29 18:20:29 +0000565 default:
Mark Brown9e501082010-01-29 18:20:29 +0000566 break;
567 }
568
Mark Browncc7a7272012-05-07 10:03:22 +0100569 dev_info(wm8994->dev, "%s revision %c CUST_ID %02x\n", devname,
570 'A' + wm8994->revision, wm8994->cust_id);
Mark Brown9e501082010-01-29 18:20:29 +0000571
Mark Brown34697892011-12-03 17:10:32 +0000572 switch (wm8994->type) {
573 case WM1811:
574 regmap_config = &wm1811_regmap_config;
575 break;
576 case WM8994:
577 regmap_config = &wm8994_regmap_config;
578 break;
579 case WM8958:
580 regmap_config = &wm8958_regmap_config;
581 break;
582 default:
583 dev_err(wm8994->dev, "Unknown device type %d\n", wm8994->type);
584 return -EINVAL;
585 }
586
587 ret = regmap_reinit_cache(wm8994->regmap, regmap_config);
588 if (ret != 0) {
589 dev_err(wm8994->dev, "Failed to reinit register cache: %d\n",
590 ret);
591 return ret;
592 }
Mark Brown9e501082010-01-29 18:20:29 +0000593
Mark Brown462835e2012-01-21 12:11:53 +0000594 if (regmap_patch) {
595 ret = regmap_register_patch(wm8994->regmap, regmap_patch,
596 patch_regs);
597 if (ret != 0) {
598 dev_err(wm8994->dev, "Failed to register patch: %d\n",
599 ret);
Mark Brown9db42492012-01-30 20:06:05 +0000600 goto err;
Mark Brown462835e2012-01-21 12:11:53 +0000601 }
602 }
603
Mark Browna8a8fc22012-10-08 11:21:09 +0900604 wm8994->irq_base = pdata->irq_base;
605 wm8994->gpio_base = pdata->gpio_base;
Mark Brown9e501082010-01-29 18:20:29 +0000606
Mark Browna8a8fc22012-10-08 11:21:09 +0900607 /* GPIO configuration is only applied if it's non-zero */
608 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
609 if (pdata->gpio_defaults[i]) {
610 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
611 0xffff, pdata->gpio_defaults[i]);
Mark Brown9e501082010-01-29 18:20:29 +0000612 }
613 }
614
Mark Browna8a8fc22012-10-08 11:21:09 +0900615 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
616
617 if (pdata->spkmode_pu)
618 pulls |= WM8994_SPKMODE_PU;
619
Mark Brown26c34c22011-11-03 13:20:38 +0000620 /* Disable unneeded pulls */
Mark Brown881de672011-08-22 15:43:55 +0200621 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
Mark Brown26c34c22011-11-03 13:20:38 +0000622 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD |
623 WM8994_SPKMODE_PU | WM8994_CSNADDR_PD,
624 pulls);
Mark Brown881de672011-08-22 15:43:55 +0200625
Mark Brown9e501082010-01-29 18:20:29 +0000626 /* In some system designs where the regulators are not in use,
627 * we can achieve a small reduction in leakage currents by
628 * floating LDO outputs. This bit makes no difference if the
629 * LDOs are enabled, it only affects cases where the LDOs were
630 * in operation and are then disabled.
631 */
632 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
633 if (wm8994_ldo_in_use(pdata, i))
634 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
635 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
636 else
637 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
638 WM8994_LDO1_DISCH, 0);
639 }
640
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000641 wm8994_irq_init(wm8994);
642
Mark Brown9e501082010-01-29 18:20:29 +0000643 ret = mfd_add_devices(wm8994->dev, -1,
644 wm8994_devs, ARRAY_SIZE(wm8994_devs),
Mark Brown55692af2012-09-11 15:16:36 +0800645 NULL, 0, NULL);
Mark Brown9e501082010-01-29 18:20:29 +0000646 if (ret != 0) {
647 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000648 goto err_irq;
Mark Brown9e501082010-01-29 18:20:29 +0000649 }
650
Mark Brownd450f192010-11-26 17:19:35 +0000651 pm_runtime_enable(wm8994->dev);
Mark Brownee67b0c2012-02-06 18:47:37 +0000652 pm_runtime_idle(wm8994->dev);
Mark Brownd450f192010-11-26 17:19:35 +0000653
Mark Brown9e501082010-01-29 18:20:29 +0000654 return 0;
655
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000656err_irq:
657 wm8994_irq_exit(wm8994);
Mark Brown9e501082010-01-29 18:20:29 +0000658err_enable:
Mark Brown559e0df2010-08-31 19:25:12 +0100659 regulator_bulk_disable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000660 wm8994->supplies);
Mark Brown9db42492012-01-30 20:06:05 +0000661err:
Mark Brown9e501082010-01-29 18:20:29 +0000662 mfd_remove_devices(wm8994->dev);
Mark Brown9e501082010-01-29 18:20:29 +0000663 return ret;
664}
665
Bill Pemberton4740f732012-11-19 13:26:01 -0500666static void wm8994_device_exit(struct wm8994 *wm8994)
Mark Brown9e501082010-01-29 18:20:29 +0000667{
Mark Brownd450f192010-11-26 17:19:35 +0000668 pm_runtime_disable(wm8994->dev);
Mark Brown9e501082010-01-29 18:20:29 +0000669 mfd_remove_devices(wm8994->dev);
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000670 wm8994_irq_exit(wm8994);
Mark Brown559e0df2010-08-31 19:25:12 +0100671 regulator_bulk_disable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000672 wm8994->supplies);
Mark Brown9e501082010-01-29 18:20:29 +0000673}
674
Mark Browncf763c22011-11-22 18:22:29 +0000675static const struct of_device_id wm8994_of_match[] = {
676 { .compatible = "wlf,wm1811", },
677 { .compatible = "wlf,wm8994", },
678 { .compatible = "wlf,wm8958", },
679 { }
680};
681MODULE_DEVICE_TABLE(of, wm8994_of_match);
682
Bill Pembertonf791be42012-11-19 13:23:04 -0500683static int wm8994_i2c_probe(struct i2c_client *i2c,
Mark Brown027d6762012-02-17 15:57:01 -0800684 const struct i2c_device_id *id)
Mark Brown9e501082010-01-29 18:20:29 +0000685{
686 struct wm8994 *wm8994;
Mark Brownd6c645fc2011-06-17 13:02:27 +0100687 int ret;
Mark Brown9e501082010-01-29 18:20:29 +0000688
Mark Brown2fa33492011-10-25 13:45:40 +0200689 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL);
Axel Lind0a11692010-08-09 14:52:16 +0800690 if (wm8994 == NULL)
Mark Brown9e501082010-01-29 18:20:29 +0000691 return -ENOMEM;
Mark Brown9e501082010-01-29 18:20:29 +0000692
693 i2c_set_clientdata(i2c, wm8994);
694 wm8994->dev = &i2c->dev;
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000695 wm8994->irq = i2c->irq;
Mark Brown559e0df2010-08-31 19:25:12 +0100696 wm8994->type = id->driver_data;
Mark Brown9e501082010-01-29 18:20:29 +0000697
Mark Brown9db42492012-01-30 20:06:05 +0000698 wm8994->regmap = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config);
Mark Brownd6c645fc2011-06-17 13:02:27 +0100699 if (IS_ERR(wm8994->regmap)) {
700 ret = PTR_ERR(wm8994->regmap);
701 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
702 ret);
Mark Brownd6c645fc2011-06-17 13:02:27 +0100703 return ret;
704 }
705
Mark Brown559e0df2010-08-31 19:25:12 +0100706 return wm8994_device_init(wm8994, i2c->irq);
Mark Brown9e501082010-01-29 18:20:29 +0000707}
708
Bill Pemberton4740f732012-11-19 13:26:01 -0500709static int wm8994_i2c_remove(struct i2c_client *i2c)
Mark Brown9e501082010-01-29 18:20:29 +0000710{
711 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
712
713 wm8994_device_exit(wm8994);
714
715 return 0;
716}
717
Mark Brown9e501082010-01-29 18:20:29 +0000718static const struct i2c_device_id wm8994_i2c_id[] = {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800719 { "wm1811", WM1811 },
Mark Brown71d17182011-11-30 20:16:42 +0000720 { "wm1811a", WM1811 },
Mark Brown559e0df2010-08-31 19:25:12 +0100721 { "wm8994", WM8994 },
722 { "wm8958", WM8958 },
Mark Brown9e501082010-01-29 18:20:29 +0000723 { }
724};
725MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
726
Mark Brown63946782013-03-22 12:40:22 +0100727static const struct dev_pm_ops wm8994_pm_ops = {
728 SET_RUNTIME_PM_OPS(wm8994_suspend, wm8994_resume, NULL)
729};
Mark Brownd450f192010-11-26 17:19:35 +0000730
Mark Brown9e501082010-01-29 18:20:29 +0000731static struct i2c_driver wm8994_i2c_driver = {
732 .driver = {
Mark Brownd450f192010-11-26 17:19:35 +0000733 .name = "wm8994",
734 .owner = THIS_MODULE,
735 .pm = &wm8994_pm_ops,
Mark Browncf763c22011-11-22 18:22:29 +0000736 .of_match_table = wm8994_of_match,
Mark Brown9e501082010-01-29 18:20:29 +0000737 },
738 .probe = wm8994_i2c_probe,
Bill Pemberton84449212012-11-19 13:20:24 -0500739 .remove = wm8994_i2c_remove,
Mark Brown9e501082010-01-29 18:20:29 +0000740 .id_table = wm8994_i2c_id,
741};
742
Mark Brownceb57d22012-05-07 10:03:23 +0100743module_i2c_driver(wm8994_i2c_driver);
Mark Brown9e501082010-01-29 18:20:29 +0000744
745MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
746MODULE_LICENSE("GPL");
747MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");