Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 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

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         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 unsigned int rates_11289[] = {
126         44100, 88235,
127 };
128 
129 static struct snd_pcm_hw_constraint_list constraints_11289 = {
130         .count  = ARRAY_SIZE(rates_11289),
131         .list   = rates_11289,
132 };
133 
134 static unsigned int rates_12288[] = {
135         32000, 48000, 96000,
136 };
137 
138 static struct snd_pcm_hw_constraint_list constraints_12288 = {
139         .count  = ARRAY_SIZE(rates_12288),
140         .list   = rates_12288,
141 };
142 
143 static unsigned int rates_16384[] = {
144         32000,
145 };
146 
147 static struct snd_pcm_hw_constraint_list constraints_16384 = {
148         .count  = ARRAY_SIZE(rates_16384),
149         .list   = rates_16384,
150 };
151 
152 static unsigned int rates_16934[] = {
153         44100, 88235,
154 };
155 
156 static struct snd_pcm_hw_constraint_list constraints_16934 = {
157         .count  = ARRAY_SIZE(rates_16934),
158         .list   = rates_16934,
159 };
160 
161 static unsigned int rates_18432[] = {
162         48000, 96000,
163 };
164 
165 static struct snd_pcm_hw_constraint_list constraints_18432 = {
166         .count  = ARRAY_SIZE(rates_18432),
167         .list   = rates_18432,
168 };
169 
170 static unsigned int rates_22579[] = {
171         44100, 88235, 1764000
172 };
173 
174 static struct snd_pcm_hw_constraint_list constraints_22579 = {
175         .count  = ARRAY_SIZE(rates_22579),
176         .list   = rates_22579,
177 };
178 
179 static unsigned int rates_24576[] = {
180         32000, 48000, 96000, 192000
181 };
182 
183 static struct snd_pcm_hw_constraint_list constraints_24576 = {
184         .count  = ARRAY_SIZE(rates_24576),
185         .list   = rates_24576,
186 };
187 
188 static unsigned int rates_36864[] = {
189         48000, 96000, 19200
190 };
191 
192 static 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 = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP);
433         if (ret != 0) {
434                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
435                 goto err_enable;
436         }
437 
438         ret = wm8741_reset(codec);
439         if (ret < 0) {
440                 dev_err(codec->dev, "Failed to issue reset\n");
441                 goto err_enable;
442         }
443 
444         /* Change some default settings - latch VU */
445         snd_soc_update_bits(codec, WM8741_DACLLSB_ATTENUATION,
446                             WM8741_UPDATELL, WM8741_UPDATELL);
447         snd_soc_update_bits(codec, WM8741_DACLMSB_ATTENUATION,
448                             WM8741_UPDATELM, WM8741_UPDATELM);
449         snd_soc_update_bits(codec, WM8741_DACRLSB_ATTENUATION,
450                             WM8741_UPDATERL, WM8741_UPDATERL);
451         snd_soc_update_bits(codec, WM8741_DACRMSB_ATTENUATION,
452                             WM8741_UPDATERM, WM8741_UPDATERM);
453 
454         dev_dbg(codec->dev, "Successful registration\n");
455         return ret;
456 
457 err_enable:
458         regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
459 err_get:
460         return ret;
461 }
462 
463 static int wm8741_remove(struct snd_soc_codec *codec)
464 {
465         struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
466 
467         regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
468 
469         return 0;
470 }
471 
472 static struct snd_soc_codec_driver soc_codec_dev_wm8741 = {
473         .probe =        wm8741_probe,
474         .remove =       wm8741_remove,
475         .resume =       wm8741_resume,
476 
477         .controls = wm8741_snd_controls,
478         .num_controls = ARRAY_SIZE(wm8741_snd_controls),
479         .dapm_widgets = wm8741_dapm_widgets,
480         .num_dapm_widgets = ARRAY_SIZE(wm8741_dapm_widgets),
481         .dapm_routes = wm8741_dapm_routes,
482         .num_dapm_routes = ARRAY_SIZE(wm8741_dapm_routes),
483 };
484 
485 static const struct of_device_id wm8741_of_match[] = {
486         { .compatible = "wlf,wm8741", },
487         { }
488 };
489 MODULE_DEVICE_TABLE(of, wm8741_of_match);
490 
491 static const struct regmap_config wm8741_regmap = {
492         .reg_bits = 7,
493         .val_bits = 9,
494         .max_register = WM8741_MAX_REGISTER,
495 
496         .reg_defaults = wm8741_reg_defaults,
497         .num_reg_defaults = ARRAY_SIZE(wm8741_reg_defaults),
498         .cache_type = REGCACHE_RBTREE,
499 
500         .readable_reg = wm8741_readable,
501 };
502 
503 #if IS_ENABLED(CONFIG_I2C)
504 static int wm8741_i2c_probe(struct i2c_client *i2c,
505                             const struct i2c_device_id *id)
506 {
507         struct wm8741_priv *wm8741;
508         int ret, i;
509 
510         wm8741 = devm_kzalloc(&i2c->dev, sizeof(struct wm8741_priv),
511                               GFP_KERNEL);
512         if (wm8741 == NULL)
513                 return -ENOMEM;
514 
515         for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
516                 wm8741->supplies[i].supply = wm8741_supply_names[i];
517 
518         ret = devm_regulator_bulk_get(&i2c->dev, ARRAY_SIZE(wm8741->supplies),
519                                       wm8741->supplies);
520         if (ret != 0) {
521                 dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret);
522                 return ret;
523         }
524 
525         wm8741->regmap = devm_regmap_init_i2c(i2c, &wm8741_regmap);
526         if (IS_ERR(wm8741->regmap)) {
527                 ret = PTR_ERR(wm8741->regmap);
528                 dev_err(&i2c->dev, "Failed to init regmap: %d\n", ret);
529                 return ret;
530         }
531 
532         i2c_set_clientdata(i2c, wm8741);
533 
534         ret = snd_soc_register_codec(&i2c->dev,
535                                      &soc_codec_dev_wm8741, &wm8741_dai, 1);
536 
537         return ret;
538 }
539 
540 static int wm8741_i2c_remove(struct i2c_client *client)
541 {
542         snd_soc_unregister_codec(&client->dev);
543         return 0;
544 }
545 
546 static const struct i2c_device_id wm8741_i2c_id[] = {
547         { "wm8741", 0 },
548         { }
549 };
550 MODULE_DEVICE_TABLE(i2c, wm8741_i2c_id);
551 
552 static struct i2c_driver wm8741_i2c_driver = {
553         .driver = {
554                 .name = "wm8741",
555                 .owner = THIS_MODULE,
556                 .of_match_table = wm8741_of_match,
557         },
558         .probe =    wm8741_i2c_probe,
559         .remove =   wm8741_i2c_remove,
560         .id_table = wm8741_i2c_id,
561 };
562 #endif
563 
564 #if defined(CONFIG_SPI_MASTER)
565 static int wm8741_spi_probe(struct spi_device *spi)
566 {
567         struct wm8741_priv *wm8741;
568         int ret, i;
569 
570         wm8741 = devm_kzalloc(&spi->dev, sizeof(struct wm8741_priv),
571                              GFP_KERNEL);
572         if (wm8741 == NULL)
573                 return -ENOMEM;
574 
575         for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
576                 wm8741->supplies[i].supply = wm8741_supply_names[i];
577 
578         ret = devm_regulator_bulk_get(&spi->dev, ARRAY_SIZE(wm8741->supplies),
579                                       wm8741->supplies);
580         if (ret != 0) {
581                 dev_err(&spi->dev, "Failed to request supplies: %d\n", ret);
582                 return ret;
583         }
584 
585         wm8741->regmap = devm_regmap_init_spi(spi, &wm8741_regmap);
586         if (IS_ERR(wm8741->regmap)) {
587                 ret = PTR_ERR(wm8741->regmap);
588                 dev_err(&spi->dev, "Failed to init regmap: %d\n", ret);
589                 return ret;
590         }
591 
592         spi_set_drvdata(spi, wm8741);
593 
594         ret = snd_soc_register_codec(&spi->dev,
595                         &soc_codec_dev_wm8741, &wm8741_dai, 1);
596         return ret;
597 }
598 
599 static int wm8741_spi_remove(struct spi_device *spi)
600 {
601         snd_soc_unregister_codec(&spi->dev);
602         return 0;
603 }
604 
605 static struct spi_driver wm8741_spi_driver = {
606         .driver = {
607                 .name   = "wm8741",
608                 .owner  = THIS_MODULE,
609                 .of_match_table = wm8741_of_match,
610         },
611         .probe          = wm8741_spi_probe,
612         .remove         = wm8741_spi_remove,
613 };
614 #endif /* CONFIG_SPI_MASTER */
615 
616 static int __init wm8741_modinit(void)
617 {
618         int ret = 0;
619 
620 #if IS_ENABLED(CONFIG_I2C)
621         ret = i2c_add_driver(&wm8741_i2c_driver);
622         if (ret != 0)
623                 pr_err("Failed to register WM8741 I2C driver: %d\n", ret);
624 #endif
625 #if defined(CONFIG_SPI_MASTER)
626         ret = spi_register_driver(&wm8741_spi_driver);
627         if (ret != 0) {
628                 printk(KERN_ERR "Failed to register wm8741 SPI driver: %d\n",
629                        ret);
630         }
631 #endif
632 
633         return ret;
634 }
635 module_init(wm8741_modinit);
636 
637 static void __exit wm8741_exit(void)
638 {
639 #if defined(CONFIG_SPI_MASTER)
640         spi_unregister_driver(&wm8741_spi_driver);
641 #endif
642 #if IS_ENABLED(CONFIG_I2C)
643         i2c_del_driver(&wm8741_i2c_driver);
644 #endif
645 }
646 module_exit(wm8741_exit);
647 
648 MODULE_DESCRIPTION("ASoC WM8741 driver");
649 MODULE_AUTHOR("Ian Lartey <ian@opensource.wolfsonmicro.com>");
650 MODULE_LICENSE("GPL");
651 

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