Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5

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

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