Version:  2.0.40 2.2.26 2.4.37 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 4.6 4.7 4.8

Linux/sound/soc/codecs/pcm1681.c

  1 /*
  2  * PCM1681 ASoC codec driver
  3  *
  4  * Copyright (c) StreamUnlimited GmbH 2013
  5  *      Marek Belisko <marek.belisko@streamunlimited.com>
  6  *
  7  * This program is free software; you can redistribute it and/or
  8  * modify it under the terms of the GNU General Public License
  9  * as published by the Free Software Foundation; either version 2
 10  * of the License, or (at your option) any later version.
 11  *
 12  * This program is distributed in the hope that it will be useful,
 13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15  * GNU General Public License for more details.
 16  */
 17 
 18 #include <linux/module.h>
 19 #include <linux/slab.h>
 20 #include <linux/delay.h>
 21 #include <linux/gpio.h>
 22 #include <linux/i2c.h>
 23 #include <linux/regmap.h>
 24 #include <linux/of.h>
 25 #include <linux/of_device.h>
 26 #include <linux/of_gpio.h>
 27 #include <sound/pcm.h>
 28 #include <sound/pcm_params.h>
 29 #include <sound/soc.h>
 30 #include <sound/tlv.h>
 31 
 32 #define PCM1681_PCM_FORMATS (SNDRV_PCM_FMTBIT_S16_LE  |         \
 33                              SNDRV_PCM_FMTBIT_S24_LE)
 34 
 35 #define PCM1681_PCM_RATES   (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 | \
 36                              SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100  | \
 37                              SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200  | \
 38                              SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000)
 39 
 40 #define PCM1681_SOFT_MUTE_ALL           0xff
 41 #define PCM1681_DEEMPH_RATE_MASK        0x18
 42 #define PCM1681_DEEMPH_MASK             0x01
 43 
 44 #define PCM1681_ATT_CONTROL(X)  (X <= 6 ? X : X + 9) /* Attenuation level */
 45 #define PCM1681_SOFT_MUTE       0x07    /* Soft mute control register */
 46 #define PCM1681_DAC_CONTROL     0x08    /* DAC operation control */
 47 #define PCM1681_FMT_CONTROL     0x09    /* Audio interface data format */
 48 #define PCM1681_DEEMPH_CONTROL  0x0a    /* De-emphasis control */
 49 #define PCM1681_ZERO_DETECT_STATUS      0x0e    /* Zero detect status reg */
 50 
 51 static const struct reg_default pcm1681_reg_defaults[] = {
 52         { 0x01, 0xff },
 53         { 0x02, 0xff },
 54         { 0x03, 0xff },
 55         { 0x04, 0xff },
 56         { 0x05, 0xff },
 57         { 0x06, 0xff },
 58         { 0x07, 0x00 },
 59         { 0x08, 0x00 },
 60         { 0x09, 0x06 },
 61         { 0x0A, 0x00 },
 62         { 0x0B, 0xff },
 63         { 0x0C, 0x0f },
 64         { 0x0D, 0x00 },
 65         { 0x10, 0xff },
 66         { 0x11, 0xff },
 67         { 0x12, 0x00 },
 68         { 0x13, 0x00 },
 69 };
 70 
 71 static bool pcm1681_accessible_reg(struct device *dev, unsigned int reg)
 72 {
 73         return !((reg == 0x00) || (reg == 0x0f));
 74 }
 75 
 76 static bool pcm1681_writeable_reg(struct device *dev, unsigned int reg)
 77 {
 78         return pcm1681_accessible_reg(dev, reg) &&
 79                 (reg != PCM1681_ZERO_DETECT_STATUS);
 80 }
 81 
 82 struct pcm1681_private {
 83         struct regmap *regmap;
 84         unsigned int format;
 85         /* Current deemphasis status */
 86         unsigned int deemph;
 87         /* Current rate for deemphasis control */
 88         unsigned int rate;
 89 };
 90 
 91 static const int pcm1681_deemph[] = { 44100, 48000, 32000 };
 92 
 93 static int pcm1681_set_deemph(struct snd_soc_codec *codec)
 94 {
 95         struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec);
 96         int i = 0, val = -1, enable = 0;
 97 
 98         if (priv->deemph) {
 99                 for (i = 0; i < ARRAY_SIZE(pcm1681_deemph); i++) {
100                         if (pcm1681_deemph[i] == priv->rate) {
101                                 val = i;
102                                 break;
103                         }
104                 }
105         }
106 
107         if (val != -1) {
108                 regmap_update_bits(priv->regmap, PCM1681_DEEMPH_CONTROL,
109                                    PCM1681_DEEMPH_RATE_MASK, val << 3);
110                 enable = 1;
111         } else {
112                 enable = 0;
113         }
114 
115         /* enable/disable deemphasis functionality */
116         return regmap_update_bits(priv->regmap, PCM1681_DEEMPH_CONTROL,
117                                         PCM1681_DEEMPH_MASK, enable);
118 }
119 
120 static int pcm1681_get_deemph(struct snd_kcontrol *kcontrol,
121                               struct snd_ctl_elem_value *ucontrol)
122 {
123         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
124         struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec);
125 
126         ucontrol->value.integer.value[0] = priv->deemph;
127 
128         return 0;
129 }
130 
131 static int pcm1681_put_deemph(struct snd_kcontrol *kcontrol,
132                               struct snd_ctl_elem_value *ucontrol)
133 {
134         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
135         struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec);
136 
137         priv->deemph = ucontrol->value.integer.value[0];
138 
139         return pcm1681_set_deemph(codec);
140 }
141 
142 static int pcm1681_set_dai_fmt(struct snd_soc_dai *codec_dai,
143                               unsigned int format)
144 {
145         struct snd_soc_codec *codec = codec_dai->codec;
146         struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec);
147 
148         /* The PCM1681 can only be slave to all clocks */
149         if ((format & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS) {
150                 dev_err(codec->dev, "Invalid clocking mode\n");
151                 return -EINVAL;
152         }
153 
154         priv->format = format;
155 
156         return 0;
157 }
158 
159 static int pcm1681_digital_mute(struct snd_soc_dai *dai, int mute)
160 {
161         struct snd_soc_codec *codec = dai->codec;
162         struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec);
163         int val;
164 
165         if (mute)
166                 val = PCM1681_SOFT_MUTE_ALL;
167         else
168                 val = 0;
169 
170         return regmap_write(priv->regmap, PCM1681_SOFT_MUTE, val);
171 }
172 
173 static int pcm1681_hw_params(struct snd_pcm_substream *substream,
174                              struct snd_pcm_hw_params *params,
175                              struct snd_soc_dai *dai)
176 {
177         struct snd_soc_codec *codec = dai->codec;
178         struct pcm1681_private *priv = snd_soc_codec_get_drvdata(codec);
179         int val = 0, ret;
180 
181         priv->rate = params_rate(params);
182 
183         switch (priv->format & SND_SOC_DAIFMT_FORMAT_MASK) {
184         case SND_SOC_DAIFMT_RIGHT_J:
185                 switch (params_width(params)) {
186                 case 24:
187                         val = 0;
188                         break;
189                 case 16:
190                         val = 3;
191                         break;
192                 default:
193                         return -EINVAL;
194                 }
195                 break;
196         case SND_SOC_DAIFMT_I2S:
197                 val = 0x04;
198                 break;
199         case SND_SOC_DAIFMT_LEFT_J:
200                 val = 0x05;
201                 break;
202         default:
203                 dev_err(codec->dev, "Invalid DAI format\n");
204                 return -EINVAL;
205         }
206 
207         ret = regmap_update_bits(priv->regmap, PCM1681_FMT_CONTROL, 0x0f, val);
208         if (ret < 0)
209                 return ret;
210 
211         return pcm1681_set_deemph(codec);
212 }
213 
214 static const struct snd_soc_dai_ops pcm1681_dai_ops = {
215         .set_fmt        = pcm1681_set_dai_fmt,
216         .hw_params      = pcm1681_hw_params,
217         .digital_mute   = pcm1681_digital_mute,
218 };
219 
220 static const struct snd_soc_dapm_widget pcm1681_dapm_widgets[] = {
221 SND_SOC_DAPM_OUTPUT("VOUT1"),
222 SND_SOC_DAPM_OUTPUT("VOUT2"),
223 SND_SOC_DAPM_OUTPUT("VOUT3"),
224 SND_SOC_DAPM_OUTPUT("VOUT4"),
225 SND_SOC_DAPM_OUTPUT("VOUT5"),
226 SND_SOC_DAPM_OUTPUT("VOUT6"),
227 SND_SOC_DAPM_OUTPUT("VOUT7"),
228 SND_SOC_DAPM_OUTPUT("VOUT8"),
229 };
230 
231 static const struct snd_soc_dapm_route pcm1681_dapm_routes[] = {
232         { "VOUT1", NULL, "Playback" },
233         { "VOUT2", NULL, "Playback" },
234         { "VOUT3", NULL, "Playback" },
235         { "VOUT4", NULL, "Playback" },
236         { "VOUT5", NULL, "Playback" },
237         { "VOUT6", NULL, "Playback" },
238         { "VOUT7", NULL, "Playback" },
239         { "VOUT8", NULL, "Playback" },
240 };
241 
242 static const DECLARE_TLV_DB_SCALE(pcm1681_dac_tlv, -6350, 50, 1);
243 
244 static const struct snd_kcontrol_new pcm1681_controls[] = {
245         SOC_DOUBLE_R_TLV("Channel 1/2 Playback Volume",
246                         PCM1681_ATT_CONTROL(1), PCM1681_ATT_CONTROL(2), 0,
247                         0x7f, 0, pcm1681_dac_tlv),
248         SOC_DOUBLE_R_TLV("Channel 3/4 Playback Volume",
249                         PCM1681_ATT_CONTROL(3), PCM1681_ATT_CONTROL(4), 0,
250                         0x7f, 0, pcm1681_dac_tlv),
251         SOC_DOUBLE_R_TLV("Channel 5/6 Playback Volume",
252                         PCM1681_ATT_CONTROL(5), PCM1681_ATT_CONTROL(6), 0,
253                         0x7f, 0, pcm1681_dac_tlv),
254         SOC_DOUBLE_R_TLV("Channel 7/8 Playback Volume",
255                         PCM1681_ATT_CONTROL(7), PCM1681_ATT_CONTROL(8), 0,
256                         0x7f, 0, pcm1681_dac_tlv),
257         SOC_SINGLE_BOOL_EXT("De-emphasis Switch", 0,
258                             pcm1681_get_deemph, pcm1681_put_deemph),
259 };
260 
261 static struct snd_soc_dai_driver pcm1681_dai = {
262         .name = "pcm1681-hifi",
263         .playback = {
264                 .stream_name = "Playback",
265                 .channels_min = 2,
266                 .channels_max = 8,
267                 .rates = PCM1681_PCM_RATES,
268                 .formats = PCM1681_PCM_FORMATS,
269         },
270         .ops = &pcm1681_dai_ops,
271 };
272 
273 #ifdef CONFIG_OF
274 static const struct of_device_id pcm1681_dt_ids[] = {
275         { .compatible = "ti,pcm1681", },
276         { }
277 };
278 MODULE_DEVICE_TABLE(of, pcm1681_dt_ids);
279 #endif
280 
281 static const struct regmap_config pcm1681_regmap = {
282         .reg_bits               = 8,
283         .val_bits               = 8,
284         .max_register           = 0x13,
285         .reg_defaults           = pcm1681_reg_defaults,
286         .num_reg_defaults       = ARRAY_SIZE(pcm1681_reg_defaults),
287         .writeable_reg          = pcm1681_writeable_reg,
288         .readable_reg           = pcm1681_accessible_reg,
289 };
290 
291 static struct snd_soc_codec_driver soc_codec_dev_pcm1681 = {
292         .controls               = pcm1681_controls,
293         .num_controls           = ARRAY_SIZE(pcm1681_controls),
294         .dapm_widgets           = pcm1681_dapm_widgets,
295         .num_dapm_widgets       = ARRAY_SIZE(pcm1681_dapm_widgets),
296         .dapm_routes            = pcm1681_dapm_routes,
297         .num_dapm_routes        = ARRAY_SIZE(pcm1681_dapm_routes),
298 };
299 
300 static const struct i2c_device_id pcm1681_i2c_id[] = {
301         {"pcm1681", 0},
302         {}
303 };
304 MODULE_DEVICE_TABLE(i2c, pcm1681_i2c_id);
305 
306 static int pcm1681_i2c_probe(struct i2c_client *client,
307                               const struct i2c_device_id *id)
308 {
309         int ret;
310         struct pcm1681_private *priv;
311 
312         priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
313         if (!priv)
314                 return -ENOMEM;
315 
316         priv->regmap = devm_regmap_init_i2c(client, &pcm1681_regmap);
317         if (IS_ERR(priv->regmap)) {
318                 ret = PTR_ERR(priv->regmap);
319                 dev_err(&client->dev, "Failed to create regmap: %d\n", ret);
320                 return ret;
321         }
322 
323         i2c_set_clientdata(client, priv);
324 
325         return snd_soc_register_codec(&client->dev, &soc_codec_dev_pcm1681,
326                 &pcm1681_dai, 1);
327 }
328 
329 static int pcm1681_i2c_remove(struct i2c_client *client)
330 {
331         snd_soc_unregister_codec(&client->dev);
332         return 0;
333 }
334 
335 static struct i2c_driver pcm1681_i2c_driver = {
336         .driver = {
337                 .name   = "pcm1681",
338                 .of_match_table = of_match_ptr(pcm1681_dt_ids),
339         },
340         .id_table       = pcm1681_i2c_id,
341         .probe          = pcm1681_i2c_probe,
342         .remove         = pcm1681_i2c_remove,
343 };
344 
345 module_i2c_driver(pcm1681_i2c_driver);
346 
347 MODULE_DESCRIPTION("Texas Instruments PCM1681 ALSA SoC Codec Driver");
348 MODULE_AUTHOR("Marek Belisko <marek.belisko@streamunlimited.com>");
349 MODULE_LICENSE("GPL");
350 

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