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 static const __devinitdata struct reg_default wm8994_revc_patch[] = {
363 { 0x102, 0x3 },
364 { 0x56, 0x3 },
365 { 0x817, 0x0 },
366 { 0x102, 0x0 },
367 };
368
369 static const __devinitdata struct reg_default wm8958_reva_patch[] = {
370 { 0x102, 0x3 },
371 { 0xcb, 0x81 },
372 { 0x817, 0x0 },
373 { 0x102, 0x0 },
374 };
375
376 static const __devinitdata struct reg_default wm1811_reva_patch[] = {
377 { 0x102, 0x3 },
378 { 0x56, 0x7 },
379 { 0x5d, 0x7e },
380 { 0x5e, 0x0 },
381 { 0x102, 0x0 },
382 };
383
384 /*
385 * Instantiate the generic non-control parts of the device.
386 */
wm8994_device_init(struct wm8994 * wm8994,int irq)387 static __devinit int wm8994_device_init(struct wm8994 *wm8994, int irq)
388 {
389 struct wm8994_pdata *pdata = wm8994->dev->platform_data;
390 struct regmap_config *regmap_config;
391 const struct reg_default *regmap_patch = NULL;
392 const char *devname;
393 int ret, i, patch_regs;
394 int pulls = 0;
395
396 dev_set_drvdata(wm8994->dev, wm8994);
397
398 /* Add the on-chip regulators first for bootstrapping */
399 ret = mfd_add_devices(wm8994->dev, -1,
400 wm8994_regulator_devs,
401 ARRAY_SIZE(wm8994_regulator_devs),
402 NULL, 0);
403 if (ret != 0) {
404 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
405 goto err;
406 }
407
408 switch (wm8994->type) {
409 case WM1811:
410 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
411 break;
412 case WM8994:
413 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
414 break;
415 case WM8958:
416 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
417 break;
418 default:
419 BUG();
420 goto err;
421 }
422
423 wm8994->supplies = devm_kzalloc(wm8994->dev,
424 sizeof(struct regulator_bulk_data) *
425 wm8994->num_supplies, GFP_KERNEL);
426 if (!wm8994->supplies) {
427 ret = -ENOMEM;
428 goto err;
429 }
430
431 switch (wm8994->type) {
432 case WM1811:
433 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
434 wm8994->supplies[i].supply = wm1811_main_supplies[i];
435 break;
436 case WM8994:
437 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
438 wm8994->supplies[i].supply = wm8994_main_supplies[i];
439 break;
440 case WM8958:
441 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
442 wm8994->supplies[i].supply = wm8958_main_supplies[i];
443 break;
444 default:
445 BUG();
446 goto err;
447 }
448
449 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
450 wm8994->supplies);
451 if (ret != 0) {
452 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
453 goto err;
454 }
455
456 ret = regulator_bulk_enable(wm8994->num_supplies,
457 wm8994->supplies);
458 if (ret != 0) {
459 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
460 goto err_get;
461 }
462
463 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
464 if (ret < 0) {
465 dev_err(wm8994->dev, "Failed to read ID register\n");
466 goto err_enable;
467 }
468 switch (ret) {
469 case 0x1811:
470 devname = "WM1811";
471 if (wm8994->type != WM1811)
472 dev_warn(wm8994->dev, "Device registered as type %d\n",
473 wm8994->type);
474 wm8994->type = WM1811;
475 break;
476 case 0x8994:
477 devname = "WM8994";
478 if (wm8994->type != WM8994)
479 dev_warn(wm8994->dev, "Device registered as type %d\n",
480 wm8994->type);
481 wm8994->type = WM8994;
482 break;
483 case 0x8958:
484 devname = "WM8958";
485 if (wm8994->type != WM8958)
486 dev_warn(wm8994->dev, "Device registered as type %d\n",
487 wm8994->type);
488 wm8994->type = WM8958;
489 break;
490 default:
491 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
492 ret);
493 ret = -EINVAL;
494 goto err_enable;
495 }
496
497 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
498 if (ret < 0) {
499 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
500 ret);
501 goto err_enable;
502 }
503 wm8994->revision = ret;
504
505 switch (wm8994->type) {
506 case WM8994:
507 switch (wm8994->revision) {
508 case 0:
509 case 1:
510 dev_warn(wm8994->dev,
511 "revision %c not fully supported\n",
512 'A' + wm8994->revision);
513 break;
514 case 2:
515 case 3:
516 regmap_patch = wm8994_revc_patch;
517 patch_regs = ARRAY_SIZE(wm8994_revc_patch);
518 break;
519 default:
520 break;
521 }
522 break;
523
524 case WM8958:
525 switch (wm8994->revision) {
526 case 0:
527 regmap_patch = wm8958_reva_patch;
528 patch_regs = ARRAY_SIZE(wm8958_reva_patch);
529 break;
530 default:
531 break;
532 }
533 break;
534
535 case WM1811:
536 /* Revision C did not change the relevant layer */
537 if (wm8994->revision > 1)
538 wm8994->revision++;
539 switch (wm8994->revision) {
540 case 0:
541 case 1:
542 case 2:
543 case 3:
544 case 4:
545 regmap_patch = wm1811_reva_patch;
546 patch_regs = ARRAY_SIZE(wm1811_reva_patch);
547 break;
548 default:
549 break;
550 }
551 break;
552
553 default:
554 break;
555 }
556
557 dev_info(wm8994->dev, "%s revision %c\n", devname,
558 'A' + wm8994->revision);
559
560 switch (wm8994->type) {
561 case WM1811:
562 regmap_config = &wm1811_regmap_config;
563 break;
564 case WM8994:
565 regmap_config = &wm8994_regmap_config;
566 break;
567 case WM8958:
568 regmap_config = &wm8958_regmap_config;
569 break;
570 default:
571 dev_err(wm8994->dev, "Unknown device type %d\n", wm8994->type);
572 return -EINVAL;
573 }
574
575 ret = regmap_reinit_cache(wm8994->regmap, regmap_config);
576 if (ret != 0) {
577 dev_err(wm8994->dev, "Failed to reinit register cache: %d\n",
578 ret);
579 return ret;
580 }
581
582 if (regmap_patch) {
583 ret = regmap_register_patch(wm8994->regmap, regmap_patch,
584 patch_regs);
585 if (ret != 0) {
586 dev_err(wm8994->dev, "Failed to register patch: %d\n",
587 ret);
588 goto err;
589 }
590 }
591
592 if (pdata) {
593 wm8994->irq_base = pdata->irq_base;
594 wm8994->gpio_base = pdata->gpio_base;
595
596 /* GPIO configuration is only applied if it's non-zero */
597 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
598 if (pdata->gpio_defaults[i]) {
599 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
600 0xffff,
601 pdata->gpio_defaults[i]);
602 }
603 }
604
605 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
606
607 if (pdata->spkmode_pu)
608 pulls |= WM8994_SPKMODE_PU;
609 }
610
611 /* Disable unneeded pulls */
612 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
613 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD |
614 WM8994_SPKMODE_PU | WM8994_CSNADDR_PD,
615 pulls);
616
617 /* In some system designs where the regulators are not in use,
618 * we can achieve a small reduction in leakage currents by
619 * floating LDO outputs. This bit makes no difference if the
620 * LDOs are enabled, it only affects cases where the LDOs were
621 * in operation and are then disabled.
622 */
623 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
624 if (wm8994_ldo_in_use(pdata, i))
625 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
626 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
627 else
628 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
629 WM8994_LDO1_DISCH, 0);
630 }
631
632 wm8994_irq_init(wm8994);
633
634 ret = mfd_add_devices(wm8994->dev, -1,
635 wm8994_devs, ARRAY_SIZE(wm8994_devs),
636 NULL, 0);
637 if (ret != 0) {
638 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
639 goto err_irq;
640 }
641
642 pm_runtime_enable(wm8994->dev);
643 pm_runtime_idle(wm8994->dev);
644
645 return 0;
646
647 err_irq:
648 wm8994_irq_exit(wm8994);
649 err_enable:
650 regulator_bulk_disable(wm8994->num_supplies,
651 wm8994->supplies);
652 err_get:
653 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
654 err:
655 mfd_remove_devices(wm8994->dev);
656 return ret;
657 }
658
wm8994_device_exit(struct wm8994 * wm8994)659 static __devexit void wm8994_device_exit(struct wm8994 *wm8994)
660 {
661 pm_runtime_disable(wm8994->dev);
662 mfd_remove_devices(wm8994->dev);
663 wm8994_irq_exit(wm8994);
664 regulator_bulk_disable(wm8994->num_supplies,
665 wm8994->supplies);
666 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
667 }
668
669 static const struct of_device_id wm8994_of_match[] = {
670 { .compatible = "wlf,wm1811", },
671 { .compatible = "wlf,wm8994", },
672 { .compatible = "wlf,wm8958", },
673 { }
674 };
675 MODULE_DEVICE_TABLE(of, wm8994_of_match);
676
wm8994_i2c_probe(struct i2c_client * i2c,const struct i2c_device_id * id)677 static __devinit int wm8994_i2c_probe(struct i2c_client *i2c,
678 const struct i2c_device_id *id)
679 {
680 struct wm8994 *wm8994;
681 int ret;
682
683 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL);
684 if (wm8994 == NULL)
685 return -ENOMEM;
686
687 i2c_set_clientdata(i2c, wm8994);
688 wm8994->dev = &i2c->dev;
689 wm8994->irq = i2c->irq;
690 wm8994->type = id->driver_data;
691
692 wm8994->regmap = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config);
693 if (IS_ERR(wm8994->regmap)) {
694 ret = PTR_ERR(wm8994->regmap);
695 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
696 ret);
697 return ret;
698 }
699
700 return wm8994_device_init(wm8994, i2c->irq);
701 }
702
wm8994_i2c_remove(struct i2c_client * i2c)703 static __devexit int wm8994_i2c_remove(struct i2c_client *i2c)
704 {
705 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
706
707 wm8994_device_exit(wm8994);
708
709 return 0;
710 }
711
712 static const struct i2c_device_id wm8994_i2c_id[] = {
713 { "wm1811", WM1811 },
714 { "wm1811a", WM1811 },
715 { "wm8994", WM8994 },
716 { "wm8958", WM8958 },
717 { }
718 };
719 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
720
721 static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
722 NULL);
723
724 static struct i2c_driver wm8994_i2c_driver = {
725 .driver = {
726 .name = "wm8994",
727 .owner = THIS_MODULE,
728 .pm = &wm8994_pm_ops,
729 .of_match_table = wm8994_of_match,
730 },
731 .probe = wm8994_i2c_probe,
732 .remove = __devexit_p(wm8994_i2c_remove),
733 .id_table = wm8994_i2c_id,
734 };
735
wm8994_i2c_init(void)736 static int __init wm8994_i2c_init(void)
737 {
738 int ret;
739
740 ret = i2c_add_driver(&wm8994_i2c_driver);
741 if (ret != 0)
742 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
743
744 return ret;
745 }
746 module_init(wm8994_i2c_init);
747
wm8994_i2c_exit(void)748 static void __exit wm8994_i2c_exit(void)
749 {
750 i2c_del_driver(&wm8994_i2c_driver);
751 }
752 module_exit(wm8994_i2c_exit);
753
754 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
755 MODULE_LICENSE("GPL");
756 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
757