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