~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/codecs/ak4641.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * ak4641.c  --  AK4641 ALSA Soc Audio driver
  3  *
  4  * Copyright (C) 2008 Harald Welte <laforge@gnufiish.org>
  5  * Copyright (C) 2011 Dmitry Artamonow <mad_soft@inbox.ru>
  6  *
  7  * Based on ak4535.c by Richard Purdie
  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/init.h>
 16 #include <linux/delay.h>
 17 #include <linux/gpio.h>
 18 #include <linux/pm.h>
 19 #include <linux/i2c.h>
 20 #include <linux/regmap.h>
 21 #include <linux/slab.h>
 22 #include <sound/core.h>
 23 #include <sound/pcm.h>
 24 #include <sound/pcm_params.h>
 25 #include <sound/soc.h>
 26 #include <sound/initval.h>
 27 #include <sound/tlv.h>
 28 #include <sound/ak4641.h>
 29 
 30 #include "ak4641.h"
 31 
 32 /* codec private data */
 33 struct ak4641_priv {
 34         struct regmap *regmap;
 35         unsigned int sysclk;
 36         int deemph;
 37         int playback_fs;
 38 };
 39 
 40 /*
 41  * ak4641 register cache
 42  */
 43 static const struct reg_default ak4641_reg_defaults[] = {
 44         {  0, 0x00 }, {  1, 0x80 }, {  2, 0x00 }, {  3, 0x80 },
 45         {  4, 0x02 }, {  5, 0x00 }, {  6, 0x11 }, {  7, 0x05 },
 46         {  8, 0x00 }, {  9, 0x00 }, { 10, 0x36 }, { 11, 0x10 },
 47         { 12, 0x00 }, { 13, 0x00 }, { 14, 0x57 }, { 15, 0x00 },
 48         { 16, 0x88 }, { 17, 0x88 }, { 18, 0x08 }, { 19, 0x08 }
 49 };
 50 
 51 static const int deemph_settings[] = {44100, 0, 48000, 32000};
 52 
 53 static int ak4641_set_deemph(struct snd_soc_codec *codec)
 54 {
 55         struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
 56         int i, best = 0;
 57 
 58         for (i = 0 ; i < ARRAY_SIZE(deemph_settings); i++) {
 59                 /* if deemphasis is on, select the nearest available rate */
 60                 if (ak4641->deemph && deemph_settings[i] != 0 &&
 61                     abs(deemph_settings[i] - ak4641->playback_fs) <
 62                     abs(deemph_settings[best] - ak4641->playback_fs))
 63                         best = i;
 64 
 65                 if (!ak4641->deemph && deemph_settings[i] == 0)
 66                         best = i;
 67         }
 68 
 69         dev_dbg(codec->dev, "Set deemphasis %d\n", best);
 70 
 71         return snd_soc_update_bits(codec, AK4641_DAC, 0x3, best);
 72 }
 73 
 74 static int ak4641_put_deemph(struct snd_kcontrol *kcontrol,
 75                                 struct snd_ctl_elem_value *ucontrol)
 76 {
 77         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
 78         struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
 79         int deemph = ucontrol->value.integer.value[0];
 80 
 81         if (deemph > 1)
 82                 return -EINVAL;
 83 
 84         ak4641->deemph = deemph;
 85 
 86         return ak4641_set_deemph(codec);
 87 }
 88 
 89 static int ak4641_get_deemph(struct snd_kcontrol *kcontrol,
 90                                 struct snd_ctl_elem_value *ucontrol)
 91 {
 92         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
 93         struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
 94 
 95         ucontrol->value.integer.value[0] = ak4641->deemph;
 96         return 0;
 97 };
 98 
 99 static const char *ak4641_mono_out[] = {"(L + R)/2", "Hi-Z"};
