blob: 7eec619a6023c717803d05e318537e0589f6967e [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 Brown20fb2772013-04-11 18:11:51 +010022#include <linux/of.h>
23#include <linux/of_device.h>
24#include <linux/of_gpio.h>
Mark Brownd450f192010-11-26 17:19:35 +000025#include <linux/pm_runtime.h>
Mark Brownd6c645fc2011-06-17 13:02:27 +010026#include <linux/regmap.h>
Mark Brown9e501082010-01-29 18:20:29 +000027#include <linux/regulator/consumer.h>
28#include <linux/regulator/machine.h>
29
30#include <linux/mfd/wm8994/core.h>
31#include <linux/mfd/wm8994/pdata.h>
32#include <linux/mfd/wm8994/registers.h>
33
Mark Brownc3f13862011-10-25 14:23:53 +020034#include "wm8994.h"
Mark Brown9e501082010-01-29 18:20:29 +000035
Geert Uytterhoevenad59de42013-11-18 14:33:04 +010036static const struct mfd_cell wm8994_regulator_devs[] = {
Mark Brownd450f192010-11-26 17:19:35 +000037 {
38 .name = "wm8994-ldo",
Inha Songfef22cb2015-01-08 10:04:33 +090039 .id = 0,
Mark Brownd450f192010-11-26 17:19:35 +000040 .pm_runtime_no_callbacks = true,
41 },
42 {
43 .name = "wm8994-ldo",
Inha Songfef22cb2015-01-08 10:04:33 +090044 .id = 1,
Mark Brownd450f192010-11-26 17:19:35 +000045 .pm_runtime_no_callbacks = true,
46 },
Mark Brown9e501082010-01-29 18:20:29 +000047};
48
Mark Brownc9fbf7e2010-03-26 16:49:15 +000049static struct resource wm8994_codec_resources[] = {
50 {
51 .start = WM8994_IRQ_TEMP_SHUT,
52 .end = WM8994_IRQ_TEMP_WARN,
53 .flags = IORESOURCE_IRQ,
54 },
55};
56
57static struct resource wm8994_gpio_resources[] = {
58 {
59 .start = WM8994_IRQ_GPIO(1),
60 .end = WM8994_IRQ_GPIO(11),
61 .flags = IORESOURCE_IRQ,
62 },
63};
64
Geert Uytterhoevenad59de42013-11-18 14:33:04 +010065static const struct mfd_cell wm8994_devs[] = {
Mark Brownc9fbf7e2010-03-26 16:49:15 +000066 {
67 .name = "wm8994-codec",
68 .num_resources = ARRAY_SIZE(wm8994_codec_resources),
69 .resources = wm8994_codec_resources,
70 },
71
72 {
73 .name = "wm8994-gpio",
74 .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
75 .resources = wm8994_gpio_resources,
Mark Brownd450f192010-11-26 17:19:35 +000076 .pm_runtime_no_callbacks = true,
Mark Brownc9fbf7e2010-03-26 16:49:15 +000077 },
Mark Brown9e501082010-01-29 18:20:29 +000078};
79
80/*
81 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
82 * and should be handled via the standard regulator API supply
83 * management.
84 */
Mark Brownb1f43bf2011-05-24 17:35:40 +080085static const char *wm1811_main_supplies[] = {
86 "DBVDD1",
87 "DBVDD2",
88 "DBVDD3",
89 "DCVDD",
90 "AVDD1",
91 "AVDD2",
92 "CPVDD",
93 "SPKVDD1",
94 "SPKVDD2",
95};
96
Mark Brown9e501082010-01-29 18:20:29 +000097static const char *wm8994_main_supplies[] = {
98 "DBVDD",
99 "DCVDD",
100 "AVDD1",
101 "AVDD2",
102 "CPVDD",
103 "SPKVDD1",
104 "SPKVDD2",
105};
106
Mark Brown559e0df2010-08-31 19:25:12 +0100107static const char *wm8958_main_supplies[] = {
108 "DBVDD1",
109 "DBVDD2",
110 "DBVDD3",
111 "DCVDD",
112 "AVDD1",
113 "AVDD2",
114 "CPVDD",
115 "SPKVDD1",
116 "SPKVDD2",
117};
118
Rafael J. Wysocki48bb9fe2014-12-05 03:04:12 +0100119#ifdef CONFIG_PM
Mark Brownd450f192010-11-26 17:19:35 +0000120static int wm8994_suspend(struct device *dev)
Mark Brown9e501082010-01-29 18:20:29 +0000121{
122 struct wm8994 *wm8994 = dev_get_drvdata(dev);
123 int ret;
124
Mark Brown77bd70e2011-02-04 14:57:43 +0000125 /* Don't actually go through with the suspend if the CODEC is
Mark Brownebe38f82013-07-17 13:16:09 +0100126 * still active for accessory detect. */
Mark Brown5f40c6b2011-08-13 14:37:48 +0900127 switch (wm8994->type) {
128 case WM8958:
Mark Brownb5488b62011-11-04 23:14:46 +0000129 case WM1811:
Mark Brown5f40c6b2011-08-13 14:37:48 +0900130 ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1);
131 if (ret < 0) {
132 dev_err(dev, "Failed to read power status: %d\n", ret);
133 } else if (ret & WM8958_MICD_ENA) {
134 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
135 return 0;
136 }
137 break;
138 default:
139 break;
140 }
141
Mark Brown881de672011-08-22 15:43:55 +0200142 /* Disable LDO pulldowns while the device is suspended if we
143 * don't know that something will be driving them. */
144 if (!wm8994->ldo_ena_always_driven)
145 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
146 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
147 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD);
148
Mark Brownf40dff92011-02-21 18:30:31 +0000149 /* Explicitly put the device into reset in case regulators
150 * don't get disabled in order to ensure consistent restart.
151 */
Mark Brownbe79cf22011-10-25 13:25:43 +0200152 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET,
153 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
Mark Brownf40dff92011-02-21 18:30:31 +0000154
Mark Browned393dc2012-06-29 14:55:39 +0100155 regcache_mark_dirty(wm8994->regmap);
156
Chris Rattray78a27cd2012-06-12 00:43:35 +0800157 /* Restore GPIO registers to prevent problems with mismatched
158 * pin configurations.
159 */
Mark Browned393dc2012-06-29 14:55:39 +0100160 ret = regcache_sync_region(wm8994->regmap, WM8994_GPIO_1,
161 WM8994_GPIO_11);
Chris Rattray78a27cd2012-06-12 00:43:35 +0800162 if (ret != 0)
163 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
164
Mark Brown1a2017b2012-06-29 14:55:40 +0100165 /* In case one of the GPIOs is used as a wake input. */
166 ret = regcache_sync_region(wm8994->regmap,
167 WM8994_INTERRUPT_STATUS_1_MASK,
168 WM8994_INTERRUPT_STATUS_1_MASK);
169 if (ret != 0)
170 dev_err(dev, "Failed to restore interrupt mask: %d\n", ret);
171
Mark Brown3befc922012-01-09 00:36:42 -0800172 regcache_cache_only(wm8994->regmap, true);
Mark Brown77bd70e2011-02-04 14:57:43 +0000173 wm8994->suspended = true;
174
Mark Brown559e0df2010-08-31 19:25:12 +0100175 ret = regulator_bulk_disable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000176 wm8994->supplies);
177 if (ret != 0) {
178 dev_err(dev, "Failed to disable supplies: %d\n", ret);
179 return ret;
180 }
181
182 return 0;
183}
184
Mark Brownd450f192010-11-26 17:19:35 +0000185static int wm8994_resume(struct device *dev)
Mark Brown9e501082010-01-29 18:20:29 +0000186{
187 struct wm8994 *wm8994 = dev_get_drvdata(dev);
Mark Brownc3f13862011-10-25 14:23:53 +0200188 int ret;
Mark Brown9e501082010-01-29 18:20:29 +0000189
Mark Brown77bd70e2011-02-04 14:57:43 +0000190 /* We may have lied to the PM core about suspending */
191 if (!wm8994->suspended)
192 return 0;
193
Mark Brown559e0df2010-08-31 19:25:12 +0100194 ret = regulator_bulk_enable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000195 wm8994->supplies);
196 if (ret != 0) {
197 dev_err(dev, "Failed to enable supplies: %d\n", ret);
198 return ret;
199 }
200
Mark Brown3befc922012-01-09 00:36:42 -0800201 regcache_cache_only(wm8994->regmap, false);
Mark Brownc3f13862011-10-25 14:23:53 +0200202 ret = regcache_sync(wm8994->regmap);
203 if (ret != 0) {
204 dev_err(dev, "Failed to restore register map: %d\n", ret);
205 goto err_enable;
Mark Brown98ae1cc2011-06-07 11:49:42 +0100206 }
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000207
Mark Brown881de672011-08-22 15:43:55 +0200208 /* Disable LDO pulldowns while the device is active */
209 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
210 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
211 0);
212
Mark Brown77bd70e2011-02-04 14:57:43 +0000213 wm8994->suspended = false;
214
Mark Brown9e501082010-01-29 18:20:29 +0000215 return 0;
Mark Brownc3f13862011-10-25 14:23:53 +0200216
217err_enable:
218 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies);
219
220 return ret;
Mark Brown9e501082010-01-29 18:20:29 +0000221}
222#endif
223
224#ifdef CONFIG_REGULATOR
225static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
226{
227 struct wm8994_ldo_pdata *ldo_pdata;
228
229 if (!pdata)
230 return 0;
231
232 ldo_pdata = &pdata->ldo[ldo];
233
234 if (!ldo_pdata->init_data)
235 return 0;
236
237 return ldo_pdata->init_data->num_consumer_supplies != 0;
238}
239#else
240static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
241{
242 return 0;
243}
244#endif
245
Nariman Poushin8019ff62015-07-16 16:36:21 +0100246static const struct reg_sequence wm8994_revc_patch[] = {
Mark Brown462835e2012-01-21 12:11:53 +0000247 { 0x102, 0x3 },
248 { 0x56, 0x3 },
249 { 0x817, 0x0 },
250 { 0x102, 0x0 },
251};
252
Nariman Poushin8019ff62015-07-16 16:36:21 +0100253static const struct reg_sequence wm8958_reva_patch[] = {
Mark Brown462835e2012-01-21 12:11:53 +0000254 { 0x102, 0x3 },
255 { 0xcb, 0x81 },
256 { 0x817, 0x0 },
257 { 0x102, 0x0 },
258};
259
Nariman Poushin8019ff62015-07-16 16:36:21 +0100260static const struct reg_sequence wm1811_reva_patch[] = {
Mark Brown462835e2012-01-21 12:11:53 +0000261 { 0x102, 0x3 },
Mark Brown9282a7b2012-08-23 16:10:29 +0100262 { 0x56, 0xc07 },
Mark Brown462835e2012-01-21 12:11:53 +0000263 { 0x5d, 0x7e },
264 { 0x5e, 0x0 },
265 { 0x102, 0x0 },
266};
267
Mark Brown20fb2772013-04-11 18:11:51 +0100268#ifdef CONFIG_OF
269static int wm8994_set_pdata_from_of(struct wm8994 *wm8994)
270{
271 struct device_node *np = wm8994->dev->of_node;
272 struct wm8994_pdata *pdata = &wm8994->pdata;
273 int i;
274
275 if (!np)
276 return 0;
277
278 if (of_property_read_u32_array(np, "wlf,gpio-cfg", pdata->gpio_defaults,
279 ARRAY_SIZE(pdata->gpio_defaults)) >= 0) {
280 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
281 if (wm8994->pdata.gpio_defaults[i] == 0)
282 pdata->gpio_defaults[i]
283 = WM8994_CONFIGURE_GPIO;
284 }
285 }
286
287 of_property_read_u32_array(np, "wlf,micbias-cfg", pdata->micbias,
288 ARRAY_SIZE(pdata->micbias));
289
290 pdata->lineout1_diff = true;
291 pdata->lineout2_diff = true;
292 if (of_find_property(np, "wlf,lineout1-se", NULL))
293 pdata->lineout1_diff = false;
294 if (of_find_property(np, "wlf,lineout2-se", NULL))
295 pdata->lineout2_diff = false;
296
297 if (of_find_property(np, "wlf,lineout1-feedback", NULL))
298 pdata->lineout1fb = true;
299 if (of_find_property(np, "wlf,lineout2-feedback", NULL))
300 pdata->lineout2fb = true;
301
302 if (of_find_property(np, "wlf,ldoena-always-driven", NULL))
303 pdata->lineout2fb = true;
304
305 pdata->ldo[0].enable = of_get_named_gpio(np, "wlf,ldo1ena", 0);
306 if (pdata->ldo[0].enable < 0)
307 pdata->ldo[0].enable = 0;
308
309 pdata->ldo[1].enable = of_get_named_gpio(np, "wlf,ldo2ena", 0);
310 if (pdata->ldo[1].enable < 0)
311 pdata->ldo[1].enable = 0;
312
313 return 0;
314}
315#else
316static int wm8994_set_pdata_from_of(struct wm8994 *wm8994)
317{
318 return 0;
319}
320#endif
321
Mark Brown9e501082010-01-29 18:20:29 +0000322/*
323 * Instantiate the generic non-control parts of the device.
324 */
Bill Pembertonf791be42012-11-19 13:23:04 -0500325static int wm8994_device_init(struct wm8994 *wm8994, int irq)
Mark Brown9e501082010-01-29 18:20:29 +0000326{
Mark Browna8a8fc22012-10-08 11:21:09 +0900327 struct wm8994_pdata *pdata;
Mark Brown34697892011-12-03 17:10:32 +0000328 struct regmap_config *regmap_config;
Nariman Poushin8019ff62015-07-16 16:36:21 +0100329 const struct reg_sequence *regmap_patch = NULL;
Mark Brown559e0df2010-08-31 19:25:12 +0100330 const char *devname;
Jingoo Han222bc782013-02-20 11:53:36 +0900331 int ret, i, patch_regs = 0;
Mark Brown26c34c22011-11-03 13:20:38 +0000332 int pulls = 0;
Mark Brown9e501082010-01-29 18:20:29 +0000333
Mark Browna8a8fc22012-10-08 11:21:09 +0900334 if (dev_get_platdata(wm8994->dev)) {
335 pdata = dev_get_platdata(wm8994->dev);
336 wm8994->pdata = *pdata;
337 }
338 pdata = &wm8994->pdata;
339
Mark Brown20fb2772013-04-11 18:11:51 +0100340 ret = wm8994_set_pdata_from_of(wm8994);
341 if (ret != 0)
342 return ret;
343
Mark Brown9e501082010-01-29 18:20:29 +0000344 dev_set_drvdata(wm8994->dev, wm8994);
345
346 /* Add the on-chip regulators first for bootstrapping */
Inha Songfef22cb2015-01-08 10:04:33 +0900347 ret = mfd_add_devices(wm8994->dev, 0,
Mark Brown9e501082010-01-29 18:20:29 +0000348 wm8994_regulator_devs,
349 ARRAY_SIZE(wm8994_regulator_devs),
Mark Brown55692af2012-09-11 15:16:36 +0800350 NULL, 0, NULL);
Mark Brown9e501082010-01-29 18:20:29 +0000351 if (ret != 0) {
352 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
Mark Brown9db42492012-01-30 20:06:05 +0000353 goto err;
Mark Brown9e501082010-01-29 18:20:29 +0000354 }
355
Mark Brown559e0df2010-08-31 19:25:12 +0100356 switch (wm8994->type) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800357 case WM1811:
358 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
359 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100360 case WM8994:
361 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
362 break;
363 case WM8958:
364 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
365 break;
366 default:
367 BUG();
Mark Brown9db42492012-01-30 20:06:05 +0000368 goto err;
Mark Brown559e0df2010-08-31 19:25:12 +0100369 }
370
Mark Brown2fa33492011-10-25 13:45:40 +0200371 wm8994->supplies = devm_kzalloc(wm8994->dev,
372 sizeof(struct regulator_bulk_data) *
373 wm8994->num_supplies, GFP_KERNEL);
Axel Linfccbd212010-08-04 09:44:47 +0800374 if (!wm8994->supplies) {
375 ret = -ENOMEM;
Mark Brown9db42492012-01-30 20:06:05 +0000376 goto err;
Axel Linfccbd212010-08-04 09:44:47 +0800377 }
Mark Brown9e501082010-01-29 18:20:29 +0000378
Mark Brown559e0df2010-08-31 19:25:12 +0100379 switch (wm8994->type) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800380 case WM1811:
381 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
382 wm8994->supplies[i].supply = wm1811_main_supplies[i];
383 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100384 case WM8994:
385 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
386 wm8994->supplies[i].supply = wm8994_main_supplies[i];
387 break;
388 case WM8958:
389 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
390 wm8994->supplies[i].supply = wm8958_main_supplies[i];
391 break;
392 default:
393 BUG();
Mark Brown9db42492012-01-30 20:06:05 +0000394 goto err;
Mark Brown559e0df2010-08-31 19:25:12 +0100395 }
396
Sachin Kamatf1c68e42013-01-08 14:01:22 +0530397 ret = devm_regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000398 wm8994->supplies);
399 if (ret != 0) {
400 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
Mark Brown9db42492012-01-30 20:06:05 +0000401 goto err;
Mark Brown9e501082010-01-29 18:20:29 +0000402 }
403
Mark Brown559e0df2010-08-31 19:25:12 +0100404 ret = regulator_bulk_enable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000405 wm8994->supplies);
406 if (ret != 0) {
407 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
Sachin Kamatf1c68e42013-01-08 14:01:22 +0530408 goto err;
Mark Brown9e501082010-01-29 18:20:29 +0000409 }
410
411 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
412 if (ret < 0) {
413 dev_err(wm8994->dev, "Failed to read ID register\n");
414 goto err_enable;
415 }
Mark Brown559e0df2010-08-31 19:25:12 +0100416 switch (ret) {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800417 case 0x1811:
418 devname = "WM1811";
419 if (wm8994->type != WM1811)
420 dev_warn(wm8994->dev, "Device registered as type %d\n",
421 wm8994->type);
422 wm8994->type = WM1811;
423 break;
Mark Brown559e0df2010-08-31 19:25:12 +0100424 case 0x8994:
425 devname = "WM8994";
426 if (wm8994->type != WM8994)
427 dev_warn(wm8994->dev, "Device registered as type %d\n",
428 wm8994->type);
429 wm8994->type = WM8994;
430 break;
431 case 0x8958:
432 devname = "WM8958";
433 if (wm8994->type != WM8958)
434 dev_warn(wm8994->dev, "Device registered as type %d\n",
435 wm8994->type);
436 wm8994->type = WM8958;
437 break;
438 default:
Mark Brown9e501082010-01-29 18:20:29 +0000439 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
440 ret);
441 ret = -EINVAL;
442 goto err_enable;
443 }
444
445 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
446 if (ret < 0) {
447 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
448 ret);
449 goto err_enable;
450 }
Mark Browncc7a7272012-05-07 10:03:22 +0100451 wm8994->revision = ret & WM8994_CHIP_REV_MASK;
452 wm8994->cust_id = (ret & WM8994_CUST_ID_MASK) >> WM8994_CUST_ID_SHIFT;
Mark Brown9e501082010-01-29 18:20:29 +0000453
Mark Browna2495bc2011-06-02 19:18:55 +0100454 switch (wm8994->type) {
455 case WM8994:
Mark Brown7ed58492011-12-01 13:55:49 +0000456 switch (wm8994->revision) {
Mark Browna2495bc2011-06-02 19:18:55 +0100457 case 0:
458 case 1:
Mark Brown559e0df2010-08-31 19:25:12 +0100459 dev_warn(wm8994->dev,
460 "revision %c not fully supported\n",
Mark Brown7ed58492011-12-01 13:55:49 +0000461 'A' + wm8994->revision);
Mark Browna2495bc2011-06-02 19:18:55 +0100462 break;
Mark Brown462835e2012-01-21 12:11:53 +0000463 case 2:
464 case 3:
Mark Brownd54e17f2012-11-27 15:23:30 +0000465 default:
Mark Brown462835e2012-01-21 12:11:53 +0000466 regmap_patch = wm8994_revc_patch;
467 patch_regs = ARRAY_SIZE(wm8994_revc_patch);
468 break;
Mark Browna2495bc2011-06-02 19:18:55 +0100469 }
Mark Brown9e501082010-01-29 18:20:29 +0000470 break;
Mark Brown462835e2012-01-21 12:11:53 +0000471
472 case WM8958:
473 switch (wm8994->revision) {
474 case 0:
475 regmap_patch = wm8958_reva_patch;
476 patch_regs = ARRAY_SIZE(wm8958_reva_patch);
477 break;
478 default:
479 break;
480 }
481 break;
482
Mark Brown443e67e2011-11-30 16:51:04 +0000483 case WM1811:
484 /* Revision C did not change the relevant layer */
Mark Brown7ed58492011-12-01 13:55:49 +0000485 if (wm8994->revision > 1)
486 wm8994->revision++;
Mark Brownd54e17f2012-11-27 15:23:30 +0000487
488 regmap_patch = wm1811_reva_patch;
489 patch_regs = ARRAY_SIZE(wm1811_reva_patch);
Mark Brown443e67e2011-11-30 16:51:04 +0000490 break;
Mark Brown462835e2012-01-21 12:11:53 +0000491
Mark Brown9e501082010-01-29 18:20:29 +0000492 default:
Mark Brown9e501082010-01-29 18:20:29 +0000493 break;
494 }
495
Mark Browncc7a7272012-05-07 10:03:22 +0100496 dev_info(wm8994->dev, "%s revision %c CUST_ID %02x\n", devname,
497 'A' + wm8994->revision, wm8994->cust_id);
Mark Brown9e501082010-01-29 18:20:29 +0000498
Mark Brown34697892011-12-03 17:10:32 +0000499 switch (wm8994->type) {
500 case WM1811:
501 regmap_config = &wm1811_regmap_config;
502 break;
503 case WM8994:
504 regmap_config = &wm8994_regmap_config;
505 break;
506 case WM8958:
507 regmap_config = &wm8958_regmap_config;
508 break;
509 default:
510 dev_err(wm8994->dev, "Unknown device type %d\n", wm8994->type);
511 return -EINVAL;
512 }
513
514 ret = regmap_reinit_cache(wm8994->regmap, regmap_config);
515 if (ret != 0) {
516 dev_err(wm8994->dev, "Failed to reinit register cache: %d\n",
517 ret);
518 return ret;
519 }
Mark Brown9e501082010-01-29 18:20:29 +0000520
Mark Brownf3799e92013-05-17 13:25:21 +0100521 /* Explicitly put the device into reset in case regulators
522 * don't get disabled in order to ensure we know the device
523 * state.
524 */
525 ret = wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET,
526 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
527 if (ret != 0) {
528 dev_err(wm8994->dev, "Failed to reset device: %d\n", ret);
529 return ret;
530 }
531
Mark Brown462835e2012-01-21 12:11:53 +0000532 if (regmap_patch) {
533 ret = regmap_register_patch(wm8994->regmap, regmap_patch,
534 patch_regs);
535 if (ret != 0) {
536 dev_err(wm8994->dev, "Failed to register patch: %d\n",
537 ret);
Mark Brown9db42492012-01-30 20:06:05 +0000538 goto err;
Mark Brown462835e2012-01-21 12:11:53 +0000539 }
540 }
541
Mark Browna8a8fc22012-10-08 11:21:09 +0900542 wm8994->irq_base = pdata->irq_base;
543 wm8994->gpio_base = pdata->gpio_base;
Mark Brown9e501082010-01-29 18:20:29 +0000544
Mark Browna8a8fc22012-10-08 11:21:09 +0900545 /* GPIO configuration is only applied if it's non-zero */
546 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
547 if (pdata->gpio_defaults[i]) {
548 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
549 0xffff, pdata->gpio_defaults[i]);
Mark Brown9e501082010-01-29 18:20:29 +0000550 }
551 }
552
Mark Browna8a8fc22012-10-08 11:21:09 +0900553 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
554
555 if (pdata->spkmode_pu)
556 pulls |= WM8994_SPKMODE_PU;
557
Mark Brown26c34c22011-11-03 13:20:38 +0000558 /* Disable unneeded pulls */
Mark Brown881de672011-08-22 15:43:55 +0200559 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
Mark Brown26c34c22011-11-03 13:20:38 +0000560 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD |
561 WM8994_SPKMODE_PU | WM8994_CSNADDR_PD,
562 pulls);
Mark Brown881de672011-08-22 15:43:55 +0200563
Mark Brown9e501082010-01-29 18:20:29 +0000564 /* In some system designs where the regulators are not in use,
565 * we can achieve a small reduction in leakage currents by
566 * floating LDO outputs. This bit makes no difference if the
567 * LDOs are enabled, it only affects cases where the LDOs were
568 * in operation and are then disabled.
569 */
570 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
571 if (wm8994_ldo_in_use(pdata, i))
572 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
573 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
574 else
575 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
576 WM8994_LDO1_DISCH, 0);
577 }
578
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000579 wm8994_irq_init(wm8994);
580
Mark Brown9e501082010-01-29 18:20:29 +0000581 ret = mfd_add_devices(wm8994->dev, -1,
582 wm8994_devs, ARRAY_SIZE(wm8994_devs),
Mark Brown55692af2012-09-11 15:16:36 +0800583 NULL, 0, NULL);
Mark Brown9e501082010-01-29 18:20:29 +0000584 if (ret != 0) {
585 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000586 goto err_irq;
Mark Brown9e501082010-01-29 18:20:29 +0000587 }
588
Mark Brownd450f192010-11-26 17:19:35 +0000589 pm_runtime_enable(wm8994->dev);
Mark Brownee67b0c2012-02-06 18:47:37 +0000590 pm_runtime_idle(wm8994->dev);
Mark Brownd450f192010-11-26 17:19:35 +0000591
Mark Brown9e501082010-01-29 18:20:29 +0000592 return 0;
593
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000594err_irq:
595 wm8994_irq_exit(wm8994);
Mark Brown9e501082010-01-29 18:20:29 +0000596err_enable:
Mark Brown559e0df2010-08-31 19:25:12 +0100597 regulator_bulk_disable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000598 wm8994->supplies);
Mark Brown9db42492012-01-30 20:06:05 +0000599err:
Mark Brown9e501082010-01-29 18:20:29 +0000600 mfd_remove_devices(wm8994->dev);
Mark Brown9e501082010-01-29 18:20:29 +0000601 return ret;
602}
603
Bill Pemberton4740f732012-11-19 13:26:01 -0500604static void wm8994_device_exit(struct wm8994 *wm8994)
Mark Brown9e501082010-01-29 18:20:29 +0000605{
Mark Brownd450f192010-11-26 17:19:35 +0000606 pm_runtime_disable(wm8994->dev);
Mark Brown9e501082010-01-29 18:20:29 +0000607 mfd_remove_devices(wm8994->dev);
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000608 wm8994_irq_exit(wm8994);
Mark Brown559e0df2010-08-31 19:25:12 +0100609 regulator_bulk_disable(wm8994->num_supplies,
Mark Brown9e501082010-01-29 18:20:29 +0000610 wm8994->supplies);
Mark Brown9e501082010-01-29 18:20:29 +0000611}
612
Mark Browncf763c22011-11-22 18:22:29 +0000613static const struct of_device_id wm8994_of_match[] = {
Mark Brown39aa3b52013-04-11 18:11:50 +0100614 { .compatible = "wlf,wm1811", .data = (void *)WM1811 },
615 { .compatible = "wlf,wm8994", .data = (void *)WM8994 },
616 { .compatible = "wlf,wm8958", .data = (void *)WM8958 },
Mark Browncf763c22011-11-22 18:22:29 +0000617 { }
618};
619MODULE_DEVICE_TABLE(of, wm8994_of_match);
620
Bill Pembertonf791be42012-11-19 13:23:04 -0500621static int wm8994_i2c_probe(struct i2c_client *i2c,
Mark Brown027d6762012-02-17 15:57:01 -0800622 const struct i2c_device_id *id)
Mark Brown9e501082010-01-29 18:20:29 +0000623{
Mark Brown20fb2772013-04-11 18:11:51 +0100624 const struct of_device_id *of_id;
Mark Brown9e501082010-01-29 18:20:29 +0000625 struct wm8994 *wm8994;
Mark Brownd6c645fc2011-06-17 13:02:27 +0100626 int ret;
Mark Brown9e501082010-01-29 18:20:29 +0000627
Mark Brown2fa33492011-10-25 13:45:40 +0200628 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL);
Axel Lind0a11692010-08-09 14:52:16 +0800629 if (wm8994 == NULL)
Mark Brown9e501082010-01-29 18:20:29 +0000630 return -ENOMEM;
Mark Brown9e501082010-01-29 18:20:29 +0000631
632 i2c_set_clientdata(i2c, wm8994);
633 wm8994->dev = &i2c->dev;
Mark Brownc9fbf7e2010-03-26 16:49:15 +0000634 wm8994->irq = i2c->irq;
Mark Brown20fb2772013-04-11 18:11:51 +0100635
636 if (i2c->dev.of_node) {
637 of_id = of_match_device(wm8994_of_match, &i2c->dev);
638 if (of_id)
Lee Jones7f8279c2014-01-23 14:47:13 +0000639 wm8994->type = (enum wm8994_type)of_id->data;
Mark Brown20fb2772013-04-11 18:11:51 +0100640 } else {
641 wm8994->type = id->driver_data;
642 }
Mark Brown9e501082010-01-29 18:20:29 +0000643
Mark Brown9db42492012-01-30 20:06:05 +0000644 wm8994->regmap = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config);
Mark Brownd6c645fc2011-06-17 13:02:27 +0100645 if (IS_ERR(wm8994->regmap)) {
646 ret = PTR_ERR(wm8994->regmap);
647 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
648 ret);
Mark Brownd6c645fc2011-06-17 13:02:27 +0100649 return ret;
650 }
651
Mark Brown559e0df2010-08-31 19:25:12 +0100652 return wm8994_device_init(wm8994, i2c->irq);
Mark Brown9e501082010-01-29 18:20:29 +0000653}
654
Bill Pemberton4740f732012-11-19 13:26:01 -0500655static int wm8994_i2c_remove(struct i2c_client *i2c)
Mark Brown9e501082010-01-29 18:20:29 +0000656{
657 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
658
659 wm8994_device_exit(wm8994);
660
661 return 0;
662}
663
Mark Brown9e501082010-01-29 18:20:29 +0000664static const struct i2c_device_id wm8994_i2c_id[] = {
Mark Brownb1f43bf2011-05-24 17:35:40 +0800665 { "wm1811", WM1811 },
Mark Brown71d17182011-11-30 20:16:42 +0000666 { "wm1811a", WM1811 },
Mark Brown559e0df2010-08-31 19:25:12 +0100667 { "wm8994", WM8994 },
668 { "wm8958", WM8958 },
Mark Brown9e501082010-01-29 18:20:29 +0000669 { }
670};
671MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
672
Mark Brown63946782013-03-22 12:40:22 +0100673static const struct dev_pm_ops wm8994_pm_ops = {
674 SET_RUNTIME_PM_OPS(wm8994_suspend, wm8994_resume, NULL)
675};
Mark Brownd450f192010-11-26 17:19:35 +0000676
Mark Brown9e501082010-01-29 18:20:29 +0000677static struct i2c_driver wm8994_i2c_driver = {
678 .driver = {
Mark Brownd450f192010-11-26 17:19:35 +0000679 .name = "wm8994",
Mark Brownd450f192010-11-26 17:19:35 +0000680 .pm = &wm8994_pm_ops,
Mark Brown20fb2772013-04-11 18:11:51 +0100681 .of_match_table = of_match_ptr(wm8994_of_match),
Mark Brown9e501082010-01-29 18:20:29 +0000682 },
683 .probe = wm8994_i2c_probe,
Bill Pemberton84449212012-11-19 13:20:24 -0500684 .remove = wm8994_i2c_remove,
Mark Brown9e501082010-01-29 18:20:29 +0000685 .id_table = wm8994_i2c_id,
686};
687
Mark Brownceb57d22012-05-07 10:03:23 +0100688module_i2c_driver(wm8994_i2c_driver);
Mark Brown9e501082010-01-29 18:20:29 +0000689
690MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
691MODULE_LICENSE("GPL");
692MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");