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 simple_card_data { 25 struct snd_soc_card snd_card; 26 struct simple_dai_props { 27 struct asoc_simple_dai cpu_dai; 28 struct asoc_simple_dai codec_dai; 29 } *dai_props; 30 unsigned int mclk_fs; 31 int gpio_hp_det; 32 int gpio_hp_det_invert; 33 int gpio_mic_det; 34 int gpio_mic_det_invert; 35 struct snd_soc_dai_link dai_link[]; /* dynamically allocated */ 36 }; 37 38 #define simple_priv_to_dev(priv) ((priv)->snd_card.dev) 39 #define simple_priv_to_link(priv, i) ((priv)->snd_card.dai_link + i) 40 #define simple_priv_to_props(priv, i) ((priv)->dai_props + i) 41 42 static int asoc_simple_card_startup(struct snd_pcm_substream *substream) 43 { 44 struct snd_soc_pcm_runtime *rtd = substream->private_data; 45 struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card); 46 struct simple_dai_props *dai_props = 47 &priv->dai_props[rtd - rtd->card->rtd]; 48 int ret; 49 50 ret = clk_prepare_enable(dai_props->cpu_dai.clk); 51 if (ret) 52 return ret; 53 54 ret = clk_prepare_enable(dai_props->codec_dai.clk); 55 if (ret) 56 clk_disable_unprepare(dai_props->cpu_dai.clk); 57 58 return ret; 59 } 60 61 static void asoc_simple_card_shutdown(struct snd_pcm_substream *substream) 62 { 63 struct snd_soc_pcm_runtime *rtd = substream->private_data; 64 struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card); 65 struct simple_dai_props *dai_props = 66 &priv->dai_props[rtd - rtd->card->rtd]; 67 68 clk_disable_unprepare(dai_props->cpu_dai.clk); 69 70 clk_disable_unprepare(dai_props->codec_dai.clk); 71 } 72 73 static int asoc_simple_card_hw_params(struct snd_pcm_substream *substream, 74 struct snd_pcm_hw_params *params) 75 { 76 struct snd_soc_pcm_runtime *rtd = substream->private_data; 77 struct snd_soc_dai *codec_dai = rtd->codec_dai; 78 struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card); 79 unsigned int mclk; 80 int ret = 0; 81 82 if (priv->mclk_fs) { 83 mclk = params_rate(params) * priv->mclk_fs; 84 ret = snd_soc_dai_set_sysclk(codec_dai, 0, mclk, 85 SND_SOC_CLOCK_IN); 86 } 87 88 return ret; 89 } 90 91 static struct snd_soc_ops asoc_simple_card_ops = { 92 .startup = asoc_simple_card_startup, 93 .shutdown = asoc_simple_card_shutdown, 94 .hw_params = asoc_simple_card_hw_params, 95 }; 96 97 static struct snd_soc_jack simple_card_hp_jack; 98 static struct snd_soc_jack_pin simple_card_hp_jack_pins[] = { 99 { 100 .pin = "Headphones", 101 .mask = SND_JACK_HEADPHONE, 102 }, 103 }; 104 static struct snd_soc_jack_gpio simple_card_hp_jack_gpio = { 105 .name = "Headphone detection", 106 .report = SND_JACK_HEADPHONE, 107 .debounce_time = 150, 108 }; 109 110 static struct snd_soc_jack simple_card_mic_jack; 111 static struct snd_soc_jack_pin simple_card_mic_jack_pins[] = { 112 { 113 .pin = "Mic Jack", 114 .mask = SND_JACK_MICROPHONE, 115 }, 116 }; 117 static struct snd_soc_jack_gpio simple_card_mic_jack_gpio = { 118 .name = "Mic detection", 119 .report = SND_JACK_MICROPHONE, 120 .debounce_time = 150, 121 }; 122 123 static int __asoc_simple_card_dai_init(struct snd_soc_dai *dai, 124 struct asoc_simple_dai *set) 125 { 126 int ret; 127 128 if (set->fmt) { 129 ret = snd_soc_dai_set_fmt(dai, set->fmt); 130 if (ret && ret != -ENOTSUPP) { 131 dev_err(dai->dev, "simple-card: set_fmt error\n"); 132 goto err; 133 } 134 } 135 136 if (set->sysclk) { 137 ret = snd_soc_dai_set_sysclk(dai, 0, set->sysclk, 0); 138 if (ret && ret != -ENOTSUPP) { 139 dev_err(dai->dev, "simple-card: set_sysclk error\n"); 140 goto err; 141 } 142 } 143 144 if (set->slots) { 145 ret = snd_soc_dai_set_tdm_slot(dai, 0, 0, 146 set->slots, 147 set->slot_width); 148 if (ret && ret != -ENOTSUPP) { 149 dev_err(dai->dev, "simple-card: set_tdm_slot error\n"); 150 goto err; 151 } 152 } 153 154 ret = 0; 155 156 err: 157 return ret; 158 } 159 160 static int asoc_simple_card_dai_init(struct snd_soc_pcm_runtime *rtd) 161 { 162 struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card); 163 struct snd_soc_dai *codec = rtd->codec_dai; 164 struct snd_soc_dai *cpu = rtd->cpu_dai; 165 struct simple_dai_props *dai_props; 166 int num, ret; 167 168 num = rtd - rtd->card->rtd; 169 dai_props = &priv->dai_props[num]; 170 ret = __asoc_simple_card_dai_init(codec, &dai_props->codec_dai); 171 if (ret < 0) 172 return ret; 173 174 ret = __asoc_simple_card_dai_init(cpu, &dai_props->cpu_dai); 175 if (ret < 0) 176 return ret; 177 178 if (gpio_is_valid(priv->gpio_hp_det)) { 179 snd_soc_jack_new(codec->codec, "Headphones", SND_JACK_HEADPHONE, 180 &simple_card_hp_jack); 181 snd_soc_jack_add_pins(&simple_card_hp_jack, 182 ARRAY_SIZE(simple_card_hp_jack_pins), 183 simple_card_hp_jack_pins); 184 185 simple_card_hp_jack_gpio.gpio = priv->gpio_hp_det; 186 simple_card_hp_jack_gpio.invert = priv->gpio_hp_det_invert; 187 snd_soc_jack_add_gpios(&simple_card_hp_jack, 1, 188 &simple_card_hp_jack_gpio); 189 } 190 191 if (gpio_is_valid(priv->gpio_mic_det)) { 192 snd_soc_jack_new(codec->codec, "Mic Jack", SND_JACK_MICROPHONE, 193 &simple_card_mic_jack); 194 snd_soc_jack_add_pins(&simple_card_mic_jack, 195 ARRAY_SIZE(simple_card_mic_jack_pins), 196 simple_card_mic_jack_pins); 197 simple_card_mic_jack_gpio.gpio = priv->gpio_mic_det; 198 simple_card_mic_jack_gpio.invert = priv->gpio_mic_det_invert; 199 snd_soc_jack_add_gpios(&simple_card_mic_jack, 1, 200 &simple_card_mic_jack_gpio); 201 } 202 return 0; 203 } 204 205 static int 206 asoc_simple_card_sub_parse_of(struct device_node *np, 207 struct asoc_simple_dai *dai, 208 struct device_node **p_node, 209 const char **name, 210 int *args_count) 211 { 212 struct of_phandle_args args; 213 struct clk *clk; 214 u32 val; 215 int ret; 216 217 /* 218 * Get node via "sound-dai = <&phandle port>" 219 * it will be used as xxx_of_node on soc_bind_dai_link() 220 */ 221 ret = of_parse_phandle_with_args(np, "sound-dai", 222 "#sound-dai-cells", 0, &args); 223 if (ret) 224 return ret; 225 226 *p_node = args.np; 227 228 if (args_count) 229 *args_count = args.args_count; 230 231 /* Get dai->name */ 232 ret = snd_soc_of_get_dai_name(np, name); 233 if (ret < 0) 234 return ret; 235 236 /* Parse TDM slot */ 237 ret = snd_soc_of_parse_tdm_slot(np, &dai->slots, &dai->slot_width); 238 if (ret) 239 return ret; 240 241 /* 242 * Parse dai->sysclk come from "clocks = <&xxx>" 243 * (if system has common clock) 244 * or "system-clock-frequency = <xxx>" 245 * or device's module clock. 246 */ 247 if (of_property_read_bool(np, "clocks")) { 248 clk = of_clk_get(np, 0); 249 if (IS_ERR(clk)) { 250 ret = PTR_ERR(clk); 251 return ret; 252 } 253 254 dai->sysclk = clk_get_rate(clk); 255 dai->clk = clk; 256 } else if (!of_property_read_u32(np, "system-clock-frequency", &val)) { 257 dai->sysclk = val; 258 } else { 259 clk = of_clk_get(args.np, 0); 260 if (!IS_ERR(clk)) 261 dai->sysclk = clk_get_rate(clk); 262 } 263 264 return 0; 265 } 266 267 static int asoc_simple_card_parse_daifmt(struct device_node *node, 268 struct simple_card_data *priv, 269 struct device_node *codec, 270 char *prefix, int idx) 271 { 272 struct device *dev = simple_priv_to_dev(priv); 273 struct device_node *bitclkmaster = NULL; 274 struct device_node *framemaster = NULL; 275 struct simple_dai_props *dai_props = simple_priv_to_props(priv, idx); 276 struct asoc_simple_dai *cpu_dai = &dai_props->cpu_dai; 277 struct asoc_simple_dai *codec_dai = &dai_props->codec_dai; 278 unsigned int daifmt; 279 280 daifmt = snd_soc_of_parse_daifmt(node, prefix, 281 &bitclkmaster, &framemaster); 282 daifmt &= ~SND_SOC_DAIFMT_MASTER_MASK; 283 284 if (strlen(prefix) && !bitclkmaster && !framemaster) { 285 /* 286 * No dai-link level and master setting was not found from 287 * sound node level, revert back to legacy DT parsing and 288 * take the settings from codec node. 289 */ 290 dev_dbg(dev, "Revert to legacy daifmt parsing\n"); 291 292 cpu_dai->fmt = codec_dai->fmt = 293 snd_soc_of_parse_daifmt(codec, NULL, NULL, NULL) | 294 (daifmt & ~SND_SOC_DAIFMT_CLOCK_MASK); 295 } else { 296 if (codec == bitclkmaster) 297 daifmt |= (codec == framemaster) ? 298 SND_SOC_DAIFMT_CBM_CFM : SND_SOC_DAIFMT_CBM_CFS; 299 else 300 daifmt |= (codec == framemaster) ? 301 SND_SOC_DAIFMT_CBS_CFM : SND_SOC_DAIFMT_CBS_CFS; 302 303 cpu_dai->fmt = daifmt; 304 codec_dai->fmt = daifmt; 305 } 306 307 of_node_put(bitclkmaster); 308 of_node_put(framemaster); 309 310 return 0; 311 } 312 313 static int asoc_simple_card_dai_link_of(struct device_node *node, 314 struct simple_card_data *priv, 315 int idx, 316 bool is_top_level_node) 317 { 318 struct device *dev = simple_priv_to_dev(priv); 319 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, idx); 320 struct simple_dai_props *dai_props = simple_priv_to_props(priv, idx); 321 struct device_node *cpu = NULL; 322 struct device_node *codec = NULL; 323 char *name; 324 char prop[128]; 325 char *prefix = ""; 326 int ret, cpu_args; 327 328 /* For single DAI link & old style of DT node */ 329 if (is_top_level_node) 330 prefix = "simple-audio-card,"; 331 332 snprintf(prop, sizeof(prop), "%scpu", prefix); 333 cpu = of_get_child_by_name(node, prop); 334 335 snprintf(prop, sizeof(prop), "%scodec", prefix); 336 codec = of_get_child_by_name(node, prop); 337 338 if (!cpu || !codec) { 339 ret = -EINVAL; 340 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop); 341 goto dai_link_of_err; 342 } 343 344 ret = asoc_simple_card_parse_daifmt(node, priv, 345 codec, prefix, idx); 346 if (ret < 0) 347 goto dai_link_of_err; 348 349 ret = asoc_simple_card_sub_parse_of(cpu, &dai_props->cpu_dai, 350 &dai_link->cpu_of_node, 351 &dai_link->cpu_dai_name, 352 &cpu_args); 353 if (ret < 0) 354 goto dai_link_of_err; 355 356 ret = asoc_simple_card_sub_parse_of(codec, &dai_props->codec_dai, 357 &dai_link->codec_of_node, 358 &dai_link->codec_dai_name, NULL); 359 if (ret < 0) 360 goto dai_link_of_err; 361 362 if (!dai_link->cpu_dai_name || !dai_link->codec_dai_name) { 363 ret = -EINVAL; 364 goto dai_link_of_err; 365 } 366 367 /* Simple Card assumes platform == cpu */ 368 dai_link->platform_of_node = dai_link->cpu_of_node; 369 370 /* DAI link name is created from CPU/CODEC dai name */ 371 name = devm_kzalloc(dev, 372 strlen(dai_link->cpu_dai_name) + 373 strlen(dai_link->codec_dai_name) + 2, 374 GFP_KERNEL); 375 if (!name) { 376 ret = -ENOMEM; 377 goto dai_link_of_err; 378 } 379 380 sprintf(name, "%s-%s", dai_link->cpu_dai_name, 381 dai_link->codec_dai_name); 382 dai_link->name = dai_link->stream_name = name; 383 dai_link->ops = &asoc_simple_card_ops; 384 dai_link->init = asoc_simple_card_dai_init; 385 386 dev_dbg(dev, "\tname : %s\n", dai_link->stream_name); 387 dev_dbg(dev, "\tcpu : %s / %04x / %d\n", 388 dai_link->cpu_dai_name, 389 dai_props->cpu_dai.fmt, 390 dai_props->cpu_dai.sysclk); 391 dev_dbg(dev, "\tcodec : %s / %04x / %d\n", 392 dai_link->codec_dai_name, 393 dai_props->codec_dai.fmt, 394 dai_props->codec_dai.sysclk); 395 396 /* 397 * In soc_bind_dai_link() will check cpu name after 398 * of_node matching if dai_link has cpu_dai_name. 399 * but, it will never match if name was created by 400 * fmt_single_name() remove cpu_dai_name if cpu_args 401 * was 0. See: 402 * fmt_single_name() 403 * fmt_multiple_name() 404 */ 405 if (!cpu_args) 406 dai_link->cpu_dai_name = NULL; 407 408 dai_link_of_err: 409 of_node_put(cpu); 410 of_node_put(codec); 411 412 return ret; 413 } 414 415 static int asoc_simple_card_parse_of(struct device_node *node, 416 struct simple_card_data *priv) 417 { 418 struct device *dev = simple_priv_to_dev(priv); 419 enum of_gpio_flags flags; 420 u32 val; 421 int ret; 422 423 if (!node) 424 return -EINVAL; 425 426 /* Parse the card name from DT */ 427 snd_soc_of_parse_card_name(&priv->snd_card, "simple-audio-card,name"); 428 429 /* The off-codec widgets */ 430 if (of_property_read_bool(node, "simple-audio-card,widgets")) { 431 ret = snd_soc_of_parse_audio_simple_widgets(&priv->snd_card, 432 "simple-audio-card,widgets"); 433 if (ret) 434 return ret; 435 } 436 437 /* DAPM routes */ 438 if (of_property_read_bool(node, "simple-audio-card,routing")) { 439 ret = snd_soc_of_parse_audio_routing(&priv->snd_card, 440 "simple-audio-card,routing"); 441 if (ret) 442 return ret; 443 } 444 445 /* Factor to mclk, used in hw_params() */ 446 ret = of_property_read_u32(node, "simple-audio-card,mclk-fs", &val); 447 if (ret == 0) 448 priv->mclk_fs = val; 449 450 dev_dbg(dev, "New simple-card: %s\n", priv->snd_card.name ? 451 priv->snd_card.name : ""); 452 453 /* Single/Muti DAI link(s) & New style of DT node */ 454 if (of_get_child_by_name(node, "simple-audio-card,dai-link")) { 455 struct device_node *np = NULL; 456 int i = 0; 457 458 for_each_child_of_node(node, np) { 459 dev_dbg(dev, "\tlink %d:\n", i); 460 ret = asoc_simple_card_dai_link_of(np, priv, 461 i, false); 462 if (ret < 0) { 463 of_node_put(np); 464 return ret; 465 } 466 i++; 467 } 468 } else { 469 /* For single DAI link & old style of DT node */ 470 ret = asoc_simple_card_dai_link_of(node, priv, 0, true); 471 if (ret < 0) 472 return ret; 473 } 474 475 priv->gpio_hp_det = of_get_named_gpio_flags(node, 476 "simple-audio-card,hp-det-gpio", 0, &flags); 477 priv->gpio_hp_det_invert = !!(flags & OF_GPIO_ACTIVE_LOW); 478 if (priv->gpio_hp_det == -EPROBE_DEFER) 479 return -EPROBE_DEFER; 480 481 priv->gpio_mic_det = of_get_named_gpio_flags(node, 482 "simple-audio-card,mic-det-gpio", 0, &flags); 483 priv->gpio_mic_det_invert = !!(flags & OF_GPIO_ACTIVE_LOW); 484 if (priv->gpio_mic_det == -EPROBE_DEFER) 485 return -EPROBE_DEFER; 486 487 if (!priv->snd_card.name) 488 priv->snd_card.name = priv->snd_card.dai_link->name; 489 490 return 0; 491 } 492 493 /* Decrease the reference count of the device nodes */ 494 static int asoc_simple_card_unref(struct snd_soc_card *card) 495 { 496 struct snd_soc_dai_link *dai_link; 497 int num_links; 498 499 for (num_links = 0, dai_link = card->dai_link; 500 num_links < card->num_links; 501 num_links++, dai_link++) { 502 of_node_put(dai_link->cpu_of_node); 503 of_node_put(dai_link->codec_of_node); 504 } 505 return 0; 506 } 507 508 static int asoc_simple_card_probe(struct platform_device *pdev) 509 { 510 struct simple_card_data *priv; 511 struct snd_soc_dai_link *dai_link; 512 struct device_node *np = pdev->dev.of_node; 513 struct device *dev = &pdev->dev; 514 int num_links, ret; 515 516 /* Get the number of DAI links */ 517 if (np && of_get_child_by_name(np, "simple-audio-card,dai-link")) 518 num_links = of_get_child_count(np); 519 else 520 num_links = 1; 521 522 /* Allocate the private data and the DAI link array */ 523 priv = devm_kzalloc(dev, 524 sizeof(*priv) + sizeof(*dai_link) * num_links, 525 GFP_KERNEL); 526 if (!priv) 527 return -ENOMEM; 528 529 /* Init snd_soc_card */ 530 priv->snd_card.owner = THIS_MODULE; 531 priv->snd_card.dev = dev; 532 dai_link = priv->dai_link; 533 priv->snd_card.dai_link = dai_link; 534 priv->snd_card.num_links = num_links; 535 536 priv->gpio_hp_det = -ENOENT; 537 priv->gpio_mic_det = -ENOENT; 538 539 /* Get room for the other properties */ 540 priv->dai_props = devm_kzalloc(dev, 541 sizeof(*priv->dai_props) * num_links, 542 GFP_KERNEL); 543 if (!priv->dai_props) 544 return -ENOMEM; 545 546 if (np && of_device_is_available(np)) { 547 548 ret = asoc_simple_card_parse_of(np, priv); 549 if (ret < 0) { 550 if (ret != -EPROBE_DEFER) 551 dev_err(dev, "parse error %d\n", ret); 552 goto err; 553 } 554 555 } else { 556 struct asoc_simple_card_info *cinfo; 557 558 cinfo = dev->platform_data; 559 if (!cinfo) { 560 dev_err(dev, "no info for asoc-simple-card\n"); 561 return -EINVAL; 562 } 563 564 if (!cinfo->name || 565 !cinfo->codec_dai.name || 566 !cinfo->codec || 567 !cinfo->platform || 568 !cinfo->cpu_dai.name) { 569 dev_err(dev, "insufficient asoc_simple_card_info settings\n"); 570 return -EINVAL; 571 } 572 573 priv->snd_card.name = (cinfo->card) ? cinfo->card : cinfo->name; 574 dai_link->name = cinfo->name; 575 dai_link->stream_name = cinfo->name; 576 dai_link->platform_name = cinfo->platform; 577 dai_link->codec_name = cinfo->codec; 578 dai_link->cpu_dai_name = cinfo->cpu_dai.name; 579 dai_link->codec_dai_name = cinfo->codec_dai.name; 580 dai_link->init = asoc_simple_card_dai_init; 581 memcpy(&priv->dai_props->cpu_dai, &cinfo->cpu_dai, 582 sizeof(priv->dai_props->cpu_dai)); 583 memcpy(&priv->dai_props->codec_dai, &cinfo->codec_dai, 584 sizeof(priv->dai_props->codec_dai)); 585 586 priv->dai_props->cpu_dai.fmt |= cinfo->daifmt; 587 priv->dai_props->codec_dai.fmt |= cinfo->daifmt; 588 } 589 590 snd_soc_card_set_drvdata(&priv->snd_card, priv); 591 592 ret = devm_snd_soc_register_card(&pdev->dev, &priv->snd_card); 593 if (ret >= 0) 594 return ret; 595 596 err: 597 asoc_simple_card_unref(&priv->snd_card); 598 return ret; 599 } 600 601 static int asoc_simple_card_remove(struct platform_device *pdev) 602 { 603 struct snd_soc_card *card = platform_get_drvdata(pdev); 604 struct simple_card_data *priv = snd_soc_card_get_drvdata(card); 605 606 if (gpio_is_valid(priv->gpio_hp_det)) 607 snd_soc_jack_free_gpios(&simple_card_hp_jack, 1, 608 &simple_card_hp_jack_gpio); 609 if (gpio_is_valid(priv->gpio_mic_det)) 610 snd_soc_jack_free_gpios(&simple_card_mic_jack, 1, 611 &simple_card_mic_jack_gpio); 612 613 return asoc_simple_card_unref(card); 614 } 615 616 static const struct of_device_id asoc_simple_of_match[] = { 617 { .compatible = "simple-audio-card", }, 618 {}, 619 }; 620 MODULE_DEVICE_TABLE(of, asoc_simple_of_match); 621 622 static struct platform_driver asoc_simple_card = { 623 .driver = { 624 .name = "asoc-simple-card", 625 .of_match_table = asoc_simple_of_match, 626 }, 627 .probe = asoc_simple_card_probe, 628 .remove = asoc_simple_card_remove, 629 }; 630 631 module_platform_driver(asoc_simple_card); 632 633 MODULE_ALIAS("platform:asoc-simple-card"); 634 MODULE_LICENSE("GPL"); 635 MODULE_DESCRIPTION("ASoC Simple Sound Card"); 636 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 637