1 /* 2 * ASoC simple sound card support 3 * 4 * Copyright (C) 2012 Renesas Solutions Corp. 5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include <linux/clk.h> 12 #include <linux/device.h> 13 #include <linux/gpio.h> 14 #include <linux/module.h> 15 #include <linux/of.h> 16 #include <linux/of_gpio.h> 17 #include <linux/platform_device.h> 18 #include <linux/string.h> 19 #include <sound/jack.h> 20 #include <sound/simple_card.h> 21 #include <sound/soc-dai.h> 22 #include <sound/soc.h> 23 24 struct asoc_simple_jack { 25 struct snd_soc_jack jack; 26 struct snd_soc_jack_pin pin; 27 struct snd_soc_jack_gpio gpio; 28 }; 29 30 struct simple_card_data { 31 struct snd_soc_card snd_card; 32 struct simple_dai_props { 33 struct asoc_simple_dai cpu_dai; 34 struct asoc_simple_dai codec_dai; 35 unsigned int mclk_fs; 36 } *dai_props; 37 unsigned int mclk_fs; 38 struct asoc_simple_jack hp_jack; 39 struct asoc_simple_jack mic_jack; 40 struct snd_soc_dai_link *dai_link; 41 }; 42 43 #define simple_priv_to_card(priv) (&(priv)->snd_card) 44 #define simple_priv_to_props(priv, i) ((priv)->dai_props + (i)) 45 #define simple_priv_to_dev(priv) (simple_priv_to_card(priv)->dev) 46 #define simple_priv_to_link(priv, i) (simple_priv_to_card(priv)->dai_link + (i)) 47 48 #define DAI "sound-dai" 49 #define CELL "#sound-dai-cells" 50 #define PREFIX "simple-audio-card," 51 52 #define asoc_simple_card_init_hp(card, sjack, prefix)\ 53 asoc_simple_card_init_jack(card, sjack, 1, prefix) 54 #define asoc_simple_card_init_mic(card, sjack, prefix)\ 55 asoc_simple_card_init_jack(card, sjack, 0, prefix) 56 static int asoc_simple_card_init_jack(struct snd_soc_card *card, 57 struct asoc_simple_jack *sjack, 58 int is_hp, char *prefix) 59 { 60 struct device *dev = card->dev; 61 enum of_gpio_flags flags; 62 char prop[128]; 63 char *pin_name; 64 char *gpio_name; 65 int mask; 66 int det; 67 68 sjack->gpio.gpio = -ENOENT; 69 70 if (is_hp) { 71 snprintf(prop, sizeof(prop), "%shp-det-gpio", prefix); 72 pin_name = "Headphones"; 73 gpio_name = "Headphone detection"; 74 mask = SND_JACK_HEADPHONE; 75 } else { 76 snprintf(prop, sizeof(prop), "%smic-det-gpio", prefix); 77 pin_name = "Mic Jack"; 78 gpio_name = "Mic detection"; 79 mask = SND_JACK_MICROPHONE; 80 } 81 82 det = of_get_named_gpio_flags(dev->of_node, prop, 0, &flags); 83 if (det == -EPROBE_DEFER) 84 return -EPROBE_DEFER; 85 86 if (gpio_is_valid(det)) { 87 sjack->pin.pin = pin_name; 88 sjack->pin.mask = mask; 89 90 sjack->gpio.name = gpio_name; 91 sjack->gpio.report = mask; 92 sjack->gpio.gpio = det; 93 sjack->gpio.invert = !!(flags & OF_GPIO_ACTIVE_LOW); 94 sjack->gpio.debounce_time = 150; 95 96 snd_soc_card_jack_new(card, pin_name, mask, 97 &sjack->jack, 98 &sjack->pin, 1); 99 100 snd_soc_jack_add_gpios(&sjack->jack, 1, 101 &sjack->gpio); 102 } 103 104 return 0; 105 } 106 107 static int asoc_simple_card_startup(struct snd_pcm_substream *substream) 108 { 109 struct snd_soc_pcm_runtime *rtd = substream->private_data; 110 struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card); 111 struct simple_dai_props *dai_props = 112 simple_priv_to_props(priv, rtd->num); 113 int ret; 114 115 ret = asoc_simple_card_clk_enable(&dai_props->cpu_dai); 116 if (ret) 117 return ret; 118 119 ret = asoc_simple_card_clk_enable(&dai_props->codec_dai); 120 if (ret) 121 asoc_simple_card_clk_disable(&dai_props->cpu_dai); 122 123 return ret; 124 } 125 126 static void asoc_simple_card_shutdown(struct snd_pcm_substream *substream) 127 { 128 struct snd_soc_pcm_runtime *rtd = substream->private_data; 129 struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card); 130 struct simple_dai_props *dai_props = 131 simple_priv_to_props(priv, rtd->num); 132 133 asoc_simple_card_clk_disable(&dai_props->cpu_dai); 134 135 asoc_simple_card_clk_disable(&dai_props->codec_dai); 136 } 137 138 static int asoc_simple_set_clk_rate(struct asoc_simple_dai *simple_dai, 139 unsigned long rate) 140 { 141 if (!simple_dai->clk) 142 return 0; 143 144 if (clk_get_rate(simple_dai->clk) == rate) 145 return 0; 146 147 return clk_set_rate(simple_dai->clk, rate); 148 } 149 150 static int asoc_simple_card_hw_params(struct snd_pcm_substream *substream, 151 struct snd_pcm_hw_params *params) 152 { 153 struct snd_soc_pcm_runtime *rtd = substream->private_data; 154 struct snd_soc_dai *codec_dai = rtd->codec_dai; 155 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 156 struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card); 157 struct simple_dai_props *dai_props = 158 simple_priv_to_props(priv, rtd->num); 159 unsigned int mclk, mclk_fs = 0; 160 int ret = 0; 161 162 if (priv->mclk_fs) 163 mclk_fs = priv->mclk_fs; 164 else if (dai_props->mclk_fs) 165 mclk_fs = dai_props->mclk_fs; 166 167 if (mclk_fs) { 168 mclk = params_rate(params) * mclk_fs; 169 170 ret = asoc_simple_set_clk_rate(&dai_props->codec_dai, mclk); 171 if (ret < 0) 172 return ret; 173 174 ret = asoc_simple_set_clk_rate(&dai_props->cpu_dai, mclk); 175 if (ret < 0) 176 return ret; 177 178 ret = snd_soc_dai_set_sysclk(codec_dai, 0, mclk, 179 SND_SOC_CLOCK_IN); 180 if (ret && ret != -ENOTSUPP) 181 goto err; 182 183 ret = snd_soc_dai_set_sysclk(cpu_dai, 0, mclk, 184 SND_SOC_CLOCK_OUT); 185 if (ret && ret != -ENOTSUPP) 186 goto err; 187 } 188 return 0; 189 err: 190 return ret; 191 } 192 193 static const struct snd_soc_ops asoc_simple_card_ops = { 194 .startup = asoc_simple_card_startup, 195 .shutdown = asoc_simple_card_shutdown, 196 .hw_params = asoc_simple_card_hw_params, 197 }; 198 199 static int asoc_simple_card_dai_init(struct snd_soc_pcm_runtime *rtd) 200 { 201 struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card); 202 struct snd_soc_dai *codec = rtd->codec_dai; 203 struct snd_soc_dai *cpu = rtd->cpu_dai; 204 struct simple_dai_props *dai_props = 205 simple_priv_to_props(priv, rtd->num); 206 int ret; 207 208 ret = asoc_simple_card_init_dai(codec, &dai_props->codec_dai); 209 if (ret < 0) 210 return ret; 211 212 ret = asoc_simple_card_init_dai(cpu, &dai_props->cpu_dai); 213 if (ret < 0) 214 return ret; 215 216 ret = asoc_simple_card_init_hp(rtd->card, &priv->hp_jack, PREFIX); 217 if (ret < 0) 218 return ret; 219 220 ret = asoc_simple_card_init_mic(rtd->card, &priv->mic_jack, PREFIX); 221 if (ret < 0) 222 return ret; 223 224 return 0; 225 } 226 227 static int asoc_simple_card_dai_link_of(struct device_node *node, 228 struct simple_card_data *priv, 229 int idx, 230 bool is_top_level_node) 231 { 232 struct device *dev = simple_priv_to_dev(priv); 233 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, idx); 234 struct simple_dai_props *dai_props = simple_priv_to_props(priv, idx); 235 struct asoc_simple_dai *cpu_dai = &dai_props->cpu_dai; 236 struct asoc_simple_dai *codec_dai = &dai_props->codec_dai; 237 struct device_node *cpu = NULL; 238 struct device_node *plat = NULL; 239 struct device_node *codec = NULL; 240 char prop[128]; 241 char *prefix = ""; 242 int ret, single_cpu; 243 244 /* For single DAI link & old style of DT node */ 245 if (is_top_level_node) 246 prefix = PREFIX; 247 248 snprintf(prop, sizeof(prop), "%scpu", prefix); 249 cpu = of_get_child_by_name(node, prop); 250 251 if (!cpu) { 252 ret = -EINVAL; 253 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop); 254 goto dai_link_of_err; 255 } 256 257 snprintf(prop, sizeof(prop), "%splat", prefix); 258 plat = of_get_child_by_name(node, prop); 259 260 snprintf(prop, sizeof(prop), "%scodec", prefix); 261 codec = of_get_child_by_name(node, prop); 262 263 if (!codec) { 264 ret = -EINVAL; 265 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop); 266 goto dai_link_of_err; 267 } 268 269 ret = asoc_simple_card_parse_daifmt(dev, node, codec, 270 prefix, &dai_link->dai_fmt); 271 if (ret < 0) 272 goto dai_link_of_err; 273 274 of_property_read_u32(node, "mclk-fs", &dai_props->mclk_fs); 275 276 ret = asoc_simple_card_parse_cpu(cpu, dai_link, 277 DAI, CELL, &single_cpu); 278 if (ret < 0) 279 goto dai_link_of_err; 280 281 ret = asoc_simple_card_parse_codec(codec, dai_link, DAI, CELL); 282 if (ret < 0) 283 goto dai_link_of_err; 284 285 ret = asoc_simple_card_parse_platform(plat, dai_link, DAI, CELL); 286 if (ret < 0) 287 goto dai_link_of_err; 288 289 ret = asoc_simple_card_of_parse_tdm(cpu, cpu_dai); 290 if (ret < 0) 291 goto dai_link_of_err; 292 293 ret = asoc_simple_card_of_parse_tdm(codec, codec_dai); 294 if (ret < 0) 295 goto dai_link_of_err; 296 297 ret = asoc_simple_card_parse_clk_cpu(dev, cpu, dai_link, cpu_dai); 298 if (ret < 0) 299 goto dai_link_of_err; 300 301 ret = asoc_simple_card_parse_clk_codec(dev, codec, dai_link, codec_dai); 302 if (ret < 0) 303 goto dai_link_of_err; 304 305 ret = asoc_simple_card_canonicalize_dailink(dai_link); 306 if (ret < 0) 307 goto dai_link_of_err; 308 309 ret = asoc_simple_card_set_dailink_name(dev, dai_link, 310 "%s-%s", 311 dai_link->cpu_dai_name, 312 dai_link->codec_dai_name); 313 if (ret < 0) 314 goto dai_link_of_err; 315 316 dai_link->ops = &asoc_simple_card_ops; 317 dai_link->init = asoc_simple_card_dai_init; 318 319 asoc_simple_card_canonicalize_cpu(dai_link, single_cpu); 320 321 dai_link_of_err: 322 of_node_put(cpu); 323 of_node_put(codec); 324 325 return ret; 326 } 327 328 static int asoc_simple_card_parse_aux_devs(struct device_node *node, 329 struct simple_card_data *priv) 330 { 331 struct device *dev = simple_priv_to_dev(priv); 332 struct device_node *aux_node; 333 struct snd_soc_card *card = simple_priv_to_card(priv); 334 int i, n, len; 335 336 if (!of_find_property(node, PREFIX "aux-devs", &len)) 337 return 0; /* Ok to have no aux-devs */ 338 339 n = len / sizeof(__be32); 340 if (n <= 0) 341 return -EINVAL; 342 343 card->aux_dev = devm_kcalloc(dev, 344 n, sizeof(*card->aux_dev), GFP_KERNEL); 345 if (!card->aux_dev) 346 return -ENOMEM; 347 348 for (i = 0; i < n; i++) { 349 aux_node = of_parse_phandle(node, PREFIX "aux-devs", i); 350 if (!aux_node) 351 return -EINVAL; 352 card->aux_dev[i].codec_of_node = aux_node; 353 } 354 355 card->num_aux_devs = n; 356 return 0; 357 } 358 359 static int asoc_simple_card_parse_of(struct simple_card_data *priv) 360 { 361 struct device *dev = simple_priv_to_dev(priv); 362 struct snd_soc_card *card = simple_priv_to_card(priv); 363 struct device_node *dai_link; 364 struct device_node *node = dev->of_node; 365 int ret; 366 367 if (!node) 368 return -EINVAL; 369 370 dai_link = of_get_child_by_name(node, PREFIX "dai-link"); 371 372 ret = asoc_simple_card_of_parse_widgets(card, PREFIX); 373 if (ret < 0) 374 goto card_parse_end; 375 376 ret = asoc_simple_card_of_parse_routing(card, PREFIX, 1); 377 if (ret < 0) 378 goto card_parse_end; 379 380 /* Factor to mclk, used in hw_params() */ 381 of_property_read_u32(node, PREFIX "mclk-fs", &priv->mclk_fs); 382 383 /* Single/Muti DAI link(s) & New style of DT node */ 384 if (dai_link) { 385 struct device_node *np = NULL; 386 int i = 0; 387 388 for_each_child_of_node(node, np) { 389 dev_dbg(dev, "\tlink %d:\n", i); 390 ret = asoc_simple_card_dai_link_of(np, priv, 391 i, false); 392 if (ret < 0) { 393 of_node_put(np); 394 goto card_parse_end; 395 } 396 i++; 397 } 398 } else { 399 /* For single DAI link & old style of DT node */ 400 ret = asoc_simple_card_dai_link_of(node, priv, 0, true); 401 if (ret < 0) 402 goto card_parse_end; 403 } 404 405 ret = asoc_simple_card_parse_card_name(card, PREFIX); 406 if (ret < 0) 407 goto card_parse_end; 408 409 ret = asoc_simple_card_parse_aux_devs(node, priv); 410 411 card_parse_end: 412 of_node_put(dai_link); 413 414 return ret; 415 } 416 417 static int asoc_simple_card_probe(struct platform_device *pdev) 418 { 419 struct simple_card_data *priv; 420 struct snd_soc_dai_link *dai_link; 421 struct simple_dai_props *dai_props; 422 struct device *dev = &pdev->dev; 423 struct device_node *np = dev->of_node; 424 struct snd_soc_card *card; 425 int num, ret; 426 427 /* Get the number of DAI links */ 428 if (np && of_get_child_by_name(np, PREFIX "dai-link")) 429 num = of_get_child_count(np); 430 else 431 num = 1; 432 433 /* Allocate the private data and the DAI link array */ 434 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 435 if (!priv) 436 return -ENOMEM; 437 438 dai_props = devm_kcalloc(dev, num, sizeof(*dai_props), GFP_KERNEL); 439 dai_link = devm_kcalloc(dev, num, sizeof(*dai_link), GFP_KERNEL); 440 if (!dai_props || !dai_link) 441 return -ENOMEM; 442 443 priv->dai_props = dai_props; 444 priv->dai_link = dai_link; 445 446 /* Init snd_soc_card */ 447 card = simple_priv_to_card(priv); 448 card->owner = THIS_MODULE; 449 card->dev = dev; 450 card->dai_link = priv->dai_link; 451 card->num_links = num; 452 453 if (np && of_device_is_available(np)) { 454 455 ret = asoc_simple_card_parse_of(priv); 456 if (ret < 0) { 457 if (ret != -EPROBE_DEFER) 458 dev_err(dev, "parse error %d\n", ret); 459 goto err; 460 } 461 462 } else { 463 struct asoc_simple_card_info *cinfo; 464 465 cinfo = dev->platform_data; 466 if (!cinfo) { 467 dev_err(dev, "no info for asoc-simple-card\n"); 468 return -EINVAL; 469 } 470 471 if (!cinfo->name || 472 !cinfo->codec_dai.name || 473 !cinfo->codec || 474 !cinfo->platform || 475 !cinfo->cpu_dai.name) { 476 dev_err(dev, "insufficient asoc_simple_card_info settings\n"); 477 return -EINVAL; 478 } 479 480 card->name = (cinfo->card) ? cinfo->card : cinfo->name; 481 dai_link->name = cinfo->name; 482 dai_link->stream_name = cinfo->name; 483 dai_link->platform_name = cinfo->platform; 484 dai_link->codec_name = cinfo->codec; 485 dai_link->cpu_dai_name = cinfo->cpu_dai.name; 486 dai_link->codec_dai_name = cinfo->codec_dai.name; 487 dai_link->dai_fmt = cinfo->daifmt; 488 dai_link->init = asoc_simple_card_dai_init; 489 memcpy(&priv->dai_props->cpu_dai, &cinfo->cpu_dai, 490 sizeof(priv->dai_props->cpu_dai)); 491 memcpy(&priv->dai_props->codec_dai, &cinfo->codec_dai, 492 sizeof(priv->dai_props->codec_dai)); 493 } 494 495 snd_soc_card_set_drvdata(card, priv); 496 497 ret = devm_snd_soc_register_card(dev, card); 498 if (ret < 0) 499 goto err; 500 501 return 0; 502 err: 503 asoc_simple_card_clean_reference(card); 504 505 return ret; 506 } 507 508 static int asoc_simple_card_remove(struct platform_device *pdev) 509 { 510 struct snd_soc_card *card = platform_get_drvdata(pdev); 511 512 return asoc_simple_card_clean_reference(card); 513 } 514 515 static const struct of_device_id asoc_simple_of_match[] = { 516 { .compatible = "simple-audio-card", }, 517 {}, 518 }; 519 MODULE_DEVICE_TABLE(of, asoc_simple_of_match); 520 521 static struct platform_driver asoc_simple_card = { 522 .driver = { 523 .name = "asoc-simple-card", 524 .pm = &snd_soc_pm_ops, 525 .of_match_table = asoc_simple_of_match, 526 }, 527 .probe = asoc_simple_card_probe, 528 .remove = asoc_simple_card_remove, 529 }; 530 531 module_platform_driver(asoc_simple_card); 532 533 MODULE_ALIAS("platform:asoc-simple-card"); 534 MODULE_LICENSE("GPL v2"); 535 MODULE_DESCRIPTION("ASoC Simple Sound Card"); 536 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 537