?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nilfs2: unbreak compat ioctl
[zen-stable.git] / drivers / mfd / wm8994-core.c
blob5d6ba132837e8efb5f470d48784d5bb5f9809509
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/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 static int wm8994_read(struct wm8994 *wm8994, unsigned short reg,
32 int bytes, void *dest)
33 {
34 return regmap_raw_read(wm8994->regmap, reg, dest, bytes);
35 }
36
37 /**
38 * wm8994_reg_read: Read a single WM8994 register.
39 *
40 * @wm8994: Device to read from.
41 * @reg: Register to read.
42 */
43 int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
44 {
45 unsigned int val;
46 int ret;
47
48 ret = regmap_read(wm8994->regmap, reg, &val);
49
50 if (ret < 0)
51 return ret;
52 else
53 return val;
54 }
55 EXPORT_SYMBOL_GPL(wm8994_reg_read);
56
57 /**
58 * wm8994_bulk_read: Read multiple WM8994 registers
59 *
60 * @wm8994: Device to read from
61 * @reg: First register
62 * @count: Number of registers
63 * @buf: Buffer to fill. The data will be returned big endian.
64 */
65 int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
66 int count, u16 *buf)
67 {
68 return regmap_bulk_read(wm8994->regmap, reg, buf, count);
69 }
70
71 static int wm8994_write(struct wm8994 *wm8994, unsigned short reg,
72 int bytes, const void *src)
73 {
74 return regmap_raw_write(wm8994->regmap, reg, src, bytes);
75 }
76
77 /**
78 * wm8994_reg_write: Write a single WM8994 register.
79 *
80 * @wm8994: Device to write to.
81 * @reg: Register to write to.
82 * @val: Value to write.
83 */
84 int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
85 unsigned short val)
86 {
87 return regmap_write(wm8994->regmap, reg, val);
88 }
89 EXPORT_SYMBOL_GPL(wm8994_reg_write);
90
91 /**
92 * wm8994_bulk_write: Write multiple WM8994 registers
93 *
94 * @wm8994: Device to write to
95 * @reg: First register
96 * @count: Number of registers
97 * @buf: Buffer to write from. Data must be big-endian formatted.
98 */
99 int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
100 int count, const u16 *buf)
101 {
102 return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16));
103 }
104 EXPORT_SYMBOL_GPL(wm8994_bulk_write);
105
106 /**
107 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
108 *
109 * @wm8994: Device to write to.
110 * @reg: Register to write to.
111 * @mask: Mask of bits to set.
112 * @val: Value to set (unshifted)
113 */
114 int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
115 unsigned short mask, unsigned short val)
116 {
117 return regmap_update_bits(wm8994->regmap, reg, mask, val);
118 }
119 EXPORT_SYMBOL_GPL(wm8994_set_bits);
120
121 static struct mfd_cell wm8994_regulator_devs[] = {
122 {
123 .name = "wm8994-ldo",
124 .id = 1,
125 .pm_runtime_no_callbacks = true,
126 },
127 {
128 .name = "wm8994-ldo",
129 .id = 2,
130 .pm_runtime_no_callbacks = true,
131 },
132 };
133
134 static struct resource wm8994_codec_resources[] = {
135 {
136 .start = WM8994_IRQ_TEMP_SHUT,
137 .end = WM8994_IRQ_TEMP_WARN,
138 .flags = IORESOURCE_IRQ,
139 },
140 };
141
142 static struct resource wm8994_gpio_resources[] = {
143 {
144 .start = WM8994_IRQ_GPIO(1),
145 .end = WM8994_IRQ_GPIO(11),
146 .flags = IORESOURCE_IRQ,
147 },
148 };
149
150 static struct mfd_cell wm8994_devs[] = {
151 {
152 .name = "wm8994-codec",
153 .num_resources = ARRAY_SIZE(wm8994_codec_resources),
154 .resources = wm8994_codec_resources,
155 },
156
157 {
158 .name = "wm8994-gpio",
159 .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
160 .resources = wm8994_gpio_resources,
161 .pm_runtime_no_callbacks = true,
162 },
163 };
164
165 /*
166 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
167 * and should be handled via the standard regulator API supply
168 * management.
169 */
170 static const char *wm1811_main_supplies[] = {
171 "DBVDD1",
172 "DBVDD2",
173 "DBVDD3",
174 "DCVDD",
175 "AVDD1",
176 "AVDD2",
177 "CPVDD",
178 "SPKVDD1",
179 "SPKVDD2",
180 };
181
182 static const char *wm8994_main_supplies[] = {
183 "DBVDD",
184 "DCVDD",
185 "AVDD1",
186 "AVDD2",
187 "CPVDD",
188 "SPKVDD1",
189 "SPKVDD2",
190 };
191
192 static const char *wm8958_main_supplies[] = {
193 "DBVDD1",
194 "DBVDD2",
195 "DBVDD3",
196 "DCVDD",
197 "AVDD1",
198 "AVDD2",
199 "CPVDD",
200 "SPKVDD1",
201 "SPKVDD2",
202 };
203
204 #ifdef CONFIG_PM
205 static int wm8994_suspend(struct device *dev)
206 {
207 struct wm8994 *wm8994 = dev_get_drvdata(dev);
208 int ret;
209
210 /* Don't actually go through with the suspend if the CODEC is
211 * still active (eg, for audio passthrough from CP. */
212 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
213 if (ret < 0) {
214 dev_err(dev, "Failed to read power status: %d\n", ret);
215 } else if (ret & WM8994_VMID_SEL_MASK) {
216 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
217 return 0;
218 }
219
220 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_4);
221 if (ret < 0) {
222 dev_err(dev, "Failed to read power status: %d\n", ret);
223 } else if (ret & (WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA |
224 WM8994_AIF1ADC2L_ENA | WM8994_AIF1ADC2R_ENA |
225 WM8994_AIF1ADC1L_ENA | WM8994_AIF1ADC1R_ENA)) {
226 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
227 return 0;
228 }
229
230 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_5);
231 if (ret < 0) {
232 dev_err(dev, "Failed to read power status: %d\n", ret);
233 } else if (ret & (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA |
234 WM8994_AIF1DAC2L_ENA | WM8994_AIF1DAC2R_ENA |
235 WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA)) {
236 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
237 return 0;
238 }
239
240 switch (wm8994->type) {
241 case WM8958:
242 ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1);
243 if (ret < 0) {
244 dev_err(dev, "Failed to read power status: %d\n", ret);
245 } else if (ret & WM8958_MICD_ENA) {
246 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
247 return 0;
248 }
249 break;
250 default:
251 break;
252 }
253
254 /* Disable LDO pulldowns while the device is suspended if we
255 * don't know that something will be driving them. */
256 if (!wm8994->ldo_ena_always_driven)
257 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
258 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
259 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD);
260
261 /* GPIO configuration state is saved here since we may be configuring
262 * the GPIO alternate functions even if we're not using the gpiolib
263 * driver for them.
264 */
265 ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
266 &wm8994->gpio_regs);
267 if (ret < 0)
268 dev_err(dev, "Failed to save GPIO registers: %d\n", ret);
269
270 /* For similar reasons we also stash the regulator states */
271 ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
272 &wm8994->ldo_regs);
273 if (ret < 0)
274 dev_err(dev, "Failed to save LDO registers: %d\n", ret);
275
276 /* Explicitly put the device into reset in case regulators
277 * don't get disabled in order to ensure consistent restart.
278 */
279 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 0x8994);
280
281 wm8994->suspended = true;
282
283 ret = regulator_bulk_disable(wm8994->num_supplies,
284 wm8994->supplies);
285 if (ret != 0) {
286 dev_err(dev, "Failed to disable supplies: %d\n", ret);
287 return ret;
288 }
289
290 return 0;
291 }
292
293 static int wm8994_resume(struct device *dev)
294 {
295 struct wm8994 *wm8994 = dev_get_drvdata(dev);
296 int ret, i;
297
298 /* We may have lied to the PM core about suspending */
299 if (!wm8994->suspended)
300 return 0;
301
302 ret = regulator_bulk_enable(wm8994->num_supplies,
303 wm8994->supplies);
304 if (ret != 0) {
305 dev_err(dev, "Failed to enable supplies: %d\n", ret);
306 return ret;
307 }
308
309 /* Write register at a time as we use the cache on the CPU so store
310 * it in native endian.
311 */
312 for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
313 ret = wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK
314 + i, wm8994->irq_masks_cur[i]);
315 if (ret < 0)
316 dev_err(dev, "Failed to restore interrupt masks: %d\n",
317 ret);
318 }
319
320 ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
321 &wm8994->ldo_regs);
322 if (ret < 0)
323 dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
324
325 ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
326 &wm8994->gpio_regs);
327 if (ret < 0)
328 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
329
330 /* Disable LDO pulldowns while the device is active */
331 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
332 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
333 0);
334
335 wm8994->suspended = false;
336
337 return 0;
338 }
339 #endif
340
341 #ifdef CONFIG_REGULATOR
342 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
343 {
344 struct wm8994_ldo_pdata *ldo_pdata;
345
346 if (!pdata)
347 return 0;
348
349 ldo_pdata = &pdata->ldo[ldo];
350
351 if (!ldo_pdata->init_data)
352 return 0;
353
354 return ldo_pdata->init_data->num_consumer_supplies != 0;
355 }
356 #else
357 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
358 {
359 return 0;
360 }
361 #endif
362
363 static struct regmap_config wm8994_regmap_config = {
364 .reg_bits = 16,
365 .val_bits = 16,
366 };
367
368 /*
369 * Instantiate the generic non-control parts of the device.
370 */
371 static int wm8994_device_init(struct wm8994 *wm8994, int irq)
372 {
373 struct wm8994_pdata *pdata = wm8994->dev->platform_data;
374 const char *devname;
375 int ret, i;
376
377 dev_set_drvdata(wm8994->dev, wm8994);
378
379 /* Add the on-chip regulators first for bootstrapping */
380 ret = mfd_add_devices(wm8994->dev, -1,
381 wm8994_regulator_devs,
382 ARRAY_SIZE(wm8994_regulator_devs),
383 NULL, 0);
384 if (ret != 0) {
385 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
386 goto err_regmap;
387 }
388
389 switch (wm8994->type) {
390 case WM1811:
391 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
392 break;
393 case WM8994:
394 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
395 break;
396 case WM8958:
397 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
398 break;
399 default:
400 BUG();
401 goto err_regmap;
402 }
403
404 wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
405 wm8994->num_supplies,
406 GFP_KERNEL);
407 if (!wm8994->supplies) {
408 ret = -ENOMEM;
409 goto err_regmap;
410 }
411
412 switch (wm8994->type) {
413 case WM1811:
414 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
415 wm8994->supplies[i].supply = wm1811_main_supplies[i];
416 break;
417 case WM8994:
418 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
419 wm8994->supplies[i].supply = wm8994_main_supplies[i];
420 break;
421 case WM8958:
422 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
423 wm8994->supplies[i].supply = wm8958_main_supplies[i];
424 break;
425 default:
426 BUG();
427 goto err_regmap;
428 }
429
430 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
431 wm8994->supplies);
432 if (ret != 0) {
433 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
434 goto err_supplies;
435 }
436
437 ret = regulator_bulk_enable(wm8994->num_supplies,
438 wm8994->supplies);
439 if (ret != 0) {
440 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
441 goto err_get;
442 }
443
444 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
445 if (ret < 0) {
446 dev_err(wm8994->dev, "Failed to read ID register\n");
447 goto err_enable;
448 }
449 switch (ret) {
450 case 0x1811:
451 devname = "WM1811";
452 if (wm8994->type != WM1811)
453 dev_warn(wm8994->dev, "Device registered as type %d\n",
454 wm8994->type);
455 wm8994->type = WM1811;
456 break;
457 case 0x8994:
458 devname = "WM8994";
459 if (wm8994->type != WM8994)
460 dev_warn(wm8994->dev, "Device registered as type %d\n",
461 wm8994->type);
462 wm8994->type = WM8994;
463 break;
464 case 0x8958:
465 devname = "WM8958";
466 if (wm8994->type != WM8958)
467 dev_warn(wm8994->dev, "Device registered as type %d\n",
468 wm8994->type);
469 wm8994->type = WM8958;
470 break;
471 default:
472 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
473 ret);
474 ret = -EINVAL;
475 goto err_enable;
476 }
477
478 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
479 if (ret < 0) {
480 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
481 ret);
482 goto err_enable;
483 }
484
485 switch (wm8994->type) {
486 case WM8994:
487 switch (ret) {
488 case 0:
489 case 1:
490 dev_warn(wm8994->dev,
491 "revision %c not fully supported\n",
492 'A' + ret);
493 break;
494 default:
495 break;
496 }
497 break;
498 default:
499 break;
500 }
501
502 dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
503
504 if (pdata) {
505 wm8994->irq_base = pdata->irq_base;
506 wm8994->gpio_base = pdata->gpio_base;
507
508 /* GPIO configuration is only applied if it's non-zero */
509 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
510 if (pdata->gpio_defaults[i]) {
511 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
512 0xffff,
513 pdata->gpio_defaults[i]);
514 }
515 }
516
517 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
518 }
519
520 /* Disable LDO pulldowns while the device is active */
521 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
522 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
523 0);
524
525 /* In some system designs where the regulators are not in use,
526 * we can achieve a small reduction in leakage currents by
527 * floating LDO outputs. This bit makes no difference if the
528 * LDOs are enabled, it only affects cases where the LDOs were
529 * in operation and are then disabled.
530 */
531 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
532 if (wm8994_ldo_in_use(pdata, i))
533 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
534 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
535 else
536 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
537 WM8994_LDO1_DISCH, 0);
538 }
539
540 wm8994_irq_init(wm8994);
541
542 ret = mfd_add_devices(wm8994->dev, -1,
543 wm8994_devs, ARRAY_SIZE(wm8994_devs),
544 NULL, 0);
545 if (ret != 0) {
546 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
547 goto err_irq;
548 }
549
550 pm_runtime_enable(wm8994->dev);
551 pm_runtime_resume(wm8994->dev);
552
553 return 0;
554
555 err_irq:
556 wm8994_irq_exit(wm8994);
557 err_enable:
558 regulator_bulk_disable(wm8994->num_supplies,
559 wm8994->supplies);
560 err_get:
561 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
562 err_supplies:
563 kfree(wm8994->supplies);
564 err_regmap:
565 regmap_exit(wm8994->regmap);
566 mfd_remove_devices(wm8994->dev);
567 kfree(wm8994);
568 return ret;
569 }
570
571 static void wm8994_device_exit(struct wm8994 *wm8994)
572 {
573 pm_runtime_disable(wm8994->dev);
574 mfd_remove_devices(wm8994->dev);
575 wm8994_irq_exit(wm8994);
576 regulator_bulk_disable(wm8994->num_supplies,
577 wm8994->supplies);
578 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
579 kfree(wm8994->supplies);
580 regmap_exit(wm8994->regmap);
581 kfree(wm8994);
582 }
583
584 static int wm8994_i2c_probe(struct i2c_client *i2c,
585 const struct i2c_device_id *id)
586 {
587 struct wm8994 *wm8994;
588 int ret;
589
590 wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
591 if (wm8994 == NULL)
592 return -ENOMEM;
593
594 i2c_set_clientdata(i2c, wm8994);
595 wm8994->dev = &i2c->dev;
596 wm8994->irq = i2c->irq;
597 wm8994->type = id->driver_data;
598
599 wm8994->regmap = regmap_init_i2c(i2c, &wm8994_regmap_config);
600 if (IS_ERR(wm8994->regmap)) {
601 ret = PTR_ERR(wm8994->regmap);
602 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
603 ret);
604 kfree(wm8994);
605 return ret;
606 }
607
608 return wm8994_device_init(wm8994, i2c->irq);
609 }
610
611 static int wm8994_i2c_remove(struct i2c_client *i2c)
612 {
613 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
614
615 wm8994_device_exit(wm8994);
616
617 return 0;
618 }
619
620 static const struct i2c_device_id wm8994_i2c_id[] = {
621 { "wm1811", WM1811 },
622 { "wm8994", WM8994 },
623 { "wm8958", WM8958 },
624 { }
625 };
626 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
627
628 static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
629 NULL);
630
631 static struct i2c_driver wm8994_i2c_driver = {
632 .driver = {
633 .name = "wm8994",
634 .owner = THIS_MODULE,
635 .pm = &wm8994_pm_ops,
636 },
637 .probe = wm8994_i2c_probe,
638 .remove = wm8994_i2c_remove,
639 .id_table = wm8994_i2c_id,
640 };
641
642 static int __init wm8994_i2c_init(void)
643 {
644 int ret;
645
646 ret = i2c_add_driver(&wm8994_i2c_driver);
647 if (ret != 0)
648 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
649
650 return ret;
651 }
652 module_init(wm8994_i2c_init);
653
654 static void __exit wm8994_i2c_exit(void)
655 {
656 i2c_del_driver(&wm8994_i2c_driver);
657 }
658 module_exit(wm8994_i2c_exit);
659
660 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
661 MODULE_LICENSE("GPL");
662 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");