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/of_gpio.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/regmap.h>
27 #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
34 #include "wm8994.h"
35
36 /**
37 * wm8994_reg_read: Read a single WM8994 register.
38 *
39 * @wm8994: Device to read from.
40 * @reg: Register to read.
41 */
wm8994_reg_read(struct wm8994 * wm8994,unsigned short reg)42 int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
43 {
44 unsigned int val;
45 int ret;
46
47 ret = regmap_read(wm8994->regmap, reg, &val);
48
49 if (ret < 0)
50 return ret;
51 else
52 return val;
53 }
54 EXPORT_SYMBOL_GPL(wm8994_reg_read);
55
56 /**
57 * wm8994_bulk_read: Read multiple WM8994 registers
58 *
59 * @wm8994: Device to read from
60 * @reg: First register
61 * @count: Number of registers
62 * @buf: Buffer to fill. The data will be returned big endian.
63 */
wm8994_bulk_read(struct wm8994 * wm8994,unsigned short reg,int count,u16 * buf)64 int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
65 int count, u16 *buf)
66 {
67 return regmap_bulk_read(wm8994->regmap, reg, buf, count);
68 }
69
70 /**
71 * wm8994_reg_write: Write a single WM8994 register.
72 *
73 * @wm8994: Device to write to.
74 * @reg: Register to write to.
75 * @val: Value to write.
76 */
wm8994_reg_write(struct wm8994 * wm8994,unsigned short reg,unsigned short val)77 int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
78 unsigned short val)
79 {
80 return regmap_write(wm8994->regmap, reg, val);
81 }
82 EXPORT_SYMBOL_GPL(wm8994_reg_write);
83
84 /**
85 * wm8994_bulk_write: Write multiple WM8994 registers
86 *
87 * @wm8994: Device to write to
88 * @reg: First register
89 * @count: Number of registers
90 * @buf: Buffer to write from. Data must be big-endian formatted.
91 */
wm8994_bulk_write(struct wm8994 * wm8994,unsigned short reg,int count,const u16 * buf)92 int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
93 int count, const u16 *buf)
94 {
95 return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16));
96 }
97 EXPORT_SYMBOL_GPL(wm8994_bulk_write);
98
99 /**
100 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
101 *
102 * @wm8994: Device to write to.
103 * @reg: Register to write to.
104 * @mask: Mask of bits to set.
105 * @val: Value to set (unshifted)
106 */
wm8994_set_bits(struct wm8994 * wm8994,unsigned short reg,unsigned short mask,unsigned short val)107 int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
108 unsigned short mask, unsigned short val)
109 {
110 return regmap_update_bits(wm8994->regmap, reg, mask, val);
111 }
112 EXPORT_SYMBOL_GPL(wm8994_set_bits);
113
114 static struct mfd_cell wm8994_regulator_devs[] = {
115 {
116 .name = "wm8994-ldo",
117 .id = 1,
118 .pm_runtime_no_callbacks = true,
119 },
120 {
121 .name = "wm8994-ldo",
122 .id = 2,
123 .pm_runtime_no_callbacks = true,
124 },
125 };
126
127 static struct resource wm8994_codec_resources[] = {
128 {
129 .start = WM8994_IRQ_TEMP_SHUT,
130 .end = WM8994_IRQ_TEMP_WARN,
131 .flags = IORESOURCE_IRQ,
132 },
133 };
134
135 static struct resource wm8994_gpio_resources[] = {
136 {
137 .start = WM8994_IRQ_GPIO(1),
138 .end = WM8994_IRQ_GPIO(11),
139 .flags = IORESOURCE_IRQ,
140 },
141 };
142
143 static struct mfd_cell wm8994_devs[] = {
144 {
145 .name = "wm8994-codec",
146 .num_resources = ARRAY_SIZE(wm8994_codec_resources),
147 .resources = wm8994_codec_resources,
148 },
149
150 {
151 .name = "wm8994-gpio",
152 .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
153 .resources = wm8994_gpio_resources,
154 .pm_runtime_no_callbacks = true,
155 },
156 };
157
158 /*
159 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
160 * and should be handled via the standard regulator API supply
161 * management.
162 */
163 static const char *wm1811_main_supplies[] = {
164 "DBVDD1",
165 "DBVDD2",
166 "DBVDD3",
167 "DCVDD",
168 "AVDD1",
169 "AVDD2",
170 "CPVDD",
171 "SPKVDD1",
172 "SPKVDD2",
173 };
174
175 static const char *wm8994_main_supplies[] = {
176 "DBVDD",
177 "DCVDD",
178 "AVDD1",
179 "AVDD2",
180 "CPVDD",
181 "SPKVDD1",
182 "SPKVDD2",
183 };
184
185 static const char *wm8958_main_supplies[] = {
186 "DBVDD1",
187 "DBVDD2",
188 "DBVDD3",
189 "DCVDD",
190 "AVDD1",
191 "AVDD2",
192 "CPVDD",
193 "SPKVDD1",
194 "SPKVDD2",
195 };
196
197 #ifdef CONFIG_PM_RUNTIME
wm8994_suspend(struct device * dev)198 static int wm8994_suspend(struct device *dev)
199 {
200 struct wm8994 *wm8994 = dev_get_drvdata(dev);
201 int ret;
202
203 /* Don't actually go through with the suspend if the CODEC is
204 * still active (eg, for audio passthrough from CP. */
205 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
206 if (ret < 0) {
207 dev_err(dev, "Failed to read power status: %d\n", ret);
208 } else if (ret & WM8994_VMID_SEL_MASK) {
209 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
210 return 0;
211 }
212
213 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_4);
214 if (ret < 0) {
215 dev_err(dev, "Failed to read power status: %d\n", ret);
216 } else if (ret & (WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA |
217 WM8994_AIF1ADC2L_ENA | WM8994_AIF1ADC2R_ENA |
218 WM8994_AIF1ADC1L_ENA | WM8994_AIF1ADC1R_ENA)) {
219 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
220 return 0;
221 }
222
223 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_5);
224 if (ret < 0) {
225 dev_err(dev, "Failed to read power status: %d\n", ret);
226 } else if (ret & (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA |
227 WM8994_AIF1DAC2L_ENA | WM8994_AIF1DAC2R_ENA |
228 WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA)) {
229 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
230 return 0;
231 }
232
233 switch (wm8994->type) {
234 case WM8958:
235 case WM1811:
236 ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1);
237 if (ret < 0) {
238 dev_err(dev, "Failed to read power status: %d\n", ret);
239 } else if (ret & WM8958_MICD_ENA) {
240 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
241 return 0;
242 }
243 break;
244 default:
245 break;
246 }
247
248 switch (wm8994->type) {
249 case WM1811:
250 ret = wm8994_reg_read(wm8994, WM8994_ANTIPOP_2);
251 if (ret < 0) {
252 dev_err(dev, "Failed to read jackdet: %d\n", ret);
253 } else if (ret & WM1811_JACKDET_MODE_MASK) {
254 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
255 return 0;
256 }
257 break;
258 default:
259 break;
260 }
261
262 switch (wm8994->type) {
263 case WM1811:
264 ret = wm8994_reg_read(wm8994, WM8994_ANTIPOP_2);
265 if (ret < 0) {
266 dev_err(dev, "Failed to read jackdet: %d\n", ret);
267 } else if (ret & WM1811_JACKDET_MODE_MASK) {
268 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
269 return 0;
270 }
271 break;
272 default:
273 break;
274 }
275
276 /* Disable LDO pulldowns while the device is suspended if we
277 * don't know that something will be driving them. */
278 if (!wm8994->ldo_ena_always_driven)
279 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
280 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
281 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD);
282
283 /* Explicitly put the device into reset in case regulators
284 * don't get disabled in order to ensure consistent restart.
285 */
286 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET,
287 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
288
289 regcache_mark_dirty(wm8994->regmap);
290
291 /* Restore GPIO registers to prevent problems with mismatched
292 * pin configurations.
293 */
294 ret = regcache_sync_region(wm8994->regmap, WM8994_GPIO_1,
295 WM8994_GPIO_11);
296 if (ret != 0)
297 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
298
299 /* In case one of the GPIOs is used as a wake input. */
300 ret = regcache_sync_region(wm8994->regmap,
301 WM8994_INTERRUPT_STATUS_1_MASK,
302 WM8994_INTERRUPT_STATUS_1_MASK);
303 if (ret != 0)
304 dev_err(dev, "Failed to restore interrupt mask: %d\n", ret);
305
306 regcache_cache_only(wm8994->regmap, true);
307 wm8994->suspended = true;
308
309 ret = regulator_bulk_disable(wm8994->num_supplies,
310 wm8994->supplies);
311 if (ret != 0) {
312 dev_err(dev, "Failed to disable supplies: %d\n", ret);
313 return ret;
314 }
315
316 return 0;
317 }
318
wm8994_resume(struct device * dev)319 static int wm8994_resume(struct device *dev)
320 {
321 struct wm8994 *wm8994 = dev_get_drvdata(dev);
322 int ret;
323
324 /* We may have lied to the PM core about suspending */
325 if (!wm8994->suspended)
326 return 0;
327
328 ret = regulator_bulk_enable(wm8994->num_supplies,
329 wm8994->supplies);
330 if (ret != 0) {
331 dev_err(dev, "Failed to enable supplies: %d\n", ret);
332 return ret;
333 }
334
335 regcache_cache_only(wm8994->regmap, false);
336 ret = regcache_sync(wm8994->regmap);
337 if (ret != 0) {
338 dev_err(dev, "Failed to restore register map: %d\n", ret);
339 goto err_enable;
340 }
341
342 /* Disable LDO pulldowns while the device is active */
343 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
344 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
345 0);
346
347 wm8994->suspended = false;
348
349 return 0;
350
351 err_enable:
352 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies);
353
354 return ret;
355 }
356 #endif
357
358 #ifdef CONFIG_REGULATOR
wm8994_ldo_in_use(struct wm8994_pdata * pdata,int ldo)359 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
360 {
361 struct wm8994_ldo_pdata *ldo_pdata;
362
363 if (!pdata)
364 return 0;
365
366 ldo_pdata = &pdata->ldo[ldo];
367
368 if (!ldo_pdata->init_data)
369 return 0;
370
371 return ldo_pdata->init_data->num_consumer_supplies != 0;
372 }
373 #else
wm8994_ldo_in_use(struct wm8994_pdata * pdata,int ldo)374 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
375 {
376 return 0;
377 }
378 #endif
379
380 static const struct reg_default wm8994_revc_patch[] = {
381 { 0x102, 0x3 },
382 { 0x56, 0x3 },
383 { 0x817, 0x0 },
384 { 0x102, 0x0 },
385 };
386
387 static const struct reg_default wm8958_reva_patch[] = {
388 { 0x102, 0x3 },
389 { 0xcb, 0x81 },
390 { 0x817, 0x0 },
391 { 0x102, 0x0 },
392 };
393
394 static const struct reg_default wm1811_reva_patch[] = {
395 { 0x102, 0x3 },
396 { 0x56, 0xc07 },
397 { 0x5d, 0x7e },
398 { 0x5e, 0x0 },
399 { 0x102, 0x0 },
400 };
401
402 #ifdef CONFIG_OF
wm8994_set_pdata_from_of(struct wm8994 * wm8994)403 static int wm8994_set_pdata_from_of(struct wm8994 *wm8994)
404 {
405 struct device_node *np = wm8994->dev->of_node;
406 struct wm8994_pdata *pdata = &wm8994->pdata;
407 int i;
408
409 if (!np)
410 return 0;
411
412 if (of_property_read_u32_array(np, "wlf,gpio-cfg", pdata->gpio_defaults,
413 ARRAY_SIZE(pdata->gpio_defaults)) >= 0) {
414 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
415 if (wm8994->pdata.gpio_defaults[i] == 0)
416 pdata->gpio_defaults[i]
417 = WM8994_CONFIGURE_GPIO;
418 }
419 }
420
421 of_property_read_u32_array(np, "wlf,micbias-cfg", pdata->micbias,
422 ARRAY_SIZE(pdata->micbias));
423
424 pdata->lineout1_diff = true;
425 pdata->lineout2_diff = true;
426 if (of_find_property(np, "wlf,lineout1-se", NULL))
427 pdata->lineout1_diff = false;
428 if (of_find_property(np, "wlf,lineout2-se", NULL))
429 pdata->lineout2_diff = false;
430
431 if (of_find_property(np, "wlf,lineout1-feedback", NULL))
432 pdata->lineout1fb = true;
433 if (of_find_property(np, "wlf,lineout2-feedback", NULL))
434 pdata->lineout2fb = true;
435
436 if (of_find_property(np, "wlf,ldoena-always-driven", NULL))
437 pdata->lineout2fb = true;
438
439 pdata->ldo[0].enable = of_get_named_gpio(np, "wlf,ldo1ena", 0);
440 if (pdata->ldo[0].enable < 0)
441 pdata->ldo[0].enable = 0;
442
443 pdata->ldo[1].enable = of_get_named_gpio(np, "wlf,ldo2ena", 0);
444 if (pdata->ldo[1].enable < 0)
445 pdata->ldo[1].enable = 0;
446
447 return 0;
448 }
449 #else
wm8994_set_pdata_from_of(struct wm8994 * wm8994)450 static int wm8994_set_pdata_from_of(struct wm8994 *wm8994)
451 {
452 return 0;
453 }
454 #endif
455
456 /*
457 * Instantiate the generic non-control parts of the device.
458 */
wm8994_device_init(struct wm8994 * wm8994,int irq)459 static int wm8994_device_init(struct wm8994 *wm8994, int irq)
460 {
461 struct wm8994_pdata *pdata;
462 struct regmap_config *regmap_config;
463 const struct reg_default *regmap_patch = NULL;
464 const char *devname;
465 int ret, i, patch_regs = 0;
466 int pulls = 0;
467
468 if (dev_get_platdata(wm8994->dev)) {
469 pdata = dev_get_platdata(wm8994->dev);
470 wm8994->pdata = *pdata;
471 }
472 pdata = &wm8994->pdata;
473
474 ret = wm8994_set_pdata_from_of(wm8994);
475 if (ret != 0)
476 return ret;
477
478 dev_set_drvdata(wm8994->dev, wm8994);
479
480 /* Add the on-chip regulators first for bootstrapping */
481 ret = mfd_add_devices(wm8994->dev, -1,
482 wm8994_regulator_devs,
483 ARRAY_SIZE(wm8994_regulator_devs),
484 NULL, 0, NULL);
485 if (ret != 0) {
486 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
487 goto err;
488 }
489
490 switch (wm8994->type) {
491 case WM1811:
492 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
493 break;
494 case WM8994:
495 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
496 break;
497 case WM8958:
498 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
499 break;
500 default:
501 BUG();
502 goto err;
503 }
504
505 wm8994->supplies = devm_kzalloc(wm8994->dev,
506 sizeof(struct regulator_bulk_data) *
507 wm8994->num_supplies, GFP_KERNEL);
508 if (!wm8994->supplies) {
509 ret = -ENOMEM;
510 goto err;
511 }
512
513 switch (wm8994->type) {
514 case WM1811:
515 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
516 wm8994->supplies[i].supply = wm1811_main_supplies[i];
517 break;
518 case WM8994:
519 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
520 wm8994->supplies[i].supply = wm8994_main_supplies[i];
521 break;
522 case WM8958:
523 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
524 wm8994->supplies[i].supply = wm8958_main_supplies[i];
525 break;
526 default:
527 BUG();
528 goto err;
529 }
530
531 ret = devm_regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
532 wm8994->supplies);
533 if (ret != 0) {
534 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
535 goto err;
536 }
537
538 ret = regulator_bulk_enable(wm8994->num_supplies,
539 wm8994->supplies);
540 if (ret != 0) {
541 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
542 goto err;
543 }
544
545 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
546 if (ret < 0) {
547 dev_err(wm8994->dev, "Failed to read ID register\n");
548 goto err_enable;
549 }
550 switch (ret) {
551 case 0x1811:
552 devname = "WM1811";
553 if (wm8994->type != WM1811)
554 dev_warn(wm8994->dev, "Device registered as type %d\n",
555 wm8994->type);
556 wm8994->type = WM1811;
557 break;
558 case 0x8994:
559 devname = "WM8994";
560 if (wm8994->type != WM8994)
561 dev_warn(wm8994->dev, "Device registered as type %d\n",
562 wm8994->type);
563 wm8994->type = WM8994;
564 break;
565 case 0x8958:
566 devname = "WM8958";
567 if (wm8994->type != WM8958)
568 dev_warn(wm8994->dev, "Device registered as type %d\n",
569 wm8994->type);
570 wm8994->type = WM8958;
571 break;
572 default:
573 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
574 ret);
575 ret = -EINVAL;
576 goto err_enable;
577 }
578
579 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
580 if (ret < 0) {
581 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
582 ret);
583 goto err_enable;
584 }
585 wm8994->revision = ret & WM8994_CHIP_REV_MASK;
586 wm8994->cust_id = (ret & WM8994_CUST_ID_MASK) >> WM8994_CUST_ID_SHIFT;
587
588 switch (wm8994->type) {
589 case WM8994:
590 switch (wm8994->revision) {
591 case 0:
592 case 1:
593 dev_warn(wm8994->dev,
594 "revision %c not fully supported\n",
595 'A' + wm8994->revision);
596 break;
597 case 2:
598 case 3:
599 default:
600 regmap_patch = wm8994_revc_patch;
601 patch_regs = ARRAY_SIZE(wm8994_revc_patch);
602 break;
603 }
604 break;
605
606 case WM8958:
607 switch (wm8994->revision) {
608 case 0:
609 regmap_patch = wm8958_reva_patch;
610 patch_regs = ARRAY_SIZE(wm8958_reva_patch);
611 break;
612 default:
613 break;
614 }
615 break;
616
617 case WM1811:
618 /* Revision C did not change the relevant layer */
619 if (wm8994->revision > 1)
620 wm8994->revision++;
621
622 regmap_patch = wm1811_reva_patch;
623 patch_regs = ARRAY_SIZE(wm1811_reva_patch);
624 break;
625
626 default:
627 break;
628 }
629
630 dev_info(wm8994->dev, "%s revision %c CUST_ID %02x\n", devname,
631 'A' + wm8994->revision, wm8994->cust_id);
632
633 switch (wm8994->type) {
634 case WM1811:
635 regmap_config = &wm1811_regmap_config;
636 break;
637 case WM8994:
638 regmap_config = &wm8994_regmap_config;
639 break;
640 case WM8958:
641 regmap_config = &wm8958_regmap_config;
642 break;
643 default:
644 dev_err(wm8994->dev, "Unknown device type %d\n", wm8994->type);
645 return -EINVAL;
646 }
647
648 ret = regmap_reinit_cache(wm8994->regmap, regmap_config);
649 if (ret != 0) {
650 dev_err(wm8994->dev, "Failed to reinit register cache: %d\n",
651 ret);
652 return ret;
653 }
654
655 if (regmap_patch) {
656 ret = regmap_register_patch(wm8994->regmap, regmap_patch,
657 patch_regs);
658 if (ret != 0) {
659 dev_err(wm8994->dev, "Failed to register patch: %d\n",
660 ret);
661 goto err;
662 }
663 }
664
665 wm8994->irq_base = pdata->irq_base;
666 wm8994->gpio_base = pdata->gpio_base;
667
668 /* GPIO configuration is only applied if it's non-zero */
669 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
670 if (pdata->gpio_defaults[i]) {
671 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
672 0xffff, pdata->gpio_defaults[i]);
673 }
674 }
675
676 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
677
678 if (pdata->spkmode_pu)
679 pulls |= WM8994_SPKMODE_PU;
680
681 /* Disable unneeded pulls */
682 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
683 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD |
684 WM8994_SPKMODE_PU | WM8994_CSNADDR_PD,
685 pulls);
686
687 /* In some system designs where the regulators are not in use,
688 * we can achieve a small reduction in leakage currents by
689 * floating LDO outputs. This bit makes no difference if the
690 * LDOs are enabled, it only affects cases where the LDOs were
691 * in operation and are then disabled.
692 */
693 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
694 if (wm8994_ldo_in_use(pdata, i))
695 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
696 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
697 else
698 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
699 WM8994_LDO1_DISCH, 0);
700 }
701
702 wm8994_irq_init(wm8994);
703
704 ret = mfd_add_devices(wm8994->dev, -1,
705 wm8994_devs, ARRAY_SIZE(wm8994_devs),
706 NULL, 0, NULL);
707 if (ret != 0) {
708 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
709 goto err_irq;
710 }
711
712 pm_runtime_enable(wm8994->dev);
713 pm_runtime_idle(wm8994->dev);
714
715 return 0;
716
717 err_irq:
718 wm8994_irq_exit(wm8994);
719 err_enable:
720 regulator_bulk_disable(wm8994->num_supplies,
721 wm8994->supplies);
722 err:
723 mfd_remove_devices(wm8994->dev);
724 return ret;
725 }
726
wm8994_device_exit(struct wm8994 * wm8994)727 static void wm8994_device_exit(struct wm8994 *wm8994)
728 {
729 pm_runtime_disable(wm8994->dev);
730 mfd_remove_devices(wm8994->dev);
731 wm8994_irq_exit(wm8994);
732 regulator_bulk_disable(wm8994->num_supplies,
733 wm8994->supplies);
734 }
735
736 static const struct of_device_id wm8994_of_match[] = {
737 { .compatible = "wlf,wm1811", .data = (void *)WM1811 },
738 { .compatible = "wlf,wm8994", .data = (void *)WM8994 },
739 { .compatible = "wlf,wm8958", .data = (void *)WM8958 },
740 { }
741 };
742 MODULE_DEVICE_TABLE(of, wm8994_of_match);
743
wm8994_i2c_probe(struct i2c_client * i2c,const struct i2c_device_id * id)744 static int wm8994_i2c_probe(struct i2c_client *i2c,
745 const struct i2c_device_id *id)
746 {
747 const struct of_device_id *of_id;
748 struct wm8994 *wm8994;
749 int ret;
750
751 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL);
752 if (wm8994 == NULL)
753 return -ENOMEM;
754
755 i2c_set_clientdata(i2c, wm8994);
756 wm8994->dev = &i2c->dev;
757 wm8994->irq = i2c->irq;
758
759 if (i2c->dev.of_node) {
760 of_id = of_match_device(wm8994_of_match, &i2c->dev);
761 if (of_id)
762 wm8994->type = (int)of_id->data;
763 } else {
764 wm8994->type = id->driver_data;
765 }
766
767 wm8994->regmap = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config);
768 if (IS_ERR(wm8994->regmap)) {
769 ret = PTR_ERR(wm8994->regmap);
770 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
771 ret);
772 return ret;
773 }
774
775 return wm8994_device_init(wm8994, i2c->irq);
776 }
777
wm8994_i2c_remove(struct i2c_client * i2c)778 static int wm8994_i2c_remove(struct i2c_client *i2c)
779 {
780 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
781
782 wm8994_device_exit(wm8994);
783
784 return 0;
785 }
786
787 static const struct i2c_device_id wm8994_i2c_id[] = {
788 { "wm1811", WM1811 },
789 { "wm1811a", WM1811 },
790 { "wm8994", WM8994 },
791 { "wm8958", WM8958 },
792 { }
793 };
794 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
795
796 static const struct dev_pm_ops wm8994_pm_ops = {
797 SET_RUNTIME_PM_OPS(wm8994_suspend, wm8994_resume, NULL)
798 };
799
800 static struct i2c_driver wm8994_i2c_driver = {
801 .driver = {
802 .name = "wm8994",
803 .owner = THIS_MODULE,
804 .pm = &wm8994_pm_ops,
805 .of_match_table = of_match_ptr(wm8994_of_match),
806 },
807 .probe = wm8994_i2c_probe,
808 .remove = wm8994_i2c_remove,
809 .id_table = wm8994_i2c_id,
810 };
811
812 module_i2c_driver(wm8994_i2c_driver);
813
814 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
815 MODULE_LICENSE("GPL");
816 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
817