sound/soc/atmel/tse850-pcm5142.c

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