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 #include "wm8994.h"
32
33 /**
34 * wm8994_reg_read: Read a single WM8994 register.
35 *
36 * @wm8994: Device to read from.
37 * @reg: Register to read.
38 */
wm8994_reg_read(struct wm8994 * wm8994,unsigned short reg)39 int 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 }
51 EXPORT_SYMBOL_GPL(wm8994_reg_read);
52
53 /**
54 * wm8994_bulk_read: Read multiple WM8994 registers
55 *
56 * @wm8994: Device to read from
57 * @reg: First register
58 * @count: Number of registers
59 * @buf: Buffer to fill. The data will be returned big endian.
60 */
wm8994_bulk_read(struct wm8994 * wm8994,unsigned short reg,int count,u16 * buf)61 int 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 * wm8994_reg_write: Write a single WM8994 register.
69 *
70 * @wm8994: Device to write to.
71 * @reg: Register to write to.
72 * @val: Value to write.
73 */
wm8994_reg_write(struct wm8994 * wm8994,unsigned short reg,unsigned short val)74 int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
75 unsigned short val)
76 {
77 return regmap_write(wm8994->regmap, reg, val);
78 }
79 EXPORT_SYMBOL_GPL(wm8994_reg_write);
80
81 /**
82 * wm8994_bulk_write: Write multiple WM8994 registers
83 *
84 * @wm8994: Device to write to
85 * @reg: First register
86 * @count: Number of registers
87 * @buf: Buffer to write from. Data must be big-endian formatted.
88 */
wm8994_bulk_write(struct wm8994 * wm8994,unsigned short reg,int count,const u16 * buf)89 int 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 }
94 EXPORT_SYMBOL_GPL(wm8994_bulk_write);
95
96 /**
97 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
98 *
99 * @wm8994: Device to write to.
100 * @reg: Register to write to.
101 * @mask: Mask of bits to set.
102 * @val: Value to set (unshifted)
103 */
wm8994_set_bits(struct wm8994 * wm8994,unsigned short reg,unsigned short mask,unsigned short val)104 int 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 }
109 EXPORT_SYMBOL_GPL(wm8994_set_bits);
110
111 static 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
124 static 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
132 static 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
140 static 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 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
157 * and should be handled via the standard regulator API supply
158 * management.
159 */
160 static 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
172 static const char *wm8994_main_supplies[] = {
173 "DBVDD",
174 "DCVDD",
175 "AVDD1",
176 "AVDD2",
177 "CPVDD",
178 "SPKVDD1",
179 "SPKVDD2",
180 };
181
182 static 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
wm8994_suspend(struct device * dev)195 static int wm8994_suspend(struct device *dev)
196 {
197 struct wm8994 *wm8994 = dev_get_drvdata(dev);
198 int ret;
199
200 /* Don't actually go through with the suspend if the CODEC is
201 * still active (eg, for audio passthrough from CP. */
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 /* Disable LDO pulldowns while the device is suspended if we
274 * don't know that something will be driving them. */
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 /* Explicitly put the device into reset in case regulators
281 * don't get disabled in order to ensure consistent restart.
282 */
283 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET,
284 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
285
286 regcache_cache_only(wm8994->regmap, true);
287 regcache_mark_dirty(wm8994->regmap);
288
289 wm8994->suspended = true;
290
291 ret = regulator_bulk_disable(wm8994->num_supplies,
292 wm8994->supplies);
293 if (ret != 0) {
294 dev_err(dev, "Failed to disable supplies: %d\n", ret);
295 return ret;
296 }
297
298 return 0;
299 }
300
wm8994_resume(struct device * dev)301 static int wm8994_resume(struct device *dev)
302 {
303 struct wm8994 *wm8994 = dev_get_drvdata(dev);
304 int ret;
305
306 /* We may have lied to the PM core about suspending */
307 if (!wm8994->suspended)
308 return 0;
309
310 ret = regulator_bulk_enable(wm8994->num_supplies,
311 wm8994->supplies);
312 if (ret != 0) {
313 dev_err(dev, "Failed to enable supplies: %d\n", ret);
314 return ret;
315 }
316
317 regcache_cache_only(wm8994->regmap, false);
318 ret = regcache_sync(wm8994->regmap);
319 if (ret != 0) {
320 dev_err(dev, "Failed to restore register map: %d\n", ret);
321 goto err_enable;
322 }
323
324 /* Disable LDO pulldowns while the device is active */
325 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
326 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
327 0);
328
329 wm8994->suspended = false;
330
331 return 0;
332
333 err_enable:
334 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies);
335
336 return ret;
337 }
338 #endif
339
340 #ifdef CONFIG_REGULATOR
wm8994_ldo_in_use(struct wm8994_pdata * pdata,int ldo)341 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
342 {
343 struct wm8994_ldo_pdata *ldo_pdata;
344
345 if (!pdata)
346 return 0;
347
348 ldo_pdata = &pdata->ldo[ldo];
349
350 if (!ldo_pdata->init_data)
351 return 0;
352
353 return ldo_pdata->init_data->num_consumer_supplies != 0;
354 }
355 #else
wm8994_ldo_in_use(struct wm8994_pdata * pdata,int ldo)356 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
357 {
358 return 0;
359 }
360 #endif
361
362 /*
363 * Instantiate the generic non-control parts of the device.
364 */
wm8994_device_init(struct wm8994 * wm8994,int irq)365 static int wm8994_device_init(struct wm8994 *wm8994, int irq)
366 {
367 struct wm8994_pdata *pdata = wm8994->dev->platform_data;
368 struct regmap_config *regmap_config;
369 const char *devname;
370 int ret, i;
371 int pulls = 0;
372
373 dev_set_drvdata(wm8994->dev, wm8994);
374
375 /* Add the on-chip regulators first for bootstrapping */
376 ret = mfd_add_devices(wm8994->dev, -1,
377 wm8994_regulator_devs,
378 ARRAY_SIZE(wm8994_regulator_devs),
379 NULL, 0);
380 if (ret != 0) {
381 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
382 goto err_regmap;
383 }
384
385 switch (wm8994->type) {
386 case WM1811:
387 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
388 break;
389 case WM8994:
390 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
391 break;
392 case WM8958:
393 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
394 break;
395 default:
396 BUG();
397 goto err_regmap;
398 }
399
400 wm8994->supplies = devm_kzalloc(wm8994->dev,
401 sizeof(struct regulator_bulk_data) *
402 wm8994->num_supplies, GFP_KERNEL);
403 if (!wm8994->supplies) {
404 ret = -ENOMEM;
405 goto err_regmap;
406 }
407
408 switch (wm8994->type) {
409 case WM1811:
410 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
411 wm8994->supplies[i].supply = wm1811_main_supplies[i];
412 break;
413 case WM8994:
414 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
415 wm8994->supplies[i].supply = wm8994_main_supplies[i];
416 break;
417 case WM8958:
418 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
419 wm8994->supplies[i].supply = wm8958_main_supplies[i];
420 break;
421 default:
422 BUG();
423 goto err_regmap;
424 }
425
426 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
427 wm8994->supplies);
428 if (ret != 0) {
429 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
430 goto err_regmap;
431 }
432
433 ret = regulator_bulk_enable(wm8994->num_supplies,
434 wm8994->supplies);
435 if (ret != 0) {
436 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
437 goto err_get;
438 }
439
440 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
441 if (ret < 0) {
442 dev_err(wm8994->dev, "Failed to read ID register\n");
443 goto err_enable;
444 }
445 switch (ret) {
446 case 0x1811:
447 devname = "WM1811";
448 if (wm8994->type != WM1811)
449 dev_warn(wm8994->dev, "Device registered as type %d\n",
450 wm8994->type);
451 wm8994->type = WM1811;
452 break;
453 case 0x8994:
454 devname = "WM8994";
455 if (wm8994->type != WM8994)
456 dev_warn(wm8994->dev, "Device registered as type %d\n",
457 wm8994->type);
458 wm8994->type = WM8994;
459 break;
460 case 0x8958:
461 devname = "WM8958";
462 if (wm8994->type != WM8958)
463 dev_warn(wm8994->dev, "Device registered as type %d\n",
464 wm8994->type);
465 wm8994->type = WM8958;
466 break;
467 default:
468 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
469 ret);
470 ret = -EINVAL;
471 goto err_enable;
472 }
473
474 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
475 if (ret < 0) {
476 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
477 ret);
478 goto err_enable;
479 }
480 wm8994->revision = ret;
481
482 switch (wm8994->type) {
483 case WM8994:
484 switch (wm8994->revision) {
485 case 0:
486 case 1:
487 dev_warn(wm8994->dev,
488 "revision %c not fully supported\n",
489 'A' + wm8994->revision);
490 break;
491 default:
492 break;
493 }
494 break;
495 case WM1811:
496 /* Revision C did not change the relevant layer */
497 if (wm8994->revision > 1)
498 wm8994->revision++;
499 break;
500 default:
501 break;
502 }
503
504 dev_info(wm8994->dev, "%s revision %c\n", devname,
505 'A' + wm8994->revision);
506
507 switch (wm8994->type) {
508 case WM1811:
509 regmap_config = &wm1811_regmap_config;
510 break;
511 case WM8994:
512 regmap_config = &wm8994_regmap_config;
513 break;
514 case WM8958:
515 regmap_config = &wm8958_regmap_config;
516 break;
517 default:
518 dev_err(wm8994->dev, "Unknown device type %d\n", wm8994->type);
519 return -EINVAL;
520 }
521
522 ret = regmap_reinit_cache(wm8994->regmap, regmap_config);
523 if (ret != 0) {
524 dev_err(wm8994->dev, "Failed to reinit register cache: %d\n",
525 ret);
526 return ret;
527 }
528
529 if (pdata) {
530 wm8994->irq_base = pdata->irq_base;
531 wm8994->gpio_base = pdata->gpio_base;
532
533 /* GPIO configuration is only applied if it's non-zero */
534 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
535 if (pdata->gpio_defaults[i]) {
536 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
537 0xffff,
538 pdata->gpio_defaults[i]);
539 }
540 }
541
542 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
543
544 if (pdata->spkmode_pu)
545 pulls |= WM8994_SPKMODE_PU;
546 }
547
548 /* Disable unneeded pulls */
549 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
550 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD |
551 WM8994_SPKMODE_PU | WM8994_CSNADDR_PD,
552 pulls);
553
554 /* In some system designs where the regulators are not in use,
555 * we can achieve a small reduction in leakage currents by
556 * floating LDO outputs. This bit makes no difference if the
557 * LDOs are enabled, it only affects cases where the LDOs were
558 * in operation and are then disabled.
559 */
560 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
561 if (wm8994_ldo_in_use(pdata, i))
562 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
563 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
564 else
565 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
566 WM8994_LDO1_DISCH, 0);
567 }
568
569 wm8994_irq_init(wm8994);
570
571 ret = mfd_add_devices(wm8994->dev, -1,
572 wm8994_devs, ARRAY_SIZE(wm8994_devs),
573 NULL, 0);
574 if (ret != 0) {
575 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
576 goto err_irq;
577 }
578
579 pm_runtime_enable(wm8994->dev);
580 pm_runtime_resume(wm8994->dev);
581
582 return 0;
583
584 err_irq:
585 wm8994_irq_exit(wm8994);
586 err_enable:
587 regulator_bulk_disable(wm8994->num_supplies,
588 wm8994->supplies);
589 err_get:
590 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
591 err_regmap:
592 regmap_exit(wm8994->regmap);
593 mfd_remove_devices(wm8994->dev);
594 return ret;
595 }
596
wm8994_device_exit(struct wm8994 * wm8994)597 static void wm8994_device_exit(struct wm8994 *wm8994)
598 {
599 pm_runtime_disable(wm8994->dev);
600 mfd_remove_devices(wm8994->dev);
601 wm8994_irq_exit(wm8994);
602 regulator_bulk_disable(wm8994->num_supplies,
603 wm8994->supplies);
604 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
605 regmap_exit(wm8994->regmap);
606 }
607
608 static const struct of_device_id wm8994_of_match[] = {
609 { .compatible = "wlf,wm1811", },
610 { .compatible = "wlf,wm8994", },
611 { .compatible = "wlf,wm8958", },
612 { }
613 };
614 MODULE_DEVICE_TABLE(of, wm8994_of_match);
615
wm8994_i2c_probe(struct i2c_client * i2c,const struct i2c_device_id * id)616 static int wm8994_i2c_probe(struct i2c_client *i2c,
617 const struct i2c_device_id *id)
618 {
619 struct wm8994 *wm8994;
620 int ret;
621
622 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL);
623 if (wm8994 == NULL)
624 return -ENOMEM;
625
626 i2c_set_clientdata(i2c, wm8994);
627 wm8994->dev = &i2c->dev;
628 wm8994->irq = i2c->irq;
629 wm8994->type = id->driver_data;
630
631 wm8994->regmap = regmap_init_i2c(i2c, &wm8994_base_regmap_config);
632 if (IS_ERR(wm8994->regmap)) {
633 ret = PTR_ERR(wm8994->regmap);
634 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
635 ret);
636 return ret;
637 }
638
639 return wm8994_device_init(wm8994, i2c->irq);
640 }
641
wm8994_i2c_remove(struct i2c_client * i2c)642 static int wm8994_i2c_remove(struct i2c_client *i2c)
643 {
644 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
645
646 wm8994_device_exit(wm8994);
647
648 return 0;
649 }
650
651 static const struct i2c_device_id wm8994_i2c_id[] = {
652 { "wm1811", WM1811 },
653 { "wm1811a", WM1811 },
654 { "wm8994", WM8994 },
655 { "wm8958", WM8958 },
656 { }
657 };
658 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
659
660 static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
661 NULL);
662
663 static struct i2c_driver wm8994_i2c_driver = {
664 .driver = {
665 .name = "wm8994",
666 .owner = THIS_MODULE,
667 .pm = &wm8994_pm_ops,
668 .of_match_table = wm8994_of_match,
669 },
670 .probe = wm8994_i2c_probe,
671 .remove = wm8994_i2c_remove,
672 .id_table = wm8994_i2c_id,
673 };
674
wm8994_i2c_init(void)675 static int __init wm8994_i2c_init(void)
676 {
677 int ret;
678
679 ret = i2c_add_driver(&wm8994_i2c_driver);
680 if (ret != 0)
681 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
682
683 return ret;
684 }
685 module_init(wm8994_i2c_init);
686
wm8994_i2c_exit(void)687 static void __exit wm8994_i2c_exit(void)
688 {
689 i2c_del_driver(&wm8994_i2c_driver);
690 }
691 module_exit(wm8994_i2c_exit);
692
693 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
694 MODULE_LICENSE("GPL");
695 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
696