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