1/*
2 * wm8994-core.c -- Device access for Wolfson WM8994
3 *
4 * Copyright 2009 Wolfson Microelectronics PLC.
5 *
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/slab.h>
18#include <linux/i2c.h>
19#include <linux/err.h>
20#include <linux/delay.h>
21#include <linux/mfd/core.h>
22#include <linux/of.h>
23#include <linux/of_device.h>
24#include <linux/pm_runtime.h>
25#include <linux/regmap.h>
26#include <linux/regulator/consumer.h>
27#include <linux/regulator/machine.h>
28
29#include <linux/mfd/wm8994/core.h>
30#include <linux/mfd/wm8994/pdata.h>
31#include <linux/mfd/wm8994/registers.h>
32
33#include "wm8994.h"
34
35static const struct mfd_cell wm8994_regulator_devs[] = {
36 {
37 .name = "wm8994-ldo",
38 .id = 0,
39 .pm_runtime_no_callbacks = true,
40 },
41 {
42 .name = "wm8994-ldo",
43 .id = 1,
44 .pm_runtime_no_callbacks = true,
45 },
46};
47
48static struct resource wm8994_codec_resources[] = {
49 {
50 .start = WM8994_IRQ_TEMP_SHUT,
51 .end = WM8994_IRQ_TEMP_WARN,
52 .flags = IORESOURCE_IRQ,
53 },
54};
55
56static struct resource wm8994_gpio_resources[] = {
57 {
58 .start = WM8994_IRQ_GPIO(1),
59 .end = WM8994_IRQ_GPIO(11),
60 .flags = IORESOURCE_IRQ,
61 },
62};
63
64static const struct mfd_cell wm8994_devs[] = {
65 {
66 .name = "wm8994-codec",
67 .num_resources = ARRAY_SIZE(wm8994_codec_resources),
68 .resources = wm8994_codec_resources,
69 },
70
71 {
72 .name = "wm8994-gpio",
73 .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
74 .resources = wm8994_gpio_resources,
75 .pm_runtime_no_callbacks = true,
76 },
77};
78
79/*
80 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
81 * and should be handled via the standard regulator API supply
82 * management.
83 */
84static const char *wm1811_main_supplies[] = {
85 "DBVDD1",
86 "DBVDD2",
87 "DBVDD3",
88 "DCVDD",
89 "AVDD1",
90 "AVDD2",
91 "CPVDD",
92 "SPKVDD1",
93 "SPKVDD2",
94};
95
96static const char *wm8994_main_supplies[] = {
97 "DBVDD",
98 "DCVDD",
99 "AVDD1",
100 "AVDD2",
101 "CPVDD",
102 "SPKVDD1",
103 "SPKVDD2",
104};
105
106static const char *wm8958_main_supplies[] = {
107 "DBVDD1",
108 "DBVDD2",
109 "DBVDD3",
110 "DCVDD",
111 "AVDD1",
112 "AVDD2",
113 "CPVDD",
114 "SPKVDD1",
115 "SPKVDD2",
116};
117
118#ifdef CONFIG_PM
119static int wm8994_suspend(struct device *dev)
120{
121 struct wm8994 *wm8994 = dev_get_drvdata(dev);
122 int ret;
123
124 /* Don't actually go through with the suspend if the CODEC is
125 * still active for accessory detect. */
126 switch (wm8994->type) {
127 case WM8958:
128 case WM1811:
129 ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1);
130 if (ret < 0) {
131 dev_err(dev, "Failed to read power status: %d\n", ret);
132 } else if (ret & WM8958_MICD_ENA) {
133 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
134 return 0;
135 }
136 break;
137 default:
138 break;
139 }
140
141 /* Disable LDO pulldowns while the device is suspended if we
142 * don't know that something will be driving them. */
143 if (!wm8994->ldo_ena_always_driven)
144 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
145 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
146 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD);
147
148 /* Explicitly put the device into reset in case regulators
149 * don't get disabled in order to ensure consistent restart.
150 */
151 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET,
152 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
153
154 regcache_mark_dirty(wm8994->regmap);
155
156 /* Restore GPIO registers to prevent problems with mismatched
157 * pin configurations.
158 */
159 ret = regcache_sync_region(wm8994->regmap, WM8994_GPIO_1,
160 WM8994_GPIO_11);
161 if (ret != 0)
162 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
163
164 /* In case one of the GPIOs is used as a wake input. */
165 ret = regcache_sync_region(wm8994->regmap,
166 WM8994_INTERRUPT_STATUS_1_MASK,
167 WM8994_INTERRUPT_STATUS_1_MASK);
168 if (ret != 0)
169 dev_err(dev, "Failed to restore interrupt mask: %d\n", ret);
170
171 regcache_cache_only(wm8994->regmap, true);
172 wm8994->suspended = true;
173
174 ret = regulator_bulk_disable(wm8994->num_supplies,
175 wm8994->supplies);
176 if (ret != 0) {
177 dev_err(dev, "Failed to disable supplies: %d\n", ret);
178 return ret;
179 }
180
181 return 0;
182}
183
184static int wm8994_resume(struct device *dev)
185{
186 struct wm8994 *wm8994 = dev_get_drvdata(dev);
187 int ret;
188
189 /* We may have lied to the PM core about suspending */
190 if (!wm8994->suspended)
191 return 0;
192
193 ret = regulator_bulk_enable(wm8994->num_supplies,
194 wm8994->supplies);
195 if (ret != 0) {
196 dev_err(dev, "Failed to enable supplies: %d\n", ret);
197 return ret;
198 }
199
200 regcache_cache_only(wm8994->regmap, false);
201 ret = regcache_sync(wm8994->regmap);
202 if (ret != 0) {
203 dev_err(dev, "Failed to restore register map: %d\n", ret);
204 goto err_enable;
205 }
206
207 /* Disable LDO pulldowns while the device is active */
208 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
209 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
210 0);
211
212 wm8994->suspended = false;
213
214 return 0;
215
216err_enable:
217 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies);
218
219 return ret;
220}
221#endif
222
223#ifdef CONFIG_REGULATOR
224static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
225{
226 struct wm8994_ldo_pdata *ldo_pdata;
227
228 if (!pdata)
229 return 0;
230
231 ldo_pdata = &pdata->ldo[ldo];
232
233 if (!ldo_pdata->init_data)
234 return 0;
235
236 return ldo_pdata->init_data->num_consumer_supplies != 0;
237}
238#else
239static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
240{
241 return 0;
242}
243#endif
244
245static const struct reg_sequence wm8994_revc_patch[] = {
246 { 0x102, 0x3 },
247 { 0x56, 0x3 },
248 { 0x817, 0x0 },
249 { 0x102, 0x0 },
250};
251
252static const struct reg_sequence wm8958_reva_patch[] = {
253 { 0x102, 0x3 },
254 { 0xcb, 0x81 },
255 { 0x817, 0x0 },
256 { 0x102, 0x0 },
257};
258
259static const struct reg_sequence wm1811_reva_patch[] = {
260 { 0x102, 0x3 },
261 { 0x56, 0xc07 },
262 { 0x5d, 0x7e },
263 { 0x5e, 0x0 },
264 { 0x102, 0x0 },
265};
266
267#ifdef CONFIG_OF
268static int wm8994_set_pdata_from_of(struct wm8994 *wm8994)
269{
270 struct device_node *np = wm8994->dev->of_node;
271 struct wm8994_pdata *pdata = &wm8994->pdata;
272 int i;
273
274 if (!np)
275 return 0;
276
277 if (of_property_read_u32_array(np, "wlf,gpio-cfg", pdata->gpio_defaults,
278 ARRAY_SIZE(pdata->gpio_defaults)) >= 0) {
279 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
280 if (wm8994->pdata.gpio_defaults[i] == 0)
281 pdata->gpio_defaults[i]
282 = WM8994_CONFIGURE_GPIO;
283 }
284 }
285
286 of_property_read_u32_array(np, "wlf,micbias-cfg", pdata->micbias,
287 ARRAY_SIZE(pdata->micbias));
288
289 pdata->lineout1_diff = true;
290 pdata->lineout2_diff = true;
291 if (of_find_property(np, "wlf,lineout1-se", NULL))
292 pdata->lineout1_diff = false;
293 if (of_find_property(np, "wlf,lineout2-se", NULL))
294 pdata->lineout2_diff = false;
295
296 if (of_find_property(np, "wlf,lineout1-feedback", NULL))
297 pdata->lineout1fb = true;
298 if (of_find_property(np, "wlf,lineout2-feedback", NULL))
299 pdata->lineout2fb = true;
300
301 if (of_find_property(np, "wlf,ldoena-always-driven", NULL))
302 pdata->lineout2fb = true;
303
304 pdata->spkmode_pu = of_property_read_bool(np, "wlf,spkmode-pu");
305
306 pdata->csnaddr_pd = of_property_read_bool(np, "wlf,csnaddr-pd");
307
308 return 0;
309}
310#else
311static int wm8994_set_pdata_from_of(struct wm8994 *wm8994)
312{
313 return 0;
314}
315#endif
316
317/*
318 * Instantiate the generic non-control parts of the device.
319 */
320static int wm8994_device_init(struct wm8994 *wm8994, int irq)
321{
322 struct wm8994_pdata *pdata;
323 struct regmap_config *regmap_config;
324 const struct reg_sequence *regmap_patch = NULL;
325 const char *devname;
326 int ret, i, patch_regs = 0;
327 int pulls = 0;
328
329 if (dev_get_platdata(wm8994->dev)) {
330 pdata = dev_get_platdata(wm8994->dev);
331 wm8994->pdata = *pdata;
332 }
333 pdata = &wm8994->pdata;
334
335 ret = wm8994_set_pdata_from_of(wm8994);
336 if (ret != 0)
337 return ret;
338
339 dev_set_drvdata(wm8994->dev, wm8994);
340
341 /* Add the on-chip regulators first for bootstrapping */
342 ret = mfd_add_devices(wm8994->dev, 0,
343 wm8994_regulator_devs,
344 ARRAY_SIZE(wm8994_regulator_devs),
345 NULL, 0, NULL);
346 if (ret != 0) {
347 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
348 goto err;
349 }
350
351 switch (wm8994->type) {
352 case WM1811:
353 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
354 break;
355 case WM8994:
356 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
357 break;
358 case WM8958:
359 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
360 break;
361 default:
362 BUG();
363 goto err;
364 }
365
366 wm8994->supplies = devm_kcalloc(wm8994->dev,
367 wm8994->num_supplies,
368 sizeof(struct regulator_bulk_data),
369 GFP_KERNEL);
370 if (!wm8994->supplies) {
371 ret = -ENOMEM;
372 goto err;
373 }
374
375 switch (wm8994->type) {
376 case WM1811:
377 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
378 wm8994->supplies[i].supply = wm1811_main_supplies[i];
379 break;
380 case WM8994:
381 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
382 wm8994->supplies[i].supply = wm8994_main_supplies[i];
383 break;
384 case WM8958:
385 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
386 wm8994->supplies[i].supply = wm8958_main_supplies[i];
387 break;
388 default:
389 BUG();
390 goto err;
391 }
392
393 /*
394 * Can't use devres helper here as some of the supplies are provided by
395 * wm8994->dev's children (regulators) and those regulators are
396 * unregistered by the devres core before the supplies are freed.
397 */
398 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
399 wm8994->supplies);
400 if (ret != 0) {
401 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
402 goto err;
403 }
404
405 ret = regulator_bulk_enable(wm8994->num_supplies, wm8994->supplies);
406 if (ret != 0) {
407 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
408 goto err_regulator_free;
409 }
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 }
416 switch (ret) {
417 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;
424 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:
439 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 }
451 wm8994->revision = ret & WM8994_CHIP_REV_MASK;
452 wm8994->cust_id = (ret & WM8994_CUST_ID_MASK) >> WM8994_CUST_ID_SHIFT;
453
454 switch (wm8994->type) {
455 case WM8994:
456 switch (wm8994->revision) {
457 case 0:
458 case 1:
459 dev_warn(wm8994->dev,
460 "revision %c not fully supported\n",
461 'A' + wm8994->revision);
462 break;
463 case 2:
464 case 3:
465 default:
466 regmap_patch = wm8994_revc_patch;
467 patch_regs = ARRAY_SIZE(wm8994_revc_patch);
468 break;
469 }
470 break;
471
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
483 case WM1811:
484 /* Revision C did not change the relevant layer */
485 if (wm8994->revision > 1)
486 wm8994->revision++;
487
488 regmap_patch = wm1811_reva_patch;
489 patch_regs = ARRAY_SIZE(wm1811_reva_patch);
490 break;
491
492 default:
493 break;
494 }
495
496 dev_info(wm8994->dev, "%s revision %c CUST_ID %02x\n", devname,
497 'A' + wm8994->revision, wm8994->cust_id);
498
499 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 ret = -EINVAL;
512 goto err_enable;
513 }
514
515 ret = regmap_reinit_cache(wm8994->regmap, regmap_config);
516 if (ret != 0) {
517 dev_err(wm8994->dev, "Failed to reinit register cache: %d\n",
518 ret);
519 goto err_enable;
520 }
521
522 /* Explicitly put the device into reset in case regulators
523 * don't get disabled in order to ensure we know the device
524 * state.
525 */
526 ret = wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET,
527 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
528 if (ret != 0) {
529 dev_err(wm8994->dev, "Failed to reset device: %d\n", ret);
530 goto err_enable;
531 }
532
533 if (regmap_patch) {
534 ret = regmap_register_patch(wm8994->regmap, regmap_patch,
535 patch_regs);
536 if (ret != 0) {
537 dev_err(wm8994->dev, "Failed to register patch: %d\n",
538 ret);
539 goto err_enable;
540 }
541 }
542
543 wm8994->irq_base = pdata->irq_base;
544 wm8994->gpio_base = pdata->gpio_base;
545
546 /* GPIO configuration is only applied if it's non-zero */
547 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
548 if (pdata->gpio_defaults[i]) {
549 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
550 0xffff, pdata->gpio_defaults[i]);
551 }
552 }
553
554 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
555
556 if (pdata->spkmode_pu)
557 pulls |= WM8994_SPKMODE_PU;
558 if (pdata->csnaddr_pd)
559 pulls |= WM8994_CSNADDR_PD;
560
561 /* Disable unneeded pulls */
562 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
563 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD |
564 WM8994_SPKMODE_PU | WM8994_CSNADDR_PD,
565 pulls);
566
567 /* In some system designs where the regulators are not in use,
568 * we can achieve a small reduction in leakage currents by
569 * floating LDO outputs. This bit makes no difference if the
570 * LDOs are enabled, it only affects cases where the LDOs were
571 * in operation and are then disabled.
572 */
573 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
574 if (wm8994_ldo_in_use(pdata, i))
575 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
576 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
577 else
578 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
579 WM8994_LDO1_DISCH, 0);
580 }
581
582 wm8994_irq_init(wm8994);
583
584 ret = mfd_add_devices(wm8994->dev, -1,
585 wm8994_devs, ARRAY_SIZE(wm8994_devs),
586 NULL, 0, NULL);
587 if (ret != 0) {
588 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
589 goto err_irq;
590 }
591
592 pm_runtime_enable(wm8994->dev);
593 pm_runtime_idle(wm8994->dev);
594
595 return 0;
596
597err_irq:
598 wm8994_irq_exit(wm8994);
599err_enable:
600 regulator_bulk_disable(wm8994->num_supplies,
601 wm8994->supplies);
602err_regulator_free:
603 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
604err:
605 mfd_remove_devices(wm8994->dev);
606 return ret;
607}
608
609static void wm8994_device_exit(struct wm8994 *wm8994)
610{
611 pm_runtime_disable(wm8994->dev);
612 wm8994_irq_exit(wm8994);
613 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies);
614 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
615 mfd_remove_devices(wm8994->dev);
616}
617
618static const struct of_device_id wm8994_of_match[] = {
619 { .compatible = "wlf,wm1811", .data = (void *)WM1811 },
620 { .compatible = "wlf,wm8994", .data = (void *)WM8994 },
621 { .compatible = "wlf,wm8958", .data = (void *)WM8958 },
622 { }
623};
624MODULE_DEVICE_TABLE(of, wm8994_of_match);
625
626static int wm8994_i2c_probe(struct i2c_client *i2c,
627 const struct i2c_device_id *id)
628{
629 const struct of_device_id *of_id;
630 struct wm8994 *wm8994;
631 int ret;
632
633 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL);
634 if (wm8994 == NULL)
635 return -ENOMEM;
636
637 i2c_set_clientdata(i2c, wm8994);
638 wm8994->dev = &i2c->dev;
639 wm8994->irq = i2c->irq;
640
641 if (i2c->dev.of_node) {
642 of_id = of_match_device(wm8994_of_match, &i2c->dev);
643 if (of_id)
644 wm8994->type = (enum wm8994_type)of_id->data;
645 } else {
646 wm8994->type = id->driver_data;
647 }
648
649 wm8994->regmap = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config);
650 if (IS_ERR(wm8994->regmap)) {
651 ret = PTR_ERR(wm8994->regmap);
652 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
653 ret);
654 return ret;
655 }
656
657 return wm8994_device_init(wm8994, i2c->irq);
658}
659
660static int wm8994_i2c_remove(struct i2c_client *i2c)
661{
662 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
663
664 wm8994_device_exit(wm8994);
665
666 return 0;
667}
668
669static const struct i2c_device_id wm8994_i2c_id[] = {
670 { "wm1811", WM1811 },
671 { "wm1811a", WM1811 },
672 { "wm8994", WM8994 },
673 { "wm8958", WM8958 },
674 { }
675};
676MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
677
678static const struct dev_pm_ops wm8994_pm_ops = {
679 SET_RUNTIME_PM_OPS(wm8994_suspend, wm8994_resume, NULL)
680};
681
682static struct i2c_driver wm8994_i2c_driver = {
683 .driver = {
684 .name = "wm8994",
685 .pm = &wm8994_pm_ops,
686 .of_match_table = of_match_ptr(wm8994_of_match),
687 },
688 .probe = wm8994_i2c_probe,
689 .remove = wm8994_i2c_remove,
690 .id_table = wm8994_i2c_id,
691};
692
693module_i2c_driver(wm8994_i2c_driver);
694
695MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
696MODULE_LICENSE("GPL");
697MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
698