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

TOMOYO Linux Cross Reference
Linux/sound/soc/atmel/tse850-pcm5142.c

Version: ~ [ linux-5.10-rc6 ] ~ [ linux-5.9.12 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.81 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.161 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.210 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.247 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.247 ] ~ [ 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 // SPDX-License-Identifier: GPL-2.0
  2 //
  3 // TSE-850 audio - ASoC driver for the Axentia TSE-850 with a PCM5142 codec
  4 //
  5 // Copyright (C) 2016 Axentia Technologies AB
  6 //
  7 // Author: Peter Rosin <peda@axentia.se>
  8 //
  9 //               loop1 relays
 10 //   IN1 +---o  +------------+  o---+ OUT1
 11 //            \                /
 12 //             +              +
 13 //             |   /          |
 14 //             +--o  +--.     |
 15 //             |  add   |     |
 16 //             |        V     |
 17 //             |      .---.   |
 18 //   DAC +----------->|Sum|---+
 19 //             |      '---'   |
 20 //             |              |
 21 //             +              +
 22 //
 23 //   IN2 +---o--+------------+--o---+ OUT2
 24 //               loop2 relays
 25 //
 26 // The 'loop1' gpio pin controlls two relays, which are either in loop
 27 // position, meaning that input and output are directly connected, or
 28 // they are in mixer position, meaning that the signal is passed through
 29 // the 'Sum' mixer. Similarly for 'loop2'.
 30 //
 31 // In the above, the 'loop1' relays are inactive, thus feeding IN1 to the
 32 // mixer (if 'add' is active) and feeding the mixer output to OUT1. The
 33 // 'loop2' relays are active, short-cutting the TSE-850 from channel 2.
 34 // IN1, IN2, OUT1 and OUT2 are TSE-850 connectors and DAC is the PCB name
 35 // of the (filtered) output from the PCM5142 codec.
 36 
 37 #include <linux/clk.h>
 38 #include <linux/gpio.h>
 39 #include <linux/module.h>
 40 #include <linux/of.h>
 41 #include <linux/of_device.h>
 42 #include <linux/of_gpio.h>
 43 #include <linux/regulator/consumer.h>
 44 
 45 #include <sound/soc.h>
 46 #include <sound/pcm_params.h>
 47 
 48 struct tse850_priv {
 49         struct gpio_desc *add;
 50         struct gpio_desc *loop1;
 51         struct gpio_desc *loop2;
 52 
 53         struct regulator *ana;
 54 
 55         int add_cache;
 56         int loop1_cache;
 57         int loop2_cache;
 58 };
 59 
 60 static int tse850_get_mux1(struct snd_kcontrol *kctrl,
 61                            struct snd_ctl_elem_value *ucontrol)
 62 {
 63         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
 64         struct snd_soc_card *card = dapm->card;
 65         struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
 66 
 67         ucontrol->value.enumerated.item[0] = tse850->loop1_cache;
 68 
 69         return 0;
 70 }
 71 
 72 static int tse850_put_mux1(struct snd_kcontrol *kctrl,
 73                            struct snd_ctl_elem_value *ucontrol)
 74 {
 75         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
 76         struct snd_soc_card *card = dapm->card;
 77         struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
 78         struct soc_enum *e = (struct soc_enum *)kctrl->private_value;
 79         unsigned int val = ucontrol->value.enumerated.item[0];
 80 
 81         if (val >= e->items)
 82                 return -EINVAL;
 83 
 84         gpiod_set_value_cansleep(tse850->loop1, val);
 85         tse850->loop1_cache = val;
 86 
 87         return snd_soc_dapm_put_enum_double(kctrl, ucontrol);
 88 }
 89 
 90 static int tse850_get_mux2(struct snd_kcontrol *kctrl,
 91                            struct snd_ctl_elem_value *ucontrol)
 92 {
 93         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
 94         struct snd_soc_card *card = dapm->card;
 95         struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
 96 
 97         ucontrol->value.enumerated.item[0] = tse850->loop2_cache;
 98 
 99         return 0;
100 }
101 
102 static int tse850_put_mux2(struct snd_kcontrol *kctrl,
103                            struct snd_ctl_elem_value *ucontrol)
104 {
105         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
106         struct snd_soc_card *card = dapm->card;
107         struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
108         struct soc_enum *e = (struct soc_enum *)kctrl->private_value;
109         unsigned int val = ucontrol->value.enumerated.item[0];
110 
111         if (val >= e->items)
112                 return -EINVAL;
113 
114         gpiod_set_value_cansleep(tse850->loop2, val);
115         tse850->loop2_cache = val;
116 
117         return snd_soc_dapm_put_enum_double(kctrl, ucontrol);
118 }
119 
120 static int tse850_get_mix(struct snd_kcontrol *kctrl,
121                           struct snd_ctl_elem_value *ucontrol)
122 {
123         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
124         struct snd_soc_card *card = dapm->card;
125         struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
126 
127         ucontrol->value.enumerated.item[0] = tse850->add_cache;
128 
129         return 0;
130 }
131 
132 static int tse850_put_mix(struct snd_kcontrol *kctrl,
133                           struct snd_ctl_elem_value *ucontrol)
134 {
135         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
136         struct snd_soc_card *card = dapm->card;
137         struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
138         int connect = !!ucontrol->value.integer.value[0];
139 
140         if (tse850->add_cache == connect)
141                 return 0;
142 
143         /*
144          * Hmmm, this gpiod_set_value_cansleep call should probably happen
145          * inside snd_soc_dapm_mixer_update_power in the loop.
146          */
147         gpiod_set_value_cansleep(tse850->add, connect);
148         tse850->add_cache = connect;
149 
150         snd_soc_dapm_mixer_update_power(dapm, kctrl, connect, NULL);
151         return 1;
152 }
153 
154 static int tse850_get_ana(struct snd_kcontrol *kctrl,
155                           struct snd_ctl_elem_value *ucontrol)
156 {
157         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
158         struct snd_soc_card *card = dapm->card;
159         struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
160         int ret;
161 
162         ret = regulator_get_voltage(tse850->ana);
163         if (ret < 0)
164                 return ret;
165 
166         /*
167          * Map regulator output values like so:
168          *      -11.5V to "Low" (enum 0)
169          * 11.5V-12.5V to "12V" (enum 1)
170          * 12.5V-13.5V to "13V" (enum 2)
171          *     ...
172          * 18.5V-19.5V to "19V" (enum 8)
173          * 19.5V-      to "20V" (enum 9)
174          */
175         if (ret < 11000000)
176                 ret = 11000000;
177         else if (ret > 20000000)
178                 ret = 20000000;
179         ret -= 11000000;
180         ret = (ret + 500000) / 1000000;
181 
182         ucontrol->value.enumerated.item[0] = ret;
183 
184         return 0;
185 }
186 
187 static int tse850_put_ana(struct snd_kcontrol *kctrl,
188                           struct snd_ctl_elem_value *ucontrol)
189 {
190         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl);
191         struct snd_soc_card *card = dapm->card;
192         struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
193         struct soc_enum *e = (struct soc_enum *)kctrl->private_value;
194         unsigned int uV = ucontrol->value.enumerated.item[0];
195         int ret;
196 
197         if (uV >= e->items)
198                 return -EINVAL;
199 
200         /*
201          * Map enum zero (Low) to 2 volts on the regulator, do this since
202          * the ana regulator is supplied by the system 12V voltage and
203          * requesting anything below the system voltage causes the system
204          * voltage to be passed through the regulator. Also, the ana
205          * regulator induces noise when requesting voltages near the
206          * system voltage. So, by mapping Low to 2V, that noise is
207          * eliminated when all that is needed is 12V (the system voltage).
208          */
209         if (uV)
210                 uV = 11000000 + (1000000 * uV);
211         else
212                 uV = 2000000;
213 
214         ret = regulator_set_voltage(tse850->ana, uV, uV);
215         if (ret < 0)
216                 return ret;
217 
218         return snd_soc_dapm_put_enum_double(kctrl, ucontrol);
219 }
220 
221 static const char * const mux_text[] = { "Mixer", "Loop" };
222 
223 static const struct soc_enum mux_enum =
224         SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, ARRAY_SIZE(mux_text), mux_text);
225 
226 static const struct snd_kcontrol_new mux1 =
227         SOC_DAPM_ENUM_EXT("MUX1", mux_enum, tse850_get_mux1, tse850_put_mux1);
228 
229 static const struct snd_kcontrol_new mux2 =
230         SOC_DAPM_ENUM_EXT("MUX2", mux_enum, tse850_get_mux2, tse850_put_mux2);
231 
232 #define TSE850_DAPM_SINGLE_EXT(xname, reg, shift, max, invert, xget, xput) \
233 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
234         .info = snd_soc_info_volsw, \
235         .get = xget, \
236         .put = xput, \
237         .private_value = SOC_SINGLE_VALUE(reg, shift, max, invert, 0) }
238 
239 static const struct snd_kcontrol_new mix[] = {
240         TSE850_DAPM_SINGLE_EXT("IN Switch", SND_SOC_NOPM, 0, 1, 0,
241                                tse850_get_mix, tse850_put_mix),
242 };
243 
244 static const char * const ana_text[] = {
245         "Low", "12V", "13V", "14V", "15V", "16V", "17V", "18V", "19V", "20V"
246 };
247 
248 static const struct soc_enum ana_enum =
249         SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, ARRAY_SIZE(ana_text), ana_text);
250 
251 static const struct snd_kcontrol_new out =
252         SOC_DAPM_ENUM_EXT("ANA", ana_enum, tse850_get_ana, tse850_put_ana);
253 
254 static const struct snd_soc_dapm_widget tse850_dapm_widgets[] = {
255         SND_SOC_DAPM_LINE("OUT1", NULL),
256         SND_SOC_DAPM_LINE("OUT2", NULL),
257         SND_SOC_DAPM_LINE("IN1", NULL),
258         SND_SOC_DAPM_LINE("IN2", NULL),
259         SND_SOC_DAPM_INPUT("DAC"),
260         SND_SOC_DAPM_AIF_IN("AIFINL", "Playback", 0, SND_SOC_NOPM, 0, 0),
261         SND_SOC_DAPM_AIF_IN("AIFINR", "Playback", 1, SND_SOC_NOPM, 0, 0),
262         SOC_MIXER_ARRAY("MIX", SND_SOC_NOPM, 0, 0, mix),
263         SND_SOC_DAPM_MUX("MUX1", SND_SOC_NOPM, 0, 0, &mux1),
264         SND_SOC_DAPM_MUX("MUX2", SND_SOC_NOPM, 0, 0, &mux2),
265         SND_SOC_DAPM_OUT_DRV("OUT", SND_SOC_NOPM, 0, 0, &out, 1),
266 };
267 
268 /*
269  * These connections are not entirely correct, since both IN1 and IN2
270  * are always fed to MIX (if the "IN switch" is set so), i.e. without
271  * regard to the loop1 and loop2 relays that according to this only
272  * control MUX1 and MUX2 but in fact also control how the input signals
273  * are routed.
274  * But, 1) I don't know how to do it right, and 2) it doesn't seem to
275  * matter in practice since nothing is powered in those sections anyway.
276  */
277 static const struct snd_soc_dapm_route tse850_intercon[] = {
278         { "OUT1", NULL, "MUX1" },
279         { "OUT2", NULL, "MUX2" },
280 
281         { "MUX1", "Loop",  "IN1" },
282         { "MUX1", "Mixer", "OUT" },
283 
284         { "MUX2", "Loop",  "IN2" },
285         { "MUX2", "Mixer", "OUT" },
286 
287         { "OUT", NULL, "MIX" },
288 
289         { "MIX", NULL, "DAC" },
290         { "MIX", "IN Switch", "IN1" },
291         { "MIX", "IN Switch", "IN2" },
292 
293         /* connect board input to the codec left channel output pin */
294         { "DAC", NULL, "OUTL" },
295 };
296 
297 SND_SOC_DAILINK_DEFS(pcm,
298         DAILINK_COMP_ARRAY(COMP_EMPTY()),
299         DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "pcm512x-hifi")),
300         DAILINK_COMP_ARRAY(COMP_EMPTY()));
301 
302 static struct snd_soc_dai_link tse850_dailink = {
303         .name = "TSE-850",
304         .stream_name = "TSE-850-PCM",
305         .dai_fmt = SND_SOC_DAIFMT_I2S
306                  | SND_SOC_DAIFMT_NB_NF
307                  | SND_SOC_DAIFMT_CBM_CFS,
308         SND_SOC_DAILINK_REG(pcm),
309 };
310 
311 static struct snd_soc_card tse850_card = {
312         .name = "TSE-850-ASoC",
313         .owner = THIS_MODULE,
314         .dai_link = &tse850_dailink,
315         .num_links = 1,
316         .dapm_widgets = tse850_dapm_widgets,
317         .num_dapm_widgets = ARRAY_SIZE(tse850_dapm_widgets),
318         .dapm_routes = tse850_intercon,
319         .num_dapm_routes = ARRAY_SIZE(tse850_intercon),
320         .fully_routed = true,
321 };
322 
323 static int tse850_dt_init(struct platform_device *pdev)
324 {
325         struct device_node *np = pdev->dev.of_node;
326         struct device_node *codec_np, *cpu_np;
327         struct snd_soc_dai_link *dailink = &tse850_dailink;
328 
329         if (!np) {
330                 dev_err(&pdev->dev, "only device tree supported\n");
331                 return -EINVAL;
332         }
333 
334         cpu_np = of_parse_phandle(np, "axentia,cpu-dai", 0);
335         if (!cpu_np) {
336                 dev_err(&pdev->dev, "failed to get cpu dai\n");
337                 return -EINVAL;
338         }
339         dailink->cpus->of_node = cpu_np;
340         dailink->platforms->of_node = cpu_np;
341         of_node_put(cpu_np);
342 
343         codec_np = of_parse_phandle(np, "axentia,audio-codec", 0);
344         if (!codec_np) {
345                 dev_err(&pdev->dev, "failed to get codec info\n");
346                 return -EINVAL;
347         }
348         dailink->codecs->of_node = codec_np;
349         of_node_put(codec_np);
350 
351         return 0;
352 }
353 
354 static int tse850_probe(struct platform_device *pdev)
355 {
356         struct snd_soc_card *card = &tse850_card;
357         struct device *dev = card->dev = &pdev->dev;
358         struct tse850_priv *tse850;
359         int ret;
360 
361         tse850 = devm_kzalloc(dev, sizeof(*tse850), GFP_KERNEL);
362         if (!tse850)
363                 return -ENOMEM;
364 
365         snd_soc_card_set_drvdata(card, tse850);
366 
367         ret = tse850_dt_init(pdev);
368         if (ret) {
369                 dev_err(dev, "failed to init dt info\n");
370                 return ret;
371         }
372 
373         tse850->add = devm_gpiod_get(dev, "axentia,add", GPIOD_OUT_HIGH);
374         if (IS_ERR(tse850->add)) {
375                 if (PTR_ERR(tse850->add) != -EPROBE_DEFER)
376                         dev_err(dev, "failed to get 'add' gpio\n");
377                 return PTR_ERR(tse850->add);
378         }
379         tse850->add_cache = 1;
380 
381         tse850->loop1 = devm_gpiod_get(dev, "axentia,loop1", GPIOD_OUT_HIGH);
382         if (IS_ERR(tse850->loop1)) {
383                 if (PTR_ERR(tse850->loop1) != -EPROBE_DEFER)
384                         dev_err(dev, "failed to get 'loop1' gpio\n");
385                 return PTR_ERR(tse850->loop1);
386         }
387         tse850->loop1_cache = 1;
388 
389         tse850->loop2 = devm_gpiod_get(dev, "axentia,loop2", GPIOD_OUT_HIGH);
390         if (IS_ERR(tse850->loop2)) {
391                 if (PTR_ERR(tse850->loop2) != -EPROBE_DEFER)
392                         dev_err(dev, "failed to get 'loop2' gpio\n");
393                 return PTR_ERR(tse850->loop2);
394         }
395         tse850->loop2_cache = 1;
396 
397         tse850->ana = devm_regulator_get(dev, "axentia,ana");
398         if (IS_ERR(tse850->ana)) {
399                 if (PTR_ERR(tse850->ana) != -EPROBE_DEFER)
400                         dev_err(dev, "failed to get 'ana' regulator\n");
401                 return PTR_ERR(tse850->ana);
402         }
403 
404         ret = regulator_enable(tse850->ana);
405         if (ret < 0) {
406                 dev_err(dev, "failed to enable the 'ana' regulator\n");
407                 return ret;
408         }
409 
410         ret = snd_soc_register_card(card);
411         if (ret) {
412                 dev_err(dev, "snd_soc_register_card failed\n");
413                 goto err_disable_ana;
414         }
415 
416         return 0;
417 
418 err_disable_ana:
419         regulator_disable(tse850->ana);
420         return ret;
421 }
422 
423 static int tse850_remove(struct platform_device *pdev)
424 {
425         struct snd_soc_card *card = platform_get_drvdata(pdev);
426         struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card);
427 
428         snd_soc_unregister_card(card);
429         regulator_disable(tse850->ana);
430 
431         return 0;
432 }
433 
434 static const struct of_device_id tse850_dt_ids[] = {
435         { .compatible = "axentia,tse850-pcm5142", },
436         { /* sentinel */ }
437 };
438 MODULE_DEVICE_TABLE(of, tse850_dt_ids);
439 
440 static struct platform_driver tse850_driver = {
441         .driver = {
442                 .name = "axentia-tse850-pcm5142",
443                 .of_match_table = of_match_ptr(tse850_dt_ids),
444         },
445         .probe = tse850_probe,
446         .remove = tse850_remove,
447 };
448 
449 module_platform_driver(tse850_driver);
450 
451 /* Module information */
452 MODULE_AUTHOR("Peter Rosin <peda@axentia.se>");
453 MODULE_DESCRIPTION("ALSA SoC driver for TSE-850 with PCM5142 codec");
454 MODULE_LICENSE("GPL v2");
455 

~ [ 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