config: tegra3: enable /dev mount with ACL
[linux-2.6.git] / drivers / mfd / wm8994-core.c
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 *wm8994_main_supplies[] = {
171         "DBVDD",
172         "DCVDD",
173         "AVDD1",
174         "AVDD2",
175         "CPVDD",
176         "SPKVDD1",
177         "SPKVDD2",
178 };
179
180 static const char *wm8958_main_supplies[] = {
181         "DBVDD1",
182         "DBVDD2",
183         "DBVDD3",
184         "DCVDD",
185         "AVDD1",
186         "AVDD2",
187         "CPVDD",
188         "SPKVDD1",
189         "SPKVDD2",
190 };
191
192 #ifdef CONFIG_PM
193 static int wm8994_suspend(struct device *dev)
194 {
195         struct wm8994 *wm8994 = dev_get_drvdata(dev);
196         int ret;
197
198         /* Don't actually go through with the suspend if the CODEC is
199          * still active (eg, for audio passthrough from CP. */
200         ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
201         if (ret < 0) {
202                 dev_err(dev, "Failed to read power status: %d\n", ret);
203         } else if (ret & WM8994_VMID_SEL_MASK) {
204                 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
205                 return 0;
206         }
207
208         /* GPIO configuration state is saved here since we may be configuring
209          * the GPIO alternate functions even if we're not using the gpiolib
210          * driver for them.
211          */
212         ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
213                           &wm8994->gpio_regs);
214         if (ret < 0)
215                 dev_err(dev, "Failed to save GPIO registers: %d\n", ret);
216
217         /* For similar reasons we also stash the regulator states */
218         ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
219                           &wm8994->ldo_regs);
220         if (ret < 0)
221                 dev_err(dev, "Failed to save LDO registers: %d\n", ret);
222
223         /* Explicitly put the device into reset in case regulators
224          * don't get disabled in order to ensure consistent restart.
225          */
226         wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 0x8994);
227
228         wm8994->suspended = true;
229
230         ret = regulator_bulk_disable(wm8994->num_supplies,
231                                      wm8994->supplies);
232         if (ret != 0) {
233                 dev_err(dev, "Failed to disable supplies: %d\n", ret);
234                 return ret;
235         }
236
237         return 0;
238 }
239
240 static int wm8994_resume(struct device *dev)
241 {
242         struct wm8994 *wm8994 = dev_get_drvdata(dev);
243         int ret, i;
244
245         /* We may have lied to the PM core about suspending */
246         if (!wm8994->suspended)
247                 return 0;
248
249         ret = regulator_bulk_enable(wm8994->num_supplies,
250                                     wm8994->supplies);
251         if (ret != 0) {
252                 dev_err(dev, "Failed to enable supplies: %d\n", ret);
253                 return ret;
254         }
255
256         /* Write register at a time as we use the cache on the CPU so store
257          * it in native endian.
258          */
259         for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
260                 ret = wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK
261                                        + i, wm8994->irq_masks_cur[i]);
262                 if (ret < 0)
263                         dev_err(dev, "Failed to restore interrupt masks: %d\n",
264                                 ret);
265         }
266
267         ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
268                            &wm8994->ldo_regs);
269         if (ret < 0)
270                 dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
271
272         ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
273                            &wm8994->gpio_regs);
274         if (ret < 0)
275                 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
276
277         wm8994->suspended = false;
278
279         return 0;
280 }
281 #endif
282
283 #ifdef CONFIG_REGULATOR
284 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
285 {
286         struct wm8994_ldo_pdata *ldo_pdata;
287
288         if (!pdata)
289                 return 0;
290
291         ldo_pdata = &pdata->ldo[ldo];
292
293         if (!ldo_pdata->init_data)
294                 return 0;
295
296         return ldo_pdata->init_data->num_consumer_supplies != 0;
297 }
298 #else
299 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
300 {
301         return 0;
302 }
303 #endif
304
305 static struct regmap_config wm8994_regmap_config = {
306         .reg_bits = 16,
307         .val_bits = 16,
308 };
309
310 /*
311  * Instantiate the generic non-control parts of the device.
312  */
313 static int wm8994_device_init(struct wm8994 *wm8994, int irq)
314 {
315         struct wm8994_pdata *pdata = wm8994->dev->platform_data;
316         const char *devname;
317         int ret, i;
318
319         dev_set_drvdata(wm8994->dev, wm8994);
320
321         /* Add the on-chip regulators first for bootstrapping */
322         ret = mfd_add_devices(wm8994->dev, -1,
323                               wm8994_regulator_devs,
324                               ARRAY_SIZE(wm8994_regulator_devs),
325                               NULL, 0);
326         if (ret != 0) {
327                 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
328                 goto err_regmap;
329         }
330
331         switch (wm8994->type) {
332         case WM8994:
333                 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
334                 break;
335         case WM8958:
336                 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
337                 break;
338         default:
339                 BUG();
340                 goto err_regmap;
341         }
342
343         wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
344                                    wm8994->num_supplies,
345                                    GFP_KERNEL);
346         if (!wm8994->supplies) {
347                 ret = -ENOMEM;
348                 goto err_regmap;
349         }
350
351         switch (wm8994->type) {
352         case WM8994:
353                 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
354                         wm8994->supplies[i].supply = wm8994_main_supplies[i];
355                 break;
356         case WM8958:
357                 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
358                         wm8994->supplies[i].supply = wm8958_main_supplies[i];
359                 break;
360         default:
361                 BUG();
362                 goto err_regmap;
363         }
364                 
365         ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
366                                  wm8994->supplies);
367         if (ret != 0) {
368                 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
369                 goto err_supplies;
370         }
371
372         ret = regulator_bulk_enable(wm8994->num_supplies,
373                                     wm8994->supplies);
374         if (ret != 0) {
375                 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
376                 goto err_get;
377         }
378
379         ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
380         if (ret < 0) {
381                 dev_err(wm8994->dev, "Failed to read ID register\n");
382                 goto err_enable;
383         }
384         switch (ret) {
385         case 0x8994:
386                 devname = "WM8994";
387                 if (wm8994->type != WM8994)
388                         dev_warn(wm8994->dev, "Device registered as type %d\n",
389                                  wm8994->type);
390                 wm8994->type = WM8994;
391                 break;
392         case 0x8958:
393                 devname = "WM8958";
394                 if (wm8994->type != WM8958)
395                         dev_warn(wm8994->dev, "Device registered as type %d\n",
396                                  wm8994->type);
397                 wm8994->type = WM8958;
398                 break;
399         default:
400                 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
401                         ret);
402                 ret = -EINVAL;
403                 goto err_enable;
404         }
405
406         ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
407         if (ret < 0) {
408                 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
409                         ret);
410                 goto err_enable;
411         }
412
413         switch (wm8994->type) {
414         case WM8994:
415                 switch (ret) {
416                 case 0:
417                 case 1:
418                         dev_warn(wm8994->dev,
419                                  "revision %c not fully supported\n",
420                                  'A' + ret);
421                         break;
422                 default:
423                         break;
424                 }
425                 break;
426         default:
427                 break;
428         }
429
430         dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
431
432         if (pdata) {
433                 wm8994->irq_base = pdata->irq_base;
434                 wm8994->gpio_base = pdata->gpio_base;
435
436                 /* GPIO configuration is only applied if it's non-zero */
437                 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
438                         if (pdata->gpio_defaults[i]) {
439                                 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
440                                                 0xffff,
441                                                 pdata->gpio_defaults[i]);
442                         }
443                 }
444         }
445
446         /* In some system designs where the regulators are not in use,
447          * we can achieve a small reduction in leakage currents by
448          * floating LDO outputs.  This bit makes no difference if the
449          * LDOs are enabled, it only affects cases where the LDOs were
450          * in operation and are then disabled.
451          */
452         for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
453                 if (wm8994_ldo_in_use(pdata, i))
454                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
455                                         WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
456                 else
457                         wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
458                                         WM8994_LDO1_DISCH, 0);
459         }
460
461         wm8994_irq_init(wm8994);
462
463         ret = mfd_add_devices(wm8994->dev, -1,
464                               wm8994_devs, ARRAY_SIZE(wm8994_devs),
465                               NULL, 0);
466         if (ret != 0) {
467                 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
468                 goto err_irq;
469         }
470
471         pm_runtime_enable(wm8994->dev);
472         pm_runtime_resume(wm8994->dev);
473
474         return 0;
475
476 err_irq:
477         wm8994_irq_exit(wm8994);
478 err_enable:
479         regulator_bulk_disable(wm8994->num_supplies,
480                                wm8994->supplies);
481 err_get:
482         regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
483 err_supplies:
484         kfree(wm8994->supplies);
485 err_regmap:
486         regmap_exit(wm8994->regmap);
487         mfd_remove_devices(wm8994->dev);
488         kfree(wm8994);
489         return ret;
490 }
491
492 static void wm8994_device_exit(struct wm8994 *wm8994)
493 {
494         pm_runtime_disable(wm8994->dev);
495         mfd_remove_devices(wm8994->dev);
496         wm8994_irq_exit(wm8994);
497         regulator_bulk_disable(wm8994->num_supplies,
498                                wm8994->supplies);
499         regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
500         kfree(wm8994->supplies);
501         regmap_exit(wm8994->regmap);
502         kfree(wm8994);
503 }
504
505 static int wm8994_i2c_probe(struct i2c_client *i2c,
506                             const struct i2c_device_id *id)
507 {
508         struct wm8994 *wm8994;
509         int ret;
510
511         wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
512         if (wm8994 == NULL)
513                 return -ENOMEM;
514
515         i2c_set_clientdata(i2c, wm8994);
516         wm8994->dev = &i2c->dev;
517         wm8994->irq = i2c->irq;
518         wm8994->type = id->driver_data;
519
520         wm8994->regmap = regmap_init_i2c(i2c, &wm8994_regmap_config);
521         if (IS_ERR(wm8994->regmap)) {
522                 ret = PTR_ERR(wm8994->regmap);
523                 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
524                         ret);
525                 kfree(wm8994);
526                 return ret;
527         }
528
529         return wm8994_device_init(wm8994, i2c->irq);
530 }
531
532 static int wm8994_i2c_remove(struct i2c_client *i2c)
533 {
534         struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
535
536         wm8994_device_exit(wm8994);
537
538         return 0;
539 }
540
541 static const struct i2c_device_id wm8994_i2c_id[] = {
542         { "wm8994", WM8994 },
543         { "wm8958", WM8958 },
544         { }
545 };
546 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
547
548 static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
549                             NULL);
550
551 static struct i2c_driver wm8994_i2c_driver = {
552         .driver = {
553                 .name = "wm8994",
554                 .owner = THIS_MODULE,
555                 .pm = &wm8994_pm_ops,
556         },
557         .probe = wm8994_i2c_probe,
558         .remove = wm8994_i2c_remove,
559         .id_table = wm8994_i2c_id,
560 };
561
562 static int __init wm8994_i2c_init(void)
563 {
564         int ret;
565
566         ret = i2c_add_driver(&wm8994_i2c_driver);
567         if (ret != 0)
568                 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
569
570         return ret;
571 }
572 module_init(wm8994_i2c_init);
573
574 static void __exit wm8994_i2c_exit(void)
575 {
576         i2c_del_driver(&wm8994_i2c_driver);
577 }
578 module_exit(wm8994_i2c_exit);
579
580 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
581 MODULE_LICENSE("GPL");
582 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");