1
2
3
4
5
6
7
8
9
10
11
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/pm_runtime.h>
23#include <linux/regmap.h>
24#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
31#include "wm8994.h"
32
33
34
35
36
37
38
39int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
40{
41 unsigned int val;
42 int ret;
43
44 ret = regmap_read(wm8994->regmap, reg, &val);
45
46 if (ret < 0)
47 return ret;
48 else
49 return val;
50}
51EXPORT_SYMBOL_GPL(wm8994_reg_read);
52
53
54
55
56
57
58
59
60
61int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
62 int count, u16 *buf)
63{
64 return regmap_bulk_read(wm8994->regmap, reg, buf, count);
65}
66
67
68
69
70
71
72
73
74int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
75 unsigned short val)
76{
77 return regmap_write(wm8994->regmap, reg, val);
78}
79EXPORT_SYMBOL_GPL(wm8994_reg_write);
80
81
82
83
84
85
86
87
88
89int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
90 int count, const u16 *buf)
91{
92 return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16));
93}
94EXPORT_SYMBOL_GPL(wm8994_bulk_write);
95
96
97
98
99
100
101
102
103
104int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
105 unsigned short mask, unsigned short val)
106{
107 return regmap_update_bits(wm8994->regmap, reg, mask, val);
108}
109EXPORT_SYMBOL_GPL(wm8994_set_bits);
110
111static struct mfd_cell wm8994_regulator_devs[] = {
112 {
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 },
122};
123
124static 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
140static struct mfd_cell wm8994_devs[] = {
141 {
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,
151 .pm_runtime_no_callbacks = true,
152 },
153};
154
155
156
157
158
159
160static 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
172static const char *wm8994_main_supplies[] = {
173 "DBVDD",
174 "DCVDD",
175 "AVDD1",
176 "AVDD2",
177 "CPVDD",
178 "SPKVDD1",
179 "SPKVDD2",
180};
181
182static 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
194#ifdef CONFIG_PM
195static int wm8994_suspend(struct device *dev)
196{
197 struct wm8994 *wm8994 = dev_get_drvdata(dev);
198 int ret;
199
200
201
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
210 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:
232 case WM1811:
233 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
245 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
259 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
273
274
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
280
281
282
283 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET,
284 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
285
286 regcache_mark_dirty(wm8994->regmap);
287
288
289
290
291 ret = regcache_sync_region(wm8994->regmap, WM8994_GPIO_1,
292 WM8994_GPIO_11);
293 if (ret != 0)
294 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
295
296
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
303 regcache_cache_only(wm8994->regmap, true);
304 wm8994->suspended = true;
305
306 ret = regulator_bulk_disable(wm8994->num_supplies,
307 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
316static int wm8994_resume(struct device *dev)
317{
318 struct wm8994 *wm8994 = dev_get_drvdata(dev);
319 int ret;
320
321
322 if (!wm8994->suspended)
323 return 0;
324
325 ret = regulator_bulk_enable(wm8994->num_supplies,
326 wm8994->supplies);
327 if (ret != 0) {
328 dev_err(dev, "Failed to enable supplies: %d\n", ret);
329 return ret;
330 }
331
332 regcache_cache_only(wm8994->regmap, false);
333 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;
337 }
338
339
340 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
341 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
342 0);
343
344 wm8994->suspended = false;
345
346 return 0;
347
348err_enable:
349 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies);
350
351 return ret;
352}
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
377static const __devinitdata struct reg_default wm8994_revc_patch[] = {
378 { 0x102, 0x3 },
379 { 0x56, 0x3 },
380 { 0x817, 0x0 },
381 { 0x102, 0x0 },
382};
383
384static const __devinitdata struct reg_default wm8958_reva_patch[] = {
385 { 0x102, 0x3 },
386 { 0xcb, 0x81 },
387 { 0x817, 0x0 },
388 { 0x102, 0x0 },
389};
390
391static const __devinitdata struct reg_default wm1811_reva_patch[] = {
392 { 0x102, 0x3 },
393 { 0x56, 0x7 },
394 { 0x5d, 0x7e },
395 { 0x5e, 0x0 },
396 { 0x102, 0x0 },
397};
398
399
400
401
402static __devinit int wm8994_device_init(struct wm8994 *wm8994, int irq)
403{
404 struct wm8994_pdata *pdata = wm8994->dev->platform_data;
405 struct regmap_config *regmap_config;
406 const struct reg_default *regmap_patch = NULL;
407 const char *devname;
408 int ret, i, patch_regs;
409 int pulls = 0;
410
411 dev_set_drvdata(wm8994->dev, wm8994);
412
413
414 ret = mfd_add_devices(wm8994->dev, -1,
415 wm8994_regulator_devs,
416 ARRAY_SIZE(wm8994_regulator_devs),
417 NULL, 0, NULL);
418 if (ret != 0) {
419 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
420 goto err;
421 }
422
423 switch (wm8994->type) {
424 case WM1811:
425 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
426 break;
427 case WM8994:
428 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
429 break;
430 case WM8958:
431 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
432 break;
433 default:
434 BUG();
435 goto err;
436 }
437
438 wm8994->supplies = devm_kzalloc(wm8994->dev,
439 sizeof(struct regulator_bulk_data) *
440 wm8994->num_supplies, GFP_KERNEL);
441 if (!wm8994->supplies) {
442 ret = -ENOMEM;
443 goto err;
444 }
445
446 switch (wm8994->type) {
447 case WM1811:
448 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
449 wm8994->supplies[i].supply = wm1811_main_supplies[i];
450 break;
451 case WM8994:
452 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
453 wm8994->supplies[i].supply = wm8994_main_supplies[i];
454 break;
455 case WM8958:
456 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
457 wm8994->supplies[i].supply = wm8958_main_supplies[i];
458 break;
459 default:
460 BUG();
461 goto err;
462 }
463
464 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
465 wm8994->supplies);
466 if (ret != 0) {
467 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
468 goto err;
469 }
470
471 ret = regulator_bulk_enable(wm8994->num_supplies,
472 wm8994->supplies);
473 if (ret != 0) {
474 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
475 goto err_get;
476 }
477
478 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
479 if (ret < 0) {
480 dev_err(wm8994->dev, "Failed to read ID register\n");
481 goto err_enable;
482 }
483 switch (ret) {
484 case 0x1811:
485 devname = "WM1811";
486 if (wm8994->type != WM1811)
487 dev_warn(wm8994->dev, "Device registered as type %d\n",
488 wm8994->type);
489 wm8994->type = WM1811;
490 break;
491 case 0x8994:
492 devname = "WM8994";
493 if (wm8994->type != WM8994)
494 dev_warn(wm8994->dev, "Device registered as type %d\n",
495 wm8994->type);
496 wm8994->type = WM8994;
497 break;
498 case 0x8958:
499 devname = "WM8958";
500 if (wm8994->type != WM8958)
501 dev_warn(wm8994->dev, "Device registered as type %d\n",
502 wm8994->type);
503 wm8994->type = WM8958;
504 break;
505 default:
506 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
507 ret);
508 ret = -EINVAL;
509 goto err_enable;
510 }
511
512 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
513 if (ret < 0) {
514 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
515 ret);
516 goto err_enable;
517 }
518 wm8994->revision = ret & WM8994_CHIP_REV_MASK;
519 wm8994->cust_id = (ret & WM8994_CUST_ID_MASK) >> WM8994_CUST_ID_SHIFT;
520
521 switch (wm8994->type) {
522 case WM8994:
523 switch (wm8994->revision) {
524 case 0:
525 case 1:
526 dev_warn(wm8994->dev,
527 "revision %c not fully supported\n",
528 'A' + wm8994->revision);
529 break;
530 case 2:
531 case 3:
532 regmap_patch = wm8994_revc_patch;
533 patch_regs = ARRAY_SIZE(wm8994_revc_patch);
534 break;
535 default:
536 break;
537 }
538 break;
539
540 case WM8958:
541 switch (wm8994->revision) {
542 case 0:
543 regmap_patch = wm8958_reva_patch;
544 patch_regs = ARRAY_SIZE(wm8958_reva_patch);
545 break;
546 default:
547 break;
548 }
549 break;
550
551 case WM1811:
552
553 if (wm8994->revision > 1)
554 wm8994->revision++;
555 switch (wm8994->revision) {
556 case 0:
557 case 1:
558 case 2:
559 case 3:
560 regmap_patch = wm1811_reva_patch;
561 patch_regs = ARRAY_SIZE(wm1811_reva_patch);
562 break;
563 default:
564 break;
565 }
566 break;
567
568 default:
569 break;
570 }
571
572 dev_info(wm8994->dev, "%s revision %c CUST_ID %02x\n", devname,
573 'A' + wm8994->revision, wm8994->cust_id);
574
575 switch (wm8994->type) {
576 case WM1811:
577 regmap_config = &wm1811_regmap_config;
578 break;
579 case WM8994:
580 regmap_config = &wm8994_regmap_config;
581 break;
582 case WM8958:
583 regmap_config = &wm8958_regmap_config;
584 break;
585 default:
586 dev_err(wm8994->dev, "Unknown device type %d\n", wm8994->type);
587 return -EINVAL;
588 }
589
590 ret = regmap_reinit_cache(wm8994->regmap, regmap_config);
591 if (ret != 0) {
592 dev_err(wm8994->dev, "Failed to reinit register cache: %d\n",
593 ret);
594 return ret;
595 }
596
597 if (regmap_patch) {
598 ret = regmap_register_patch(wm8994->regmap, regmap_patch,
599 patch_regs);
600 if (ret != 0) {
601 dev_err(wm8994->dev, "Failed to register patch: %d\n",
602 ret);
603 goto err;
604 }
605 }
606
607 if (pdata) {
608 wm8994->irq_base = pdata->irq_base;
609 wm8994->gpio_base = pdata->gpio_base;
610
611
612 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
613 if (pdata->gpio_defaults[i]) {
614 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
615 0xffff,
616 pdata->gpio_defaults[i]);
617 }
618 }
619
620 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
621
622 if (pdata->spkmode_pu)
623 pulls |= WM8994_SPKMODE_PU;
624 }
625
626
627 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
628 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD |
629 WM8994_SPKMODE_PU | WM8994_CSNADDR_PD,
630 pulls);
631
632
633
634
635
636
637
638 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
639 if (wm8994_ldo_in_use(pdata, i))
640 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
641 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
642 else
643 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
644 WM8994_LDO1_DISCH, 0);
645 }
646
647 wm8994_irq_init(wm8994);
648
649 ret = mfd_add_devices(wm8994->dev, -1,
650 wm8994_devs, ARRAY_SIZE(wm8994_devs),
651 NULL, 0, NULL);
652 if (ret != 0) {
653 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
654 goto err_irq;
655 }
656
657 pm_runtime_enable(wm8994->dev);
658 pm_runtime_idle(wm8994->dev);
659
660 return 0;
661
662err_irq:
663 wm8994_irq_exit(wm8994);
664err_enable:
665 regulator_bulk_disable(wm8994->num_supplies,
666 wm8994->supplies);
667err_get:
668 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
669err:
670 mfd_remove_devices(wm8994->dev);
671 return ret;
672}
673
674static __devexit void wm8994_device_exit(struct wm8994 *wm8994)
675{
676 pm_runtime_disable(wm8994->dev);
677 mfd_remove_devices(wm8994->dev);
678 wm8994_irq_exit(wm8994);
679 regulator_bulk_disable(wm8994->num_supplies,
680 wm8994->supplies);
681 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
682}
683
684static const struct of_device_id wm8994_of_match[] = {
685 { .compatible = "wlf,wm1811", },
686 { .compatible = "wlf,wm8994", },
687 { .compatible = "wlf,wm8958", },
688 { }
689};
690MODULE_DEVICE_TABLE(of, wm8994_of_match);
691
692static __devinit int wm8994_i2c_probe(struct i2c_client *i2c,
693 const struct i2c_device_id *id)
694{
695 struct wm8994 *wm8994;
696 int ret;
697
698 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL);
699 if (wm8994 == NULL)
700 return -ENOMEM;
701
702 i2c_set_clientdata(i2c, wm8994);
703 wm8994->dev = &i2c->dev;
704 wm8994->irq = i2c->irq;
705 wm8994->type = id->driver_data;
706
707 wm8994->regmap = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config);
708 if (IS_ERR(wm8994->regmap)) {
709 ret = PTR_ERR(wm8994->regmap);
710 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
711 ret);
712 return ret;
713 }
714
715 return wm8994_device_init(wm8994, i2c->irq);
716}
717
718static __devexit int wm8994_i2c_remove(struct i2c_client *i2c)
719{
720 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
721
722 wm8994_device_exit(wm8994);
723
724 return 0;
725}
726
727static const struct i2c_device_id wm8994_i2c_id[] = {
728 { "wm1811", WM1811 },
729 { "wm1811a", WM1811 },
730 { "wm8994", WM8994 },
731 { "wm8958", WM8958 },
732 { }
733};
734MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
735
736static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
737 NULL);
738
739static struct i2c_driver wm8994_i2c_driver = {
740 .driver = {
741 .name = "wm8994",
742 .owner = THIS_MODULE,
743 .pm = &wm8994_pm_ops,
744 .of_match_table = wm8994_of_match,
745 },
746 .probe = wm8994_i2c_probe,
747 .remove = __devexit_p(wm8994_i2c_remove),
748 .id_table = wm8994_i2c_id,
749};
750
751module_i2c_driver(wm8994_i2c_driver);
752
753MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
754MODULE_LICENSE("GPL");
755MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
756
