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