100 static const char *ak4641_hp_out[] = {"Stereo", "Mono"};
101 static const char *ak4641_mic_select[] = {"Internal", "External"};
102 static const char *ak4641_mic_or_dac[] = {"Microphone", "Voice DAC"};
103 
104 
105 static const DECLARE_TLV_DB_SCALE(mono_gain_tlv, -1700, 2300, 0);
106 static const DECLARE_TLV_DB_SCALE(mic_boost_tlv, 0, 2000, 0);
107 static const DECLARE_TLV_DB_SCALE(eq_tlv, -1050, 150, 0);
108 static const DECLARE_TLV_DB_SCALE(master_tlv, -12750, 50, 0);
109 static const DECLARE_TLV_DB_SCALE(mic_stereo_sidetone_tlv, -2700, 300, 0);
110 static const DECLARE_TLV_DB_SCALE(mic_mono_sidetone_tlv, -400, 400, 0);
111 static const DECLARE_TLV_DB_SCALE(capture_tlv, -800, 50, 0);
112 static const DECLARE_TLV_DB_SCALE(alc_tlv, -800, 50, 0);
113 static const DECLARE_TLV_DB_SCALE(aux_in_tlv, -2100, 300, 0);
114 
115 
116 static SOC_ENUM_SINGLE_DECL(ak4641_mono_out_enum,
117                             AK4641_SIG1, 6, ak4641_mono_out);
118 static SOC_ENUM_SINGLE_DECL(ak4641_hp_out_enum,
119                             AK4641_MODE2, 2, ak4641_hp_out);
120 static SOC_ENUM_SINGLE_DECL(ak4641_mic_select_enum,
121                             AK4641_MIC, 1, ak4641_mic_select);
122 static SOC_ENUM_SINGLE_DECL(ak4641_mic_or_dac_enum,
123                             AK4641_BTIF, 4, ak4641_mic_or_dac);
124 
125 static const struct snd_kcontrol_new ak4641_snd_controls[] = {
126         SOC_ENUM("Mono 1 Output", ak4641_mono_out_enum),
127         SOC_SINGLE_TLV("Mono 1 Gain Volume", AK4641_SIG1, 7, 1, 1,
128                                                         mono_gain_tlv),
129         SOC_ENUM("Headphone Output", ak4641_hp_out_enum),
130         SOC_SINGLE_BOOL_EXT("Playback Deemphasis Switch", 0,
131                                         ak4641_get_deemph, ak4641_put_deemph),
132 
133         SOC_SINGLE_TLV("Mic Boost Volume", AK4641_MIC, 0, 1, 0, mic_boost_tlv),
134 
135         SOC_SINGLE("ALC Operation Time", AK4641_TIMER, 0, 3, 0),
136         SOC_SINGLE("ALC Recovery Time", AK4641_TIMER, 2, 3, 0),
137         SOC_SINGLE("ALC ZC Time", AK4641_TIMER, 4, 3, 0),
138 
139         SOC_SINGLE("ALC 1 Switch", AK4641_ALC1, 5, 1, 0),
140 
141         SOC_SINGLE_TLV("ALC Volume", AK4641_ALC2, 0, 71, 0, alc_tlv),
142         SOC_SINGLE("Left Out Enable Switch", AK4641_SIG2, 1, 1, 0),
143         SOC_SINGLE("Right Out Enable Switch", AK4641_SIG2, 0, 1, 0),
144 
145         SOC_SINGLE_TLV("Capture Volume", AK4641_PGA, 0, 71, 0, capture_tlv),
146 
147         SOC_DOUBLE_R_TLV("Master Playback Volume", AK4641_LATT,
148                                 AK4641_RATT, 0, 255, 1, master_tlv),
149 
150         SOC_SINGLE_TLV("AUX In Volume", AK4641_VOL, 0, 15, 0, aux_in_tlv),
151 
152         SOC_SINGLE("Equalizer Switch", AK4641_DAC, 2, 1, 0),
153         SOC_SINGLE_TLV("EQ1 100 Hz Volume", AK4641_EQLO, 0, 15, 1, eq_tlv),
154         SOC_SINGLE_TLV("EQ2 250 Hz Volume", AK4641_EQLO, 4, 15, 1, eq_tlv),
155         SOC_SINGLE_TLV("EQ3 1 kHz Volume", AK4641_EQMID, 0, 15, 1, eq_tlv),
156         SOC_SINGLE_TLV("EQ4 3.5 kHz Volume", AK4641_EQMID, 4, 15, 1, eq_tlv),
157         SOC_SINGLE_TLV("EQ5 10 kHz Volume", AK4641_EQHI, 0, 15, 1, eq_tlv),
158 };
159 
160 /* Mono 1 Mixer */
161 static const struct snd_kcontrol_new ak4641_mono1_mixer_controls[] = {
162         SOC_DAPM_SINGLE_TLV("Mic Mono Sidetone Volume", AK4641_VOL, 7, 1, 0,
163                                                 mic_mono_sidetone_tlv),
164         SOC_DAPM_SINGLE("Mic Mono Sidetone Switch", AK4641_SIG1, 4, 1, 0),
165         SOC_DAPM_SINGLE("Mono Playback Switch", AK4641_SIG1, 5, 1, 0),
166 };
167 
168 /* Stereo Mixer */
169 static const struct snd_kcontrol_new ak4641_stereo_mixer_controls[] = {
170         SOC_DAPM_SINGLE_TLV("Mic Sidetone Volume", AK4641_VOL, 4, 7, 0,
171                                                 mic_stereo_sidetone_tlv),
172         SOC_DAPM_SINGLE("Mic Sidetone Switch", AK4641_SIG2, 4, 1, 0),
173         SOC_DAPM_SINGLE("Playback Switch", AK4641_SIG2, 7, 1, 0),
174         SOC_DAPM_SINGLE("Aux Bypass Switch", AK4641_SIG2, 5, 1, 0),
175 };
176 
177 /* Input Mixer */
178 static const struct snd_kcontrol_new ak4641_input_mixer_controls[] = {
179         SOC_DAPM_SINGLE("Mic Capture Switch", AK4641_MIC, 2, 1, 0),
180         SOC_DAPM_SINGLE("Aux Capture Switch", AK4641_MIC, 5, 1, 0),
181 };
182 
183 /* Mic mux */
184 static const struct snd_kcontrol_new ak4641_mic_mux_control =
185         SOC_DAPM_ENUM("Mic Select", ak4641_mic_select_enum);
186 
187 /* Input mux */
188 static const struct snd_kcontrol_new ak4641_input_mux_control =
189         SOC_DAPM_ENUM("Input Select", ak4641_mic_or_dac_enum);
190 
191 /* mono 2 switch */
192 static const struct snd_kcontrol_new ak4641_mono2_control =
193         SOC_DAPM_SINGLE("Switch", AK4641_SIG1, 0, 1, 0);
194 
195 /* ak4641 dapm widgets */
196 static const struct snd_soc_dapm_widget ak4641_dapm_widgets[] = {
197         SND_SOC_DAPM_MIXER("Stereo Mixer", SND_SOC_NOPM, 0, 0,
198                 &ak4641_stereo_mixer_controls[0],
199                 ARRAY_SIZE(ak4641_stereo_mixer_controls)),
200         SND_SOC_DAPM_MIXER("Mono1 Mixer", SND_SOC_NOPM, 0, 0,
201                 &ak4641_mono1_mixer_controls[0],
202                 ARRAY_SIZE(ak4641_mono1_mixer_controls)),
203         SND_SOC_DAPM_MIXER("Input Mixer", SND_SOC_NOPM, 0, 0,
204                 &ak4641_input_mixer_controls[0],
205                 ARRAY_SIZE(ak4641_input_mixer_controls)),
206         SND_SOC_DAPM_MUX("Mic Mux", SND_SOC_NOPM, 0, 0,
207                 &ak4641_mic_mux_control),
208         SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0,
209                 &ak4641_input_mux_control),
210         SND_SOC_DAPM_SWITCH("Mono 2 Enable", SND_SOC_NOPM, 0, 0,
211                 &ak4641_mono2_control),
212 
213         SND_SOC_DAPM_OUTPUT("LOUT"),
214         SND_SOC_DAPM_OUTPUT("ROUT"),
215         SND_SOC_DAPM_OUTPUT("MOUT1"),
216         SND_SOC_DAPM_OUTPUT("MOUT2"),
217         SND_SOC_DAPM_OUTPUT("MICOUT"),
218 
219         SND_SOC_DAPM_ADC("ADC", "HiFi Capture", AK4641_PM1, 0, 0),
220         SND_SOC_DAPM_PGA("Mic", AK4641_PM1, 1, 0, NULL, 0),
221         SND_SOC_DAPM_PGA("AUX In", AK4641_PM1, 2, 0, NULL, 0),
222         SND_SOC_DAPM_PGA("Mono Out", AK4641_PM1, 3, 0, NULL, 0),
223         SND_SOC_DAPM_PGA("Line Out", AK4641_PM1, 4, 0, NULL, 0),
224 
225         SND_SOC_DAPM_DAC("DAC", "HiFi Playback", AK4641_PM2, 0, 0),
226         SND_SOC_DAPM_PGA("Mono Out 2", AK4641_PM2, 3, 0, NULL, 0),
227 
228         SND_SOC_DAPM_ADC("Voice ADC", "Voice Capture", AK4641_BTIF, 0, 0),
229         SND_SOC_DAPM_DAC("Voice DAC", "Voice Playback", AK4641_BTIF, 1, 0),
230 
231         SND_SOC_DAPM_MICBIAS("Mic Int Bias", AK4641_MIC, 3, 0),
232         SND_SOC_DAPM_MICBIAS("Mic Ext Bias", AK4641_MIC, 4, 0),
233 
234         SND_SOC_DAPM_INPUT("MICIN"),
235         SND_SOC_DAPM_INPUT("MICEXT"),
236         SND_SOC_DAPM_INPUT("AUX"),
237         SND_SOC_DAPM_INPUT("AIN"),
238 };
239 
240 static const struct snd_soc_dapm_route ak4641_audio_map[] = {
241         /* Stereo Mixer */
242         {"Stereo Mixer", "Playback Switch", "DAC"},
243         {"Stereo Mixer", "Mic Sidetone Switch", "Input Mux"},
244         {"Stereo Mixer", "Aux Bypass Switch", "AUX In"},
245 
246         /* Mono 1 Mixer */
247         {"Mono1 Mixer", "Mic Mono Sidetone Switch", "Input Mux"},
248         {"Mono1 Mixer", "Mono Playback Switch", "DAC"},
249 
250         /* Mic */
251         {"Mic", NULL, "AIN"},
252         {"Mic Mux", "Internal", "Mic Int Bias"},
253         {"Mic Mux", "External", "Mic Ext Bias"},
254         {"Mic Int Bias", NULL, "MICIN"},
255         {"Mic Ext Bias", NULL, "MICEXT"},
256         {"MICOUT", NULL, "Mic Mux"},
257 
258         /* Input Mux */
259         {"Input Mux", "Microphone", "Mic"},
260         {"Input Mux", "Voice DAC", "Voice DAC"},
261 
262         /* Line Out */
263         {"LOUT", NULL, "Line Out"},
264         {"ROUT", NULL, "Line Out"},
265         {"Line Out", NULL, "Stereo Mixer"},
266 
267         /* Mono 1 Out */
268         {"MOUT1", NULL, "Mono Out"},
269         {"Mono Out", NULL, "Mono1 Mixer"},
270 
271         /* Mono 2 Out */
272         {"MOUT2", NULL, "Mono 2 Enable"},
273         {"Mono 2 Enable", "Switch", "Mono Out 2"},
274         {"Mono Out 2", NULL, "Stereo Mixer"},
275 
276         {"Voice ADC", NULL, "Mono 2 Enable"},
277 
278         /* Aux In */
279         {"AUX In", NULL, "AUX"},
280 
281         /* ADC */
282         {"ADC", NULL, "Input Mixer"},
283         {"Input Mixer", "Mic Capture Switch", "Mic"},
284         {"Input Mixer", "Aux Capture Switch", "AUX In"},
285 };
286 
287 static int ak4641_set_dai_sysclk(struct snd_soc_dai *codec_dai,
288         int clk_id, unsigned int freq, int dir)
289 {
290         struct snd_soc_codec *codec = codec_dai->codec;
291         struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
292 
293         ak4641->sysclk = freq;
294         return 0;
295 }
296 
297 static int ak4641_i2s_hw_params(struct snd_pcm_substream *substream,
298                                  struct snd_pcm_hw_params *params,
299                                  struct snd_soc_dai *dai)
300 {
301         struct snd_soc_codec *codec = dai->codec;
302         struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
303         int rate = params_rate(params), fs = 256;
304         u8 mode2;
305 
306         if (rate)
307                 fs = ak4641->sysclk / rate;
308         else
309                 return -EINVAL;
310 
311         /* set fs */
312         switch (fs) {
313         case 1024:
314                 mode2 = (0x2 << 5);
315                 break;
316         case 512:
317                 mode2 = (0x1 << 5);
318                 break;
319         case 256:
320                 mode2 = (0x0 << 5);
321                 break;
322         default:
323                 dev_err(codec->dev, "Error: unsupported fs=%d\n", fs);
324                 return -EINVAL;
325         }
326 
327         snd_soc_update_bits(codec, AK4641_MODE2, (0x3 << 5), mode2);
328 
329         /* Update de-emphasis filter for the new rate */
330         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
331                 ak4641->playback_fs = rate;
332                 ak4641_set_deemph(codec);
333         }
334 
335         return 0;
336 }
337 
338 static int ak4641_pcm_set_dai_fmt(struct snd_soc_dai *codec_dai,
339                                   unsigned int fmt)
340 {
341         struct snd_soc_codec *codec = codec_dai->codec;
342         u8 btif;
343         int ret;
344 
345         /* interface format */
346         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
347         case SND_SOC_DAIFMT_I2S:
348                 btif = (0x3 << 5);
349                 break;
350         case SND_SOC_DAIFMT_LEFT_J:
351                 btif = (0x2 << 5);
352                 break;
353         case SND_SOC_DAIFMT_DSP_A:      /* MSB after FRM */
354                 btif = (0x0 << 5);
355                 break;
356         case SND_SOC_DAIFMT_DSP_B:      /* MSB during FRM */
357                 btif = (0x1 << 5);
358                 break;
359         default:
360                 return -EINVAL;
361         }
362 
363         ret = snd_soc_update_bits(codec, AK4641_BTIF, (0x3 << 5), btif);
364         if (ret < 0)
365                 return ret;
366 
367         return 0;
368 }
369 
370 static int ak4641_i2s_set_dai_fmt(struct snd_soc_dai *codec_dai,
371                 unsigned int fmt)
372 {
373         struct snd_soc_codec *codec = codec_dai->codec;
374         u8 mode1 = 0;
375 
376         /* interface format */
377         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
378         case SND_SOC_DAIFMT_I2S:
379                 mode1 = 0x02;
380                 break;
381         case SND_SOC_DAIFMT_LEFT_J:
382                 mode1 = 0x01;
383                 break;
384         default:
385                 return -EINVAL;
386         }
387 
388         return snd_soc_write(codec, AK4641_MODE1, mode1);
389 }
390 
391 static int ak4641_mute(struct snd_soc_dai *dai, int mute)
392 {
393         struct snd_soc_codec *codec = dai->codec;
394 
395         return snd_soc_update_bits(codec, AK4641_DAC, 0x20, mute ? 0x20 : 0);
396 }
397 
398 static int ak4641_set_bias_level(struct snd_soc_codec *codec,
399         enum snd_soc_bias_level level)
400 {
401         struct ak4641_priv *ak4641 = snd_soc_codec_get_drvdata(codec);
402         struct ak4641_platform_data *pdata = codec->dev->platform_data;
403         int ret;
404 
405         switch (level) {
406         case SND_SOC_BIAS_ON:
407                 /* unmute */
408                 snd_soc_update_bits(codec, AK4641_DAC, 0x20, 0);
409                 break;
410         case SND_SOC_BIAS_PREPARE:
411                 /* mute */
412                 snd_soc_update_bits(codec, AK4641_DAC, 0x20, 0x20);
413                 break;
414         case SND_SOC_BIAS_STANDBY:
415                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
416                         if (pdata && gpio_is_valid(pdata->gpio_power))
417                                 gpio_set_value(pdata->gpio_power, 1);
418                         mdelay(1);
419                         if (pdata && gpio_is_valid(pdata->gpio_npdn))
420                                 gpio_set_value(pdata->gpio_npdn, 1);
421                         mdelay(1);
422 
423                         ret = regcache_sync(ak4641->regmap);
424                         if (ret) {
425                                 dev_err(codec->dev,
426                                         "Failed to sync cache: %d\n", ret);
427                                 return ret;
428                         }
429                 }
430                 snd_soc_update_bits(codec, AK4641_PM1, 0x80, 0x80);
431                 snd_soc_update_bits(codec, AK4641_PM2, 0x80, 0);
432                 break;
433         case SND_SOC_BIAS_OFF:
434                 snd_soc_update_bits(codec, AK4641_PM1, 0x80, 0);
435                 if (pdata && gpio_is_valid(pdata->gpio_npdn))
436                         gpio_set_value(pdata->gpio_npdn, 0);
437                 if (pdata && gpio_is_valid(pdata->gpio_power))
438                         gpio_set_value(pdata->gpio_power, 0);
439                 regcache_mark_dirty(ak4641->regmap);
440                 break;
441         }
442         codec->dapm.bias_level = level;
443         return 0;
444 }
445 
446 #define AK4641_RATES    (SNDRV_PCM_RATE_8000_48000)
447 #define AK4641_RATES_BT (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
448                          SNDRV_PCM_RATE_16000)
449 #define AK4641_FORMATS  (SNDRV_PCM_FMTBIT_S16_LE)
450 
451 static const struct snd_soc_dai_ops ak4641_i2s_dai_ops = {
452         .hw_params    = ak4641_i2s_hw_params,
453         .set_fmt      = ak4641_i2s_set_dai_fmt,
454         .digital_mute = ak4641_mute,
455         .set_sysclk   = ak4641_set_dai_sysclk,
456 };
457 
458 static const struct snd_soc_dai_ops ak4641_pcm_dai_ops = {
459         .hw_params    = NULL, /* rates are controlled by BT chip */
460         .set_fmt      = ak4641_pcm_set_dai_fmt,
461         .digital_mute = ak4641_mute,
462         .set_sysclk   = ak4641_set_dai_sysclk,
463 };
464 
465 static struct snd_soc_dai_driver ak4641_dai[] = {
466 {
467         .name = "ak4641-hifi",
468         .id = 1,
469         .playback = {
470                 .stream_name = "HiFi Playback",
471                 .channels_min = 1,
472                 .channels_max = 2,
473                 .rates = AK4641_RATES,
474                 .formats = AK4641_FORMATS,
475         },
476         .capture = {
477                 .stream_name = "HiFi Capture",
478                 .channels_min = 1,
479                 .channels_max = 2,
480                 .rates = AK4641_RATES,
481                 .formats = AK4641_FORMATS,
482         },
483         .ops = &ak4641_i2s_dai_ops,
484         .symmetric_rates = 1,
485 },
486 {
487         .name = "ak4641-voice",
488         .id = 1,
489         .playback = {
490                 .stream_name = "Voice Playback",
491                 .channels_min = 1,
492                 .channels_max = 1,
493                 .rates = AK4641_RATES_BT,
494                 .formats = AK4641_FORMATS,
495         },
496         .capture = {
497                 .stream_name = "Voice Capture",
498                 .channels_min = 1,
499                 .channels_max = 1,
500                 .rates = AK4641_RATES_BT,
501                 .formats = AK4641_FORMATS,
502         },
503         .ops = &ak4641_pcm_dai_ops,
504         .symmetric_rates = 1,
505 },
506 };
507 
508 static struct snd_soc_codec_driver soc_codec_dev_ak4641 = {
509         .controls               = ak4641_snd_controls,
510         .num_controls           = ARRAY_SIZE(ak4641_snd_controls),
511         .dapm_widgets           = ak4641_dapm_widgets,
512         .num_dapm_widgets       = ARRAY_SIZE(ak4641_dapm_widgets),
513         .dapm_routes            = ak4641_audio_map,
514         .num_dapm_routes        = ARRAY_SIZE(ak4641_audio_map),
515         .set_bias_level         = ak4641_set_bias_level,
516         .suspend_bias_off       = true,
517 };
518 
519 static const struct regmap_config ak4641_regmap = {
520         .reg_bits = 8,
521         .val_bits = 8,
522 
523         .max_register = AK4641_BTIF,
524         .reg_defaults = ak4641_reg_defaults,
525         .num_reg_defaults = ARRAY_SIZE(ak4641_reg_defaults),
526         .cache_type = REGCACHE_RBTREE,
527 };
528 
529 static int ak4641_i2c_probe(struct i2c_client *i2c,
530                             const struct i2c_device_id *id)
531 {
532         struct ak4641_platform_data *pdata = i2c->dev.platform_data;
533         struct ak4641_priv *ak4641;
534         int ret;
535 
536         ak4641 = devm_kzalloc(&i2c->dev, sizeof(struct ak4641_priv),
537                               GFP_KERNEL);
538         if (!ak4641)
539                 return -ENOMEM;
540 
541         ak4641->regmap = devm_regmap_init_i2c(i2c, &ak4641_regmap);
542         if (IS_ERR(ak4641->regmap))
543                 return PTR_ERR(ak4641->regmap);
544 
545         if (pdata) {
546                 if (gpio_is_valid(pdata->gpio_power)) {
547                         ret = gpio_request_one(pdata->gpio_power,
548                                         GPIOF_OUT_INIT_LOW, "ak4641 power");
549                         if (ret)
550                                 goto err_out;
551                 }
552                 if (gpio_is_valid(pdata->gpio_npdn)) {
553                         ret = gpio_request_one(pdata->gpio_npdn,
554                                         GPIOF_OUT_INIT_LOW, "ak4641 npdn");
555                         if (ret)
556                                 goto err_gpio;
557 
558                         udelay(1); /* > 150 ns */
559                         gpio_set_value(pdata->gpio_npdn, 1);
560                 }
561         }
562 
563         i2c_set_clientdata(i2c, ak4641);
564 
565         ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_ak4641,
566                                 ak4641_dai, ARRAY_SIZE(ak4641_dai));
567         if (ret != 0)
568                 goto err_gpio2;
569 
570         return 0;
571 
572 err_gpio2:
573         if (pdata) {
574                 if (gpio_is_valid(pdata->gpio_power))
575                         gpio_set_value(pdata->gpio_power, 0);
576                 if (gpio_is_valid(pdata->gpio_npdn))
577                         gpio_free(pdata->gpio_npdn);
578         }
579 err_gpio:
580         if (pdata && gpio_is_valid(pdata->gpio_power))
581                 gpio_free(pdata->gpio_power);
582 err_out:
583         return ret;
584 }
585 
586 static int ak4641_i2c_remove(struct i2c_client *i2c)
587 {
588         struct ak4641_platform_data *pdata = i2c->dev.platform_data;
589 
590         snd_soc_unregister_codec(&i2c->dev);
591 
592         if (pdata) {
593                 if (gpio_is_valid(pdata->gpio_power)) {
594                         gpio_set_value(pdata->gpio_power, 0);
595                         gpio_free(pdata->gpio_power);
596                 }
597                 if (gpio_is_valid(pdata->gpio_npdn))
598                         gpio_free(pdata->gpio_npdn);
599         }
600 
601         return 0;
602 }
603 
604 static const struct i2c_device_id ak4641_i2c_id[] = {
605         { "ak4641", 0 },
606         { }
607 };
608 MODULE_DEVICE_TABLE(i2c, ak4641_i2c_id);
609 
610 static struct i2c_driver ak4641_i2c_driver = {
611         .driver = {
612                 .name = "ak4641",
613                 .owner = THIS_MODULE,
614         },
615         .probe =    ak4641_i2c_probe,
616         .remove =   ak4641_i2c_remove,
617         .id_table = ak4641_i2c_id,
618 };
619 
620 module_i2c_driver(ak4641_i2c_driver);
621 
622 MODULE_DESCRIPTION("SoC AK4641 driver");
623 MODULE_AUTHOR("Harald Welte <laforge@gnufiish.org>");
624 MODULE_LICENSE("GPL");
625 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp