Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/sound/soc/codecs/wm8741.c

  1 /*
  2  * wm8741.c  --  WM8741 ALSA SoC Audio driver
  3  *
  4  * Copyright 2010-1 Wolfson Microelectronics plc
  5  *
  6  * Author: Ian Lartey <ian@opensource.wolfsonmicro.com>
  7  *
  8  *
  9  * This program is free software; you can redistribute it and/or modify
 10  * it under the terms of the GNU General Public License version 2 as
 11  * published by the Free Software Foundation.
 12  */
 13 
 14 #include <linux/module.h>
 15 #include <linux/moduleparam.h>
 16 #include <linux/init.h>
 17 #include <linux/delay.h>
 18 #include <linux/pm.h>
 19 #include <linux/i2c.h>
 20 #include <linux/spi/spi.h>
 21 #include <linux/regmap.h>
 22 #include <linux/regulator/consumer.h>
 23 #include <linux/slab.h>
 24 #include <linux/of_device.h>
 25 #include <sound/core.h>
 26 #include <sound/pcm.h>
 27 #include <sound/pcm_params.h>
 28 #include <sound/soc.h>
 29 #include <sound/initval.h>
 30 #include <sound/tlv.h>
 31 
 32 #include "wm8741.h"
 33 
 34 #define WM8741_NUM_SUPPLIES 2
 35 static const char *wm8741_supply_names[WM8741_NUM_SUPPLIES] = {
 36         "AVDD",
 37         "DVDD",
 38 };
 39 
 40 #define WM8741_NUM_RATES 6
 41 
 42 /* codec private data */
 43 struct wm8741_priv {
 44         struct regmap *regmap;
 45         struct regulator_bulk_data supplies[WM8741_NUM_SUPPLIES];
 46         unsigned int sysclk;
 47         const struct snd_pcm_hw_constraint_list *sysclk_constraints;
 48 };
 49 
 50 static const struct reg_default wm8741_reg_defaults[] = {
 51         {  0, 0x0000 },     /* R0  - DACLLSB Attenuation */
 52         {  1, 0x0000 },     /* R1  - DACLMSB Attenuation */
 53         {  2, 0x0000 },     /* R2  - DACRLSB Attenuation */
 54         {  3, 0x0000 },     /* R3  - DACRMSB Attenuation */
 55         {  4, 0x0000 },     /* R4  - Volume Control */
 56         {  5, 0x000A },     /* R5  - Format Control */
 57         {  6, 0x0000 },     /* R6  - Filter Control */
 58         {  7, 0x0000 },     /* R7  - Mode Control 1 */
 59         {  8, 0x0002 },     /* R8  - Mode Control 2 */
 60         { 32, 0x0002 },     /* R32 - ADDITONAL_CONTROL_1 */
 61 };
 62 
 63 static bool wm8741_readable(struct device *dev, unsigned int reg)
 64 {
 65         switch (reg) {
 66         case WM8741_DACLLSB_ATTENUATION:
 67         case WM8741_DACLMSB_ATTENUATION:
 68         case WM8741_DACRLSB_ATTENUATION:
 69         case WM8741_DACRMSB_ATTENUATION:
 70         case WM8741_VOLUME_CONTROL:
 71         case WM8741_FORMAT_CONTROL:
 72         case WM8741_FILTER_CONTROL:
 73         case WM8741_MODE_CONTROL_1:
 74         case WM8741_MODE_CONTROL_2:
 75         case WM8741_ADDITIONAL_CONTROL_1:
 76                 return true;
 77         default:
 78                 return false;
 79         }
 80 }
 81 
 82 static int wm8741_reset(struct snd_soc_codec *codec)
 83 {
 84         return snd_soc_write(codec, WM8741_RESET, 0);
 85 }
 86 
 87 static const DECLARE_TLV_DB_SCALE(dac_tlv_fine, -12700, 13, 0);
 88 static const DECLARE_TLV_DB_SCALE(dac_tlv, -12700, 400, 0);
 89 
 90 static const struct snd_kcontrol_new wm8741_snd_controls[] = {
 91 SOC_DOUBLE_R_TLV("Fine Playback Volume", WM8741_DACLLSB_ATTENUATION,
 92                  WM8741_DACRLSB_ATTENUATION, 1, 255, 1, dac_tlv_fine),
 93 SOC_DOUBLE_R_TLV("Playback Volume", WM8741_DACLMSB_ATTENUATION,
 94                  WM8741_DACRMSB_ATTENUATION, 0, 511, 1, dac_tlv),
 95 };
 96 
 97 static const struct snd_soc_dapm_widget wm8741_dapm_widgets[] = {
 98 SND_SOC_DAPM_DAC("DACL", "Playback", SND_SOC_NOPM, 0, 0),
 99 SND_SOC_DAPM_DAC("DACR", "Playback", SND_SOC_NOPM, 0, 0),
100 SND_SOC_DAPM_OUTPUT("VOUTLP"),
101 SND_SOC_DAPM_OUTPUT("VOUTLN"),
102 SND_SOC_DAPM_OUTPUT("VOUTRP"),
103 SND_SOC_DAPM_OUTPUT("VOUTRN"),
104 };
105 
106 static const struct snd_soc_dapm_route wm8741_dapm_routes[] = {
107         { "VOUTLP", NULL, "DACL" },
108         { "VOUTLN", NULL, "DACL" },
109         { "VOUTRP", NULL, "DACR" },
110         { "VOUTRN", NULL, "DACR" },
111 };
112 
113 static struct {
114         int value;
115         int ratio;
116 } lrclk_ratios[WM8741_NUM_RATES] = {
117         { 1, 128 },
118         { 2, 192 },
119         { 3, 256 },
120         { 4, 384 },
121         { 5, 512 },
122         { 6, 768 },
123 };
124 
125 static const unsigned int rates_11289[] = {
126         44100, 88235,
127 };
128 
129 static const struct snd_pcm_hw_constraint_list constraints_11289 = {
130         .count  = ARRAY_SIZE(rates_11289),
131         .list   = rates_11289,
132 };
133 
134 static const unsigned int rates_12288[] = {
135         32000, 48000, 96000,
136 };
137 
138 static const struct snd_pcm_hw_constraint_list constraints_12288 = {
139         .count  = ARRAY_SIZE(rates_12288),
140         .list   = rates_12288,
141 };
142 
143 static const unsigned int rates_16384[] = {
144         32000,
145 };
146 
147 static const struct snd_pcm_hw_constraint_list constraints_16384 = {
148         .count  = ARRAY_SIZE(rates_16384),
149         .list   = rates_16384,
150 };
151 
152 static const unsigned int rates_16934[] = {
153         44100, 88235,
154 };
155 
156 static const struct snd_pcm_hw_constraint_list constraints_16934 = {
157         .count  = ARRAY_SIZE(rates_16934),
158         .list   = rates_16934,
159 };
160 
161 static const unsigned int rates_18432[] = {
162         48000, 96000,
163 };
164 
165 static const struct snd_pcm_hw_constraint_list constraints_18432 = {
166         .count  = ARRAY_SIZE(rates_18432),
167         .list   = rates_18432,
168 };
169 
170 static const unsigned int rates_22579[] = {
171         44100, 88235, 1764000
172 };
173 
174 static const struct snd_pcm_hw_constraint_list constraints_22579 = {
175         .count  = ARRAY_SIZE(rates_22579),
176         .list   = rates_22579,
177 };
178 
179 static const unsigned int rates_24576[] = {
180         32000, 48000, 96000, 192000
181 };
182 
183 static const struct snd_pcm_hw_constraint_list constraints_24576 = {
184         .count  = ARRAY_SIZE(rates_24576),
185         .list   = rates_24576,
186 };
187 
188 static const unsigned int rates_36864[] = {
189         48000, 96000, 19200
190 };
191 
192 static const struct snd_pcm_hw_constraint_list constraints_36864 = {
193         .count  = ARRAY_SIZE(rates_36864),
194         .list   = rates_36864,
195 };
196 
197 
198 static int wm8741_startup(struct snd_pcm_substream *substream,
199                           struct snd_soc_dai *dai)
200 {
201         struct snd_soc_codec *codec = dai->codec;
202         struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
203 
204         /* The set of sample rates that can be supported depends on the
205          * MCLK supplied to the CODEC - enforce this.
206          */
207         if (!wm8741->sysclk) {
208                 dev_err(codec->dev,
209                         "No MCLK configured, call set_sysclk() on init\n");
210                 return -EINVAL;
211         }
212 
213         snd_pcm_hw_constraint_list(substream->runtime, 0,
214                                    SNDRV_PCM_HW_PARAM_RATE,
215                                    wm8741->sysclk_constraints);
216 
217         return 0;
218 }
219 
220 static int wm8741_hw_params(struct snd_pcm_substream *substream,
221                             struct snd_pcm_hw_params *params,
222                             struct snd_soc_dai *dai)
223 {
224         struct snd_soc_codec *codec = dai->codec;
225         struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
226         u16 iface = snd_soc_read(codec, WM8741_FORMAT_CONTROL) & 0x1FC;
227         int i;
228 
229         /* Find a supported LRCLK ratio */
230         for (i = 0; i < ARRAY_SIZE(lrclk_ratios); i++) {
231                 if (wm8741->sysclk / params_rate(params) ==
232                     lrclk_ratios[i].ratio)
233                         break;
234         }
235 
236         /* Should never happen, should be handled by constraints */
237         if (i == ARRAY_SIZE(lrclk_ratios)) {
238                 dev_err(codec->dev, "MCLK/fs ratio %d unsupported\n",
239                         wm8741->sysclk / params_rate(params));
240                 return -EINVAL;
241         }
242 
243         /* bit size */
244         switch (params_format(params)) {
245         case SNDRV_PCM_FORMAT_S16_LE:
246                 break;
247         case SNDRV_PCM_FORMAT_S20_3LE:
248                 iface |= 0x0001;
249                 break;
250         case SNDRV_PCM_FORMAT_S24_LE:
251                 iface |= 0x0002;
252                 break;
253         case SNDRV_PCM_FORMAT_S32_LE:
254                 iface |= 0x0003;
255                 break;
256         default:
257                 dev_dbg(codec->dev, "wm8741_hw_params:    Unsupported bit size param = %d",
258                         params_format(params));
259                 return -EINVAL;
260         }
261 
262         dev_dbg(codec->dev, "wm8741_hw_params:    bit size param = %d",
263                 params_format(params));
264 
265         snd_soc_write(codec, WM8741_FORMAT_CONTROL, iface);
266         return 0;
267 }
268 
269 static int wm8741_set_dai_sysclk(struct snd_soc_dai *codec_dai,
270                 int clk_id, unsigned int freq, int dir)
271 {
272         struct snd_soc_codec *codec = codec_dai->codec;
273         struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
274 
275         dev_dbg(codec->dev, "wm8741_set_dai_sysclk info: freq=%dHz\n", freq);
276 
277         switch (freq) {
278         case 11289600:
279                 wm8741->sysclk_constraints = &constraints_11289;
280                 wm8741->sysclk = freq;
281                 return 0;
282 
283         case 12288000:
284                 wm8741->sysclk_constraints = &constraints_12288;
285                 wm8741->sysclk = freq;
286                 return 0;
287 
288         case 16384000:
289                 wm8741->sysclk_constraints = &constraints_16384;
290                 wm8741->sysclk = freq;
291                 return 0;
292 
293         case 16934400:
294                 wm8741->sysclk_constraints = &constraints_16934;
295                 wm8741->sysclk = freq;
296                 return 0;
297 
298         case 18432000:
299                 wm8741->sysclk_constraints = &constraints_18432;
300                 wm8741->sysclk = freq;
301                 return 0;
302 
303         case 22579200:
304         case 33868800:
305                 wm8741->sysclk_constraints = &constraints_22579;
306                 wm8741->sysclk = freq;
307                 return 0;
308 
309         case 24576000:
310                 wm8741->sysclk_constraints = &constraints_24576;
311                 wm8741->sysclk = freq;
312                 return 0;
313 
314         case 36864000:
315                 wm8741->sysclk_constraints = &constraints_36864;
316                 wm8741->sysclk = freq;
317                 return 0;
318         }
319         return -EINVAL;
320 }
321 
322 static int wm8741_set_dai_fmt(struct snd_soc_dai *codec_dai,
323                 unsigned int fmt)
324 {
325         struct snd_soc_codec *codec = codec_dai->codec;
326         u16 iface = snd_soc_read(codec, WM8741_FORMAT_CONTROL) & 0x1C3;
327 
328         /* check master/slave audio interface */
329         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
330         case SND_SOC_DAIFMT_CBS_CFS:
331                 break;
332         default:
333                 return -EINVAL;
334         }
335 
336         /* interface format */
337         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
338         case SND_SOC_DAIFMT_I2S:
339                 iface |= 0x0008;
340                 break;
341         case SND_SOC_DAIFMT_RIGHT_J:
342                 break;
343         case SND_SOC_DAIFMT_LEFT_J:
344                 iface |= 0x0004;
345                 break;
346         case SND_SOC_DAIFMT_DSP_A:
347                 iface |= 0x000C;
348                 break;
349         case SND_SOC_DAIFMT_DSP_B:
350                 iface |= 0x001C;
351                 break;
352         default:
353                 return -EINVAL;
354         }
355 
356         /* clock inversion */
357         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
358         case SND_SOC_DAIFMT_NB_NF:
359                 break;
360         case SND_SOC_DAIFMT_IB_IF:
361                 iface |= 0x0010;
362                 break;
363         case SND_SOC_DAIFMT_IB_NF:
364                 iface |= 0x0020;
365                 break;
366         case SND_SOC_DAIFMT_NB_IF:
367                 iface |= 0x0030;
368                 break;
369         default:
370                 return -EINVAL;
371         }
372 
373 
374         dev_dbg(codec->dev, "wm8741_set_dai_fmt:    Format=%x, Clock Inv=%x\n",
375                                 fmt & SND_SOC_DAIFMT_FORMAT_MASK,
376                                 ((fmt & SND_SOC_DAIFMT_INV_MASK)));
377 
378         snd_soc_write(codec, WM8741_FORMAT_CONTROL, iface);
379         return 0;
380 }
381 
382 #define WM8741_RATES (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \
383                         SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | \
384                         SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 | \
385                         SNDRV_PCM_RATE_192000)
386 
387 #define WM8741_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
388                         SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
389 
390 static const struct snd_soc_dai_ops wm8741_dai_ops = {
391         .startup        = wm8741_startup,
392         .hw_params      = wm8741_hw_params,
393         .set_sysclk     = wm8741_set_dai_sysclk,
394         .set_fmt        = wm8741_set_dai_fmt,
395 };
396 
397 static struct snd_soc_dai_driver wm8741_dai = {
398         .name = "wm8741",
399         .playback = {
400                 .stream_name = "Playback",
401                 .channels_min = 2,  /* Mono modes not yet supported */
402                 .channels_max = 2,
403                 .rates = WM8741_RATES,
404                 .formats = WM8741_FORMATS,
405         },
406         .ops = &wm8741_dai_ops,
407 };
408 
409 #ifdef CONFIG_PM
410 static int wm8741_resume(struct snd_soc_codec *codec)
411 {
412         snd_soc_cache_sync(codec);
413         return 0;
414 }
415 #else
416 #define wm8741_suspend NULL
417 #define wm8741_resume NULL
418 #endif
419 
420 static int wm8741_probe(struct snd_soc_codec *codec)
421 {
422         struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
423         int ret = 0;
424 
425         ret = regulator_bulk_enable(ARRAY_SIZE(wm8741->supplies),
426                                     wm8741->supplies);
427         if (ret != 0) {
428                 dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
429                 goto err_get;
430         }
431 
432         ret = wm8741_reset(codec);
433         if (ret < 0) {
434                 dev_err(codec->dev, "Failed to issue reset\n");
435                 goto err_enable;
436         }
437 
438         /* Change some default settings - latch VU */
439         snd_soc_update_bits(codec, WM8741_DACLLSB_ATTENUATION,
440                             WM8741_UPDATELL, WM8741_UPDATELL);
441         snd_soc_update_bits(codec, WM8741_DACLMSB_ATTENUATION,
442                             WM8741_UPDATELM, WM8741_UPDATELM);
443         snd_soc_update_bits(codec, WM8741_DACRLSB_ATTENUATION,
444                             WM8741_UPDATERL, WM8741_UPDATERL);
445         snd_soc_update_bits(codec, WM8741_DACRMSB_ATTENUATION,
446                             WM8741_UPDATERM, WM8741_UPDATERM);
447 
448         dev_dbg(codec->dev, "Successful registration\n");
449         return ret;
450 
451 err_enable:
452         regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
453 err_get:
454         return ret;
455 }
456 
457 static int wm8741_remove(struct snd_soc_codec *codec)
458 {
459         struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
460 
461         regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
462 
463         return 0;
464 }
465 
466 static struct snd_soc_codec_driver soc_codec_dev_wm8741 = {
467         .probe =        wm8741_probe,
468         .remove =       wm8741_remove,
469         .resume =       wm8741_resume,
470 
471         .controls = wm8741_snd_controls,
472         .num_controls = ARRAY_SIZE(wm8741_snd_controls),
473         .dapm_widgets = wm8741_dapm_widgets,
474         .num_dapm_widgets = ARRAY_SIZE(wm8741_dapm_widgets),
475         .dapm_routes = wm8741_dapm_routes,
476         .num_dapm_routes = ARRAY_SIZE(wm8741_dapm_routes),
477 };
478 
479 static const struct of_device_id wm8741_of_match[] = {
480         { .compatible = "wlf,wm8741", },
481         { }
482 };
483 MODULE_DEVICE_TABLE(of, wm8741_of_match);
484 
485 static const struct regmap_config wm8741_regmap = {
486         .reg_bits = 7,
487         .val_bits = 9,
488         .max_register = WM8741_MAX_REGISTER,
489 
490         .reg_defaults = wm8741_reg_defaults,
491         .num_reg_defaults = ARRAY_SIZE(wm8741_reg_defaults),
492         .cache_type = REGCACHE_RBTREE,
493 
494         .readable_reg = wm8741_readable,
495 };
496 
497 #if IS_ENABLED(CONFIG_I2C)
498 static int wm8741_i2c_probe(struct i2c_client *i2c,
499                             const struct i2c_device_id *id)
500 {
501         struct wm8741_priv *wm8741;
502         int ret, i;
503 
504         wm8741 = devm_kzalloc(&i2c->dev, sizeof(struct wm8741_priv),
505                               GFP_KERNEL);
506         if (wm8741 == NULL)
507                 return -ENOMEM;
508 
509         for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
510                 wm8741->supplies[i].supply = wm8741_supply_names[i];
511 
512         ret = devm_regulator_bulk_get(&i2c->dev, ARRAY_SIZE(wm8741->supplies),
513                                       wm8741->supplies);
514         if (ret != 0) {
515                 dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret);
516                 return ret;
517         }
518 
519         wm8741->regmap = devm_regmap_init_i2c(i2c, &wm8741_regmap);
520         if (IS_ERR(wm8741->regmap)) {
521                 ret = PTR_ERR(wm8741->regmap);
522                 dev_err(&i2c->dev, "Failed to init regmap: %d\n", ret);
523                 return ret;
524         }
525 
526         i2c_set_clientdata(i2c, wm8741);
527 
528         ret = snd_soc_register_codec(&i2c->dev,
529                                      &soc_codec_dev_wm8741, &wm8741_dai, 1);
530 
531         return ret;
532 }
533 
534 static int wm8741_i2c_remove(struct i2c_client *client)
535 {
536         snd_soc_unregister_codec(&client->dev);
537         return 0;
538 }
539 
540 static const struct i2c_device_id wm8741_i2c_id[] = {
541         { "wm8741", 0 },
542         { }
543 };
544 MODULE_DEVICE_TABLE(i2c, wm8741_i2c_id);
545 
546 static struct i2c_driver wm8741_i2c_driver = {
547         .driver = {
548                 .name = "wm8741",
549                 .owner = THIS_MODULE,
550                 .of_match_table = wm8741_of_match,
551         },
552         .probe =    wm8741_i2c_probe,
553         .remove =   wm8741_i2c_remove,
554         .id_table = wm8741_i2c_id,
555 };
556 #endif
557 
558 #if defined(CONFIG_SPI_MASTER)
559 static int wm8741_spi_probe(struct spi_device *spi)
560 {
561         struct wm8741_priv *wm8741;
562         int ret, i;
563 
564         wm8741 = devm_kzalloc(&spi->dev, sizeof(struct wm8741_priv),
565                              GFP_KERNEL);
566         if (wm8741 == NULL)
567                 return -ENOMEM;
568 
569         for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
570                 wm8741->supplies[i].supply = wm8741_supply_names[i];
571 
572         ret = devm_regulator_bulk_get(&spi->dev, ARRAY_SIZE(wm8741->supplies),
573                                       wm8741->supplies);
574         if (ret != 0) {
575                 dev_err(&spi->dev, "Failed to request supplies: %d\n", ret);
576                 return ret;
577         }
578 
579         wm8741->regmap = devm_regmap_init_spi(spi, &wm8741_regmap);
580         if (IS_ERR(wm8741->regmap)) {
581                 ret = PTR_ERR(wm8741->regmap);
582                 dev_err(&spi->dev, "Failed to init regmap: %d\n", ret);
583                 return ret;
584         }
585 
586         spi_set_drvdata(spi, wm8741);
587 
588         ret = snd_soc_register_codec(&spi->dev,
589                         &soc_codec_dev_wm8741, &wm8741_dai, 1);
590         return ret;
591 }
592 
593 static int wm8741_spi_remove(struct spi_device *spi)
594 {
595         snd_soc_unregister_codec(&spi->dev);
596         return 0;
597 }
598 
599 static struct spi_driver wm8741_spi_driver = {
600         .driver = {
601                 .name   = "wm8741",
602                 .owner  = THIS_MODULE,
603                 .of_match_table = wm8741_of_match,
604         },
605         .probe          = wm8741_spi_probe,
606         .remove         = wm8741_spi_remove,
607 };
608 #endif /* CONFIG_SPI_MASTER */
609 
610 static int __init wm8741_modinit(void)
611 {
612         int ret = 0;
613 
614 #if IS_ENABLED(CONFIG_I2C)
615         ret = i2c_add_driver(&wm8741_i2c_driver);
616         if (ret != 0)
617                 pr_err("Failed to register WM8741 I2C driver: %d\n", ret);
618 #endif
619 #if defined(CONFIG_SPI_MASTER)
620         ret = spi_register_driver(&wm8741_spi_driver);
621         if (ret != 0) {
622                 printk(KERN_ERR "Failed to register wm8741 SPI driver: %d\n",
623                        ret);
624         }
625 #endif
626 
627         return ret;
628 }
629 module_init(wm8741_modinit);
630 
631 static void __exit wm8741_exit(void)
632 {
633 #if defined(CONFIG_SPI_MASTER)
634         spi_unregister_driver(&wm8741_spi_driver);
635 #endif
636 #if IS_ENABLED(CONFIG_I2C)
637         i2c_del_driver(&wm8741_i2c_driver);
638 #endif
639 }
640 module_exit(wm8741_exit);
641 
642 MODULE_DESCRIPTION("ASoC WM8741 driver");
643 MODULE_AUTHOR("Ian Lartey <ian@opensource.wolfsonmicro.com>");
644 MODULE_LICENSE("GPL");
645 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us