Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
wm8994-core.c
Go to the documentation of this file.
1 /*
2  * wm8994-core.c -- Device access for Wolfson WM8994
3  *
4  * Copyright 2009 Wolfson Microelectronics PLC.
5  *
6  * Author: Mark Brown <[email protected]>
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 
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 
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 
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 
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 
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
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_mark_dirty(wm8994->regmap);
287 
288  /* Restore GPIO registers to prevent problems with mismatched
289  * pin configurations.
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  /* In case one of the GPIOs is used as a wake input. */
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 
316 static int wm8994_resume(struct device *dev)
317 {
318  struct wm8994 *wm8994 = dev_get_drvdata(dev);
319  int ret;
320 
321  /* We may have lied to the PM core about suspending */
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  /* Disable LDO pulldowns while the device is active */
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 
348 err_enable:
349  regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies);
350 
351  return ret;
352 }
353 #endif
354 
355 #ifdef CONFIG_REGULATOR
356 static 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
371 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
372 {
373  return 0;
374 }
375 #endif
376 
377 static const __devinitconst struct reg_default wm8994_revc_patch[] = {
378  { 0x102, 0x3 },
379  { 0x56, 0x3 },
380  { 0x817, 0x0 },
381  { 0x102, 0x0 },
382 };
383 
384 static const __devinitconst struct reg_default wm8958_reva_patch[] = {
385  { 0x102, 0x3 },
386  { 0xcb, 0x81 },
387  { 0x817, 0x0 },
388  { 0x102, 0x0 },
389 };
390 
391 static const __devinitconst struct reg_default wm1811_reva_patch[] = {
392  { 0x102, 0x3 },
393  { 0x56, 0xc07 },
394  { 0x5d, 0x7e },
395  { 0x5e, 0x0 },
396  { 0x102, 0x0 },
397 };
398 
399 /*
400  * Instantiate the generic non-control parts of the device.
401  */
402 static __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  /* Add the on-chip regulators first for bootstrapping */
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  /* Revision C did not change the relevant layer */
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  /* GPIO configuration is only applied if it's non-zero */
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  /* Disable unneeded pulls */
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  /* In some system designs where the regulators are not in use,
633  * we can achieve a small reduction in leakage currents by
634  * floating LDO outputs. This bit makes no difference if the
635  * LDOs are enabled, it only affects cases where the LDOs were
636  * in operation and are then disabled.
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 
662 err_irq:
663  wm8994_irq_exit(wm8994);
664 err_enable:
665  regulator_bulk_disable(wm8994->num_supplies,
666  wm8994->supplies);
667 err_get:
668  regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
669 err:
670  mfd_remove_devices(wm8994->dev);
671  return ret;
672 }
673 
674 static __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 
684 static const struct of_device_id wm8994_of_match[] = {
685  { .compatible = "wlf,wm1811", },
686  { .compatible = "wlf,wm8994", },
687  { .compatible = "wlf,wm8958", },
688  { }
689 };
690 MODULE_DEVICE_TABLE(of, wm8994_of_match);
691 
692 static __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 
718 static __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 
727 static const struct i2c_device_id wm8994_i2c_id[] = {
728  { "wm1811", WM1811 },
729  { "wm1811a", WM1811 },
730  { "wm8994", WM8994 },
731  { "wm8958", WM8958 },
732  { }
733 };
734 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
735 
736 static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
737  NULL);
738 
739 static 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 
751 module_i2c_driver(wm8994_i2c_driver);
752 
753 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
754 MODULE_LICENSE("GPL");
755 MODULE_AUTHOR("Mark Brown <[email protected]>");
Generated on Thu Jan 10 2013 13:54:28 for Linux Kernel by   doxygen 1.8.2