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