1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // simple-card-utils.c 4 // 5 // Copyright (c) 2016 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 6 7 #include <dt-bindings/sound/audio-graph.h> 8 #include <linux/cleanup.h> 9 #include <linux/clk.h> 10 #include <linux/gpio/consumer.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <linux/of_graph.h> 14 #include <sound/jack.h> 15 #include <sound/pcm_params.h> 16 #include <sound/simple_card_utils.h> 17 18 int simple_util_get_sample_fmt(struct simple_util_data *data) 19 { 20 int i; 21 int val = -EINVAL; 22 23 struct { 24 char *fmt; 25 u32 val; 26 } of_sample_fmt_table[] = { 27 { "s8", SNDRV_PCM_FORMAT_S8}, 28 { "s16_le", SNDRV_PCM_FORMAT_S16_LE}, 29 { "s24_le", SNDRV_PCM_FORMAT_S24_LE}, 30 { "s24_3le", SNDRV_PCM_FORMAT_S24_3LE}, 31 { "s32_le", SNDRV_PCM_FORMAT_S32_LE}, 32 }; 33 34 for (i = 0; i < ARRAY_SIZE(of_sample_fmt_table); i++) { 35 if (!strcmp(data->convert_sample_format, 36 of_sample_fmt_table[i].fmt)) { 37 val = of_sample_fmt_table[i].val; 38 break; 39 } 40 } 41 return val; 42 } 43 EXPORT_SYMBOL_GPL(simple_util_get_sample_fmt); 44 45 static void simple_fixup_sample_fmt(struct simple_util_data *data, 46 struct snd_pcm_hw_params *params) 47 { 48 int val; 49 struct snd_mask *mask = hw_param_mask(params, 50 SNDRV_PCM_HW_PARAM_FORMAT); 51 52 val = simple_util_get_sample_fmt(data); 53 if (val >= 0) { 54 snd_mask_none(mask); 55 snd_mask_set(mask, val); 56 } 57 } 58 59 void simple_util_parse_convert(struct device_node *np, 60 char *prefix, 61 struct simple_util_data *data) 62 { 63 char prop[128]; 64 65 if (!np) 66 return; 67 68 if (!prefix) 69 prefix = ""; 70 71 /* sampling rate convert */ 72 snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-rate"); 73 of_property_read_u32(np, prop, &data->convert_rate); 74 75 /* channels transfer */ 76 snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-channels"); 77 of_property_read_u32(np, prop, &data->convert_channels); 78 79 /* convert sample format */ 80 snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-sample-format"); 81 of_property_read_string(np, prop, &data->convert_sample_format); 82 } 83 EXPORT_SYMBOL_GPL(simple_util_parse_convert); 84 85 /** 86 * simple_util_is_convert_required() - Query if HW param conversion was requested 87 * @data: Link data. 88 * 89 * Returns true if any HW param conversion was requested for this DAI link with 90 * any "convert-xxx" properties. 91 */ 92 bool simple_util_is_convert_required(const struct simple_util_data *data) 93 { 94 return data->convert_rate || 95 data->convert_channels || 96 data->convert_sample_format; 97 } 98 EXPORT_SYMBOL_GPL(simple_util_is_convert_required); 99 100 int simple_util_parse_daifmt(struct device *dev, 101 struct device_node *node, 102 struct device_node *codec, 103 char *prefix, 104 unsigned int *retfmt) 105 { 106 struct device_node *bitclkmaster = NULL; 107 struct device_node *framemaster = NULL; 108 unsigned int daifmt; 109 110 daifmt = snd_soc_daifmt_parse_format(node, prefix); 111 112 snd_soc_daifmt_parse_clock_provider_as_phandle(node, prefix, &bitclkmaster, &framemaster); 113 if (!bitclkmaster && !framemaster) { 114 /* 115 * No dai-link level and master setting was not found from 116 * sound node level, revert back to legacy DT parsing and 117 * take the settings from codec node. 118 */ 119 dev_dbg(dev, "Revert to legacy daifmt parsing\n"); 120 121 daifmt |= snd_soc_daifmt_parse_clock_provider_as_flag(codec, NULL); 122 } else { 123 daifmt |= snd_soc_daifmt_clock_provider_from_bitmap( 124 ((codec == bitclkmaster) << 4) | (codec == framemaster)); 125 } 126 127 of_node_put(bitclkmaster); 128 of_node_put(framemaster); 129 130 *retfmt = daifmt; 131 132 return 0; 133 } 134 EXPORT_SYMBOL_GPL(simple_util_parse_daifmt); 135 136 int simple_util_parse_tdm_width_map(struct device *dev, struct device_node *np, 137 struct simple_util_dai *dai) 138 { 139 int n, i, ret; 140 u32 *p; 141 142 if (!of_property_read_bool(np, "dai-tdm-slot-width-map")) 143 return 0; 144 145 n = of_property_count_elems_of_size(np, "dai-tdm-slot-width-map", sizeof(u32)); 146 if (n % 3) { 147 dev_err(dev, "Invalid number of cells for dai-tdm-slot-width-map\n"); 148 return -EINVAL; 149 } 150 151 dai->tdm_width_map = devm_kcalloc(dev, n, sizeof(*dai->tdm_width_map), GFP_KERNEL); 152 if (!dai->tdm_width_map) 153 return -ENOMEM; 154 155 u32 *array_values __free(kfree) = kcalloc(n, sizeof(*array_values), 156 GFP_KERNEL); 157 if (!array_values) 158 return -ENOMEM; 159 160 ret = of_property_read_u32_array(np, "dai-tdm-slot-width-map", array_values, n); 161 if (ret < 0) { 162 dev_err(dev, "Could not read dai-tdm-slot-width-map: %d\n", ret); 163 return ret; 164 } 165 166 p = array_values; 167 for (i = 0; i < n / 3; ++i) { 168 dai->tdm_width_map[i].sample_bits = *p++; 169 dai->tdm_width_map[i].slot_width = *p++; 170 dai->tdm_width_map[i].slot_count = *p++; 171 } 172 173 dai->n_tdm_widths = i; 174 175 return 0; 176 } 177 EXPORT_SYMBOL_GPL(simple_util_parse_tdm_width_map); 178 179 int simple_util_set_dailink_name(struct device *dev, 180 struct snd_soc_dai_link *dai_link, 181 const char *fmt, ...) 182 { 183 va_list ap; 184 char *name = NULL; 185 int ret = -ENOMEM; 186 187 va_start(ap, fmt); 188 name = devm_kvasprintf(dev, GFP_KERNEL, fmt, ap); 189 va_end(ap); 190 191 if (name) { 192 ret = 0; 193 194 dai_link->name = name; 195 dai_link->stream_name = name; 196 } 197 198 return ret; 199 } 200 EXPORT_SYMBOL_GPL(simple_util_set_dailink_name); 201 202 int simple_util_parse_card_name(struct snd_soc_card *card, 203 char *prefix) 204 { 205 int ret; 206 207 if (!prefix) 208 prefix = ""; 209 210 /* Parse the card name from DT */ 211 ret = snd_soc_of_parse_card_name(card, "label"); 212 if (ret < 0 || !card->name) { 213 char prop[128]; 214 215 snprintf(prop, sizeof(prop), "%sname", prefix); 216 ret = snd_soc_of_parse_card_name(card, prop); 217 if (ret < 0) 218 return ret; 219 } 220 221 if (!card->name && card->dai_link) 222 card->name = card->dai_link->name; 223 224 return 0; 225 } 226 EXPORT_SYMBOL_GPL(simple_util_parse_card_name); 227 228 static int simple_clk_enable(struct simple_util_dai *dai) 229 { 230 if (dai) 231 return clk_prepare_enable(dai->clk); 232 233 return 0; 234 } 235 236 static void simple_clk_disable(struct simple_util_dai *dai) 237 { 238 if (dai) 239 clk_disable_unprepare(dai->clk); 240 } 241 242 int simple_util_parse_clk(struct device *dev, 243 struct device_node *node, 244 struct simple_util_dai *simple_dai, 245 struct snd_soc_dai_link_component *dlc) 246 { 247 struct clk *clk; 248 u32 val; 249 250 /* 251 * Parse dai->sysclk come from "clocks = <&xxx>" 252 * (if system has common clock) 253 * or "system-clock-frequency = <xxx>" 254 * or device's module clock. 255 */ 256 clk = devm_get_clk_from_child(dev, node, NULL); 257 simple_dai->clk_fixed = of_property_read_bool( 258 node, "system-clock-fixed"); 259 if (!IS_ERR(clk)) { 260 simple_dai->sysclk = clk_get_rate(clk); 261 262 simple_dai->clk = clk; 263 } else if (!of_property_read_u32(node, "system-clock-frequency", &val)) { 264 simple_dai->sysclk = val; 265 simple_dai->clk_fixed = true; 266 } else { 267 clk = devm_get_clk_from_child(dev, dlc->of_node, NULL); 268 if (!IS_ERR(clk)) 269 simple_dai->sysclk = clk_get_rate(clk); 270 } 271 272 if (of_property_read_bool(node, "system-clock-direction-out")) 273 simple_dai->clk_direction = SND_SOC_CLOCK_OUT; 274 275 return 0; 276 } 277 EXPORT_SYMBOL_GPL(simple_util_parse_clk); 278 279 static int simple_check_fixed_sysclk(struct device *dev, 280 struct simple_util_dai *dai, 281 unsigned int *fixed_sysclk) 282 { 283 if (dai->clk_fixed) { 284 if (*fixed_sysclk && *fixed_sysclk != dai->sysclk) { 285 dev_err(dev, "inconsistent fixed sysclk rates (%u vs %u)\n", 286 *fixed_sysclk, dai->sysclk); 287 return -EINVAL; 288 } 289 *fixed_sysclk = dai->sysclk; 290 } 291 292 return 0; 293 } 294 295 int simple_util_startup(struct snd_pcm_substream *substream) 296 { 297 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 298 struct simple_util_priv *priv = snd_soc_card_get_drvdata(rtd->card); 299 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num); 300 struct simple_util_dai *dai; 301 unsigned int fixed_sysclk = 0; 302 int i1, i2, i; 303 int ret; 304 305 for_each_prop_dai_cpu(props, i1, dai) { 306 ret = simple_clk_enable(dai); 307 if (ret) 308 goto cpu_err; 309 ret = simple_check_fixed_sysclk(rtd->dev, dai, &fixed_sysclk); 310 if (ret) 311 goto cpu_err; 312 } 313 314 for_each_prop_dai_codec(props, i2, dai) { 315 ret = simple_clk_enable(dai); 316 if (ret) 317 goto codec_err; 318 ret = simple_check_fixed_sysclk(rtd->dev, dai, &fixed_sysclk); 319 if (ret) 320 goto codec_err; 321 } 322 323 if (fixed_sysclk && props->mclk_fs) { 324 unsigned int fixed_rate = fixed_sysclk / props->mclk_fs; 325 326 if (fixed_sysclk % props->mclk_fs) { 327 dev_err(rtd->dev, "fixed sysclk %u not divisible by mclk_fs %u\n", 328 fixed_sysclk, props->mclk_fs); 329 ret = -EINVAL; 330 goto codec_err; 331 } 332 ret = snd_pcm_hw_constraint_minmax(substream->runtime, SNDRV_PCM_HW_PARAM_RATE, 333 fixed_rate, fixed_rate); 334 if (ret < 0) 335 goto codec_err; 336 } 337 338 return 0; 339 340 codec_err: 341 for_each_prop_dai_codec(props, i, dai) { 342 if (i >= i2) 343 break; 344 simple_clk_disable(dai); 345 } 346 cpu_err: 347 for_each_prop_dai_cpu(props, i, dai) { 348 if (i >= i1) 349 break; 350 simple_clk_disable(dai); 351 } 352 return ret; 353 } 354 EXPORT_SYMBOL_GPL(simple_util_startup); 355 356 void simple_util_shutdown(struct snd_pcm_substream *substream) 357 { 358 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 359 struct simple_util_priv *priv = snd_soc_card_get_drvdata(rtd->card); 360 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num); 361 struct simple_util_dai *dai; 362 int i; 363 364 for_each_prop_dai_cpu(props, i, dai) { 365 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, i); 366 367 if (props->mclk_fs && !dai->clk_fixed && !snd_soc_dai_active(cpu_dai)) 368 snd_soc_dai_set_sysclk(cpu_dai, 369 0, 0, SND_SOC_CLOCK_OUT); 370 371 simple_clk_disable(dai); 372 } 373 for_each_prop_dai_codec(props, i, dai) { 374 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, i); 375 376 if (props->mclk_fs && !dai->clk_fixed && !snd_soc_dai_active(codec_dai)) 377 snd_soc_dai_set_sysclk(codec_dai, 378 0, 0, SND_SOC_CLOCK_IN); 379 380 simple_clk_disable(dai); 381 } 382 } 383 EXPORT_SYMBOL_GPL(simple_util_shutdown); 384 385 static int simple_set_clk_rate(struct device *dev, 386 struct simple_util_dai *simple_dai, 387 unsigned long rate) 388 { 389 if (!simple_dai) 390 return 0; 391 392 if (simple_dai->clk_fixed && rate != simple_dai->sysclk) { 393 dev_err(dev, "dai %s invalid clock rate %lu\n", simple_dai->name, rate); 394 return -EINVAL; 395 } 396 397 if (!simple_dai->clk) 398 return 0; 399 400 if (clk_get_rate(simple_dai->clk) == rate) 401 return 0; 402 403 return clk_set_rate(simple_dai->clk, rate); 404 } 405 406 static int simple_set_tdm(struct snd_soc_dai *dai, 407 struct simple_util_dai *simple_dai, 408 struct snd_pcm_hw_params *params) 409 { 410 int sample_bits = params_width(params); 411 int slot_width, slot_count; 412 int i, ret; 413 414 if (!simple_dai || !simple_dai->tdm_width_map) 415 return 0; 416 417 slot_width = simple_dai->slot_width; 418 slot_count = simple_dai->slots; 419 420 if (slot_width == 0) 421 slot_width = sample_bits; 422 423 for (i = 0; i < simple_dai->n_tdm_widths; ++i) { 424 if (simple_dai->tdm_width_map[i].sample_bits == sample_bits) { 425 slot_width = simple_dai->tdm_width_map[i].slot_width; 426 slot_count = simple_dai->tdm_width_map[i].slot_count; 427 break; 428 } 429 } 430 431 ret = snd_soc_dai_set_tdm_slot(dai, 432 simple_dai->tx_slot_mask, 433 simple_dai->rx_slot_mask, 434 slot_count, 435 slot_width); 436 if (ret && ret != -ENOTSUPP) { 437 dev_err(dai->dev, "simple-card: set_tdm_slot error: %d\n", ret); 438 return ret; 439 } 440 441 return 0; 442 } 443 444 int simple_util_hw_params(struct snd_pcm_substream *substream, 445 struct snd_pcm_hw_params *params) 446 { 447 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 448 struct simple_util_dai *pdai; 449 struct snd_soc_dai *sdai; 450 struct simple_util_priv *priv = snd_soc_card_get_drvdata(rtd->card); 451 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num); 452 unsigned int mclk, mclk_fs = 0; 453 int i, ret; 454 455 if (props->mclk_fs) 456 mclk_fs = props->mclk_fs; 457 458 if (mclk_fs) { 459 struct snd_soc_component *component; 460 mclk = params_rate(params) * mclk_fs; 461 462 for_each_prop_dai_codec(props, i, pdai) { 463 ret = simple_set_clk_rate(rtd->dev, pdai, mclk); 464 if (ret < 0) 465 return ret; 466 } 467 468 for_each_prop_dai_cpu(props, i, pdai) { 469 ret = simple_set_clk_rate(rtd->dev, pdai, mclk); 470 if (ret < 0) 471 return ret; 472 } 473 474 /* Ensure sysclk is set on all components in case any 475 * (such as platform components) are missed by calls to 476 * snd_soc_dai_set_sysclk. 477 */ 478 for_each_rtd_components(rtd, i, component) { 479 ret = snd_soc_component_set_sysclk(component, 0, 0, 480 mclk, SND_SOC_CLOCK_IN); 481 if (ret && ret != -ENOTSUPP) 482 return ret; 483 } 484 485 for_each_rtd_codec_dais(rtd, i, sdai) { 486 ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_IN); 487 if (ret && ret != -ENOTSUPP) 488 return ret; 489 } 490 491 for_each_rtd_cpu_dais(rtd, i, sdai) { 492 ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_OUT); 493 if (ret && ret != -ENOTSUPP) 494 return ret; 495 } 496 } 497 498 for_each_prop_dai_codec(props, i, pdai) { 499 sdai = snd_soc_rtd_to_codec(rtd, i); 500 ret = simple_set_tdm(sdai, pdai, params); 501 if (ret < 0) 502 return ret; 503 } 504 505 for_each_prop_dai_cpu(props, i, pdai) { 506 sdai = snd_soc_rtd_to_cpu(rtd, i); 507 ret = simple_set_tdm(sdai, pdai, params); 508 if (ret < 0) 509 return ret; 510 } 511 512 return 0; 513 } 514 EXPORT_SYMBOL_GPL(simple_util_hw_params); 515 516 int simple_util_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd, 517 struct snd_pcm_hw_params *params) 518 { 519 struct simple_util_priv *priv = snd_soc_card_get_drvdata(rtd->card); 520 struct simple_dai_props *dai_props = simple_priv_to_props(priv, rtd->num); 521 struct simple_util_data *data = &dai_props->adata; 522 struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 523 struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 524 525 if (data->convert_rate) 526 rate->min = 527 rate->max = data->convert_rate; 528 529 if (data->convert_channels) 530 channels->min = 531 channels->max = data->convert_channels; 532 533 if (data->convert_sample_format) 534 simple_fixup_sample_fmt(data, params); 535 536 return 0; 537 } 538 EXPORT_SYMBOL_GPL(simple_util_be_hw_params_fixup); 539 540 static int simple_init_dai(struct snd_soc_dai *dai, struct simple_util_dai *simple_dai) 541 { 542 int ret; 543 544 if (!simple_dai) 545 return 0; 546 547 if (simple_dai->sysclk) { 548 ret = snd_soc_dai_set_sysclk(dai, 0, simple_dai->sysclk, 549 simple_dai->clk_direction); 550 if (ret && ret != -ENOTSUPP) { 551 dev_err(dai->dev, "simple-card: set_sysclk error\n"); 552 return ret; 553 } 554 } 555 556 if (simple_dai->slots) { 557 ret = snd_soc_dai_set_tdm_slot(dai, 558 simple_dai->tx_slot_mask, 559 simple_dai->rx_slot_mask, 560 simple_dai->slots, 561 simple_dai->slot_width); 562 if (ret && ret != -ENOTSUPP) { 563 dev_err(dai->dev, "simple-card: set_tdm_slot error\n"); 564 return ret; 565 } 566 } 567 568 return 0; 569 } 570 571 static inline int simple_component_is_codec(struct snd_soc_component *component) 572 { 573 return component->driver->endianness; 574 } 575 576 static int simple_init_for_codec2codec(struct snd_soc_pcm_runtime *rtd, 577 struct simple_dai_props *dai_props) 578 { 579 struct snd_soc_dai_link *dai_link = rtd->dai_link; 580 struct snd_soc_component *component; 581 struct snd_soc_pcm_stream *c2c_params; 582 struct snd_pcm_hardware hw; 583 int i, ret, stream; 584 585 /* Do nothing if it already has Codec2Codec settings */ 586 if (dai_link->c2c_params) 587 return 0; 588 589 /* Do nothing if it was DPCM :: BE */ 590 if (dai_link->no_pcm) 591 return 0; 592 593 /* Only Codecs */ 594 for_each_rtd_components(rtd, i, component) { 595 if (!simple_component_is_codec(component)) 596 return 0; 597 } 598 599 /* Assumes the capabilities are the same for all supported streams */ 600 for_each_pcm_streams(stream) { 601 ret = snd_soc_runtime_calc_hw(rtd, &hw, stream); 602 if (ret == 0) 603 break; 604 } 605 606 if (ret < 0) { 607 dev_err(rtd->dev, "simple-card: no valid dai_link params\n"); 608 return ret; 609 } 610 611 c2c_params = devm_kzalloc(rtd->dev, sizeof(*c2c_params), GFP_KERNEL); 612 if (!c2c_params) 613 return -ENOMEM; 614 615 c2c_params->formats = hw.formats; 616 c2c_params->rates = hw.rates; 617 c2c_params->rate_min = hw.rate_min; 618 c2c_params->rate_max = hw.rate_max; 619 c2c_params->channels_min = hw.channels_min; 620 c2c_params->channels_max = hw.channels_max; 621 622 dai_link->c2c_params = c2c_params; 623 dai_link->num_c2c_params = 1; 624 625 return 0; 626 } 627 628 int simple_util_dai_init(struct snd_soc_pcm_runtime *rtd) 629 { 630 struct simple_util_priv *priv = snd_soc_card_get_drvdata(rtd->card); 631 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num); 632 struct simple_util_dai *dai; 633 int i, ret; 634 635 for_each_prop_dai_codec(props, i, dai) { 636 ret = simple_init_dai(snd_soc_rtd_to_codec(rtd, i), dai); 637 if (ret < 0) 638 return ret; 639 } 640 for_each_prop_dai_cpu(props, i, dai) { 641 ret = simple_init_dai(snd_soc_rtd_to_cpu(rtd, i), dai); 642 if (ret < 0) 643 return ret; 644 } 645 646 ret = simple_init_for_codec2codec(rtd, props); 647 if (ret < 0) 648 return ret; 649 650 return 0; 651 } 652 EXPORT_SYMBOL_GPL(simple_util_dai_init); 653 654 void simple_util_canonicalize_platform(struct snd_soc_dai_link_component *platforms, 655 struct snd_soc_dai_link_component *cpus) 656 { 657 /* 658 * Assumes Platform == CPU 659 * 660 * Some CPU might be using soc-generic-dmaengine-pcm. This means CPU and Platform 661 * are different Component, but are sharing same component->dev. 662 * 663 * Let's assume Platform is same as CPU if it doesn't identify Platform on DT. 664 * see 665 * simple-card.c :: simple_count_noml() 666 */ 667 if (!platforms->of_node) 668 snd_soc_dlc_use_cpu_as_platform(platforms, cpus); 669 } 670 EXPORT_SYMBOL_GPL(simple_util_canonicalize_platform); 671 672 void simple_util_canonicalize_cpu(struct snd_soc_dai_link_component *cpus, 673 int is_single_links) 674 { 675 /* 676 * In soc_bind_dai_link() will check cpu name after 677 * of_node matching if dai_link has cpu_dai_name. 678 * but, it will never match if name was created by 679 * fmt_single_name() remove cpu_dai_name if cpu_args 680 * was 0. See: 681 * fmt_single_name() 682 * fmt_multiple_name() 683 */ 684 if (is_single_links) 685 cpus->dai_name = NULL; 686 } 687 EXPORT_SYMBOL_GPL(simple_util_canonicalize_cpu); 688 689 void simple_util_clean_reference(struct snd_soc_card *card) 690 { 691 struct snd_soc_dai_link *dai_link; 692 struct snd_soc_dai_link_component *cpu; 693 struct snd_soc_dai_link_component *codec; 694 int i, j; 695 696 for_each_card_prelinks(card, i, dai_link) { 697 for_each_link_cpus(dai_link, j, cpu) 698 of_node_put(cpu->of_node); 699 for_each_link_codecs(dai_link, j, codec) 700 of_node_put(codec->of_node); 701 } 702 } 703 EXPORT_SYMBOL_GPL(simple_util_clean_reference); 704 705 int simple_util_parse_routing(struct snd_soc_card *card, 706 char *prefix) 707 { 708 struct device_node *node = card->dev->of_node; 709 char prop[128]; 710 711 if (!prefix) 712 prefix = ""; 713 714 snprintf(prop, sizeof(prop), "%s%s", prefix, "routing"); 715 716 if (!of_property_read_bool(node, prop)) 717 return 0; 718 719 return snd_soc_of_parse_audio_routing(card, prop); 720 } 721 EXPORT_SYMBOL_GPL(simple_util_parse_routing); 722 723 int simple_util_parse_widgets(struct snd_soc_card *card, 724 char *prefix) 725 { 726 struct device_node *node = card->dev->of_node; 727 char prop[128]; 728 729 if (!prefix) 730 prefix = ""; 731 732 snprintf(prop, sizeof(prop), "%s%s", prefix, "widgets"); 733 734 if (of_property_read_bool(node, prop)) 735 return snd_soc_of_parse_audio_simple_widgets(card, prop); 736 737 /* no widgets is not error */ 738 return 0; 739 } 740 EXPORT_SYMBOL_GPL(simple_util_parse_widgets); 741 742 int simple_util_parse_pin_switches(struct snd_soc_card *card, 743 char *prefix) 744 { 745 char prop[128]; 746 747 if (!prefix) 748 prefix = ""; 749 750 snprintf(prop, sizeof(prop), "%s%s", prefix, "pin-switches"); 751 752 return snd_soc_of_parse_pin_switches(card, prop); 753 } 754 EXPORT_SYMBOL_GPL(simple_util_parse_pin_switches); 755 756 int simple_util_init_jack(struct snd_soc_card *card, 757 struct simple_util_jack *sjack, 758 int is_hp, char *prefix, 759 char *pin) 760 { 761 struct device *dev = card->dev; 762 struct gpio_desc *desc; 763 char prop[128]; 764 char *pin_name; 765 char *gpio_name; 766 int mask; 767 int error; 768 769 if (!prefix) 770 prefix = ""; 771 772 if (is_hp) { 773 snprintf(prop, sizeof(prop), "%shp-det", prefix); 774 pin_name = pin ? pin : "Headphones"; 775 gpio_name = "Headphone detection"; 776 mask = SND_JACK_HEADPHONE; 777 } else { 778 snprintf(prop, sizeof(prop), "%smic-det", prefix); 779 pin_name = pin ? pin : "Mic Jack"; 780 gpio_name = "Mic detection"; 781 mask = SND_JACK_MICROPHONE; 782 } 783 784 desc = gpiod_get_optional(dev, prop, GPIOD_IN); 785 error = PTR_ERR_OR_ZERO(desc); 786 if (error) 787 return error; 788 789 if (desc) { 790 error = gpiod_set_consumer_name(desc, gpio_name); 791 if (error) 792 return error; 793 794 sjack->pin.pin = pin_name; 795 sjack->pin.mask = mask; 796 797 sjack->gpio.name = gpio_name; 798 sjack->gpio.report = mask; 799 sjack->gpio.desc = desc; 800 sjack->gpio.debounce_time = 150; 801 802 snd_soc_card_jack_new_pins(card, pin_name, mask, &sjack->jack, 803 &sjack->pin, 1); 804 805 snd_soc_jack_add_gpios(&sjack->jack, 1, &sjack->gpio); 806 } 807 808 return 0; 809 } 810 EXPORT_SYMBOL_GPL(simple_util_init_jack); 811 812 int simple_util_init_aux_jacks(struct simple_util_priv *priv, char *prefix) 813 { 814 struct snd_soc_card *card = simple_priv_to_card(priv); 815 struct snd_soc_component *component; 816 int found_jack_index = 0; 817 int type = 0; 818 int num = 0; 819 int ret; 820 821 if (priv->aux_jacks) 822 return 0; 823 824 for_each_card_auxs(card, component) { 825 type = snd_soc_component_get_jack_type(component); 826 if (type > 0) 827 num++; 828 } 829 if (num < 1) 830 return 0; 831 832 priv->aux_jacks = devm_kcalloc(card->dev, num, 833 sizeof(struct snd_soc_jack), GFP_KERNEL); 834 if (!priv->aux_jacks) 835 return -ENOMEM; 836 837 for_each_card_auxs(card, component) { 838 char id[128]; 839 struct snd_soc_jack *jack; 840 841 if (found_jack_index >= num) 842 break; 843 844 type = snd_soc_component_get_jack_type(component); 845 if (type <= 0) 846 continue; 847 848 /* create jack */ 849 jack = &(priv->aux_jacks[found_jack_index++]); 850 snprintf(id, sizeof(id), "%s-jack", component->name); 851 ret = snd_soc_card_jack_new(card, id, type, jack); 852 if (ret) 853 continue; 854 855 (void)snd_soc_component_set_jack(component, jack, NULL); 856 } 857 return 0; 858 } 859 EXPORT_SYMBOL_GPL(simple_util_init_aux_jacks); 860 861 int simple_util_init_priv(struct simple_util_priv *priv, 862 struct link_info *li) 863 { 864 struct snd_soc_card *card = simple_priv_to_card(priv); 865 struct device *dev = simple_priv_to_dev(priv); 866 struct snd_soc_dai_link *dai_link; 867 struct simple_dai_props *dai_props; 868 struct simple_util_dai *dais; 869 struct snd_soc_dai_link_component *dlcs; 870 struct snd_soc_codec_conf *cconf = NULL; 871 int i, dai_num = 0, dlc_num = 0, cnf_num = 0; 872 873 dai_props = devm_kcalloc(dev, li->link, sizeof(*dai_props), GFP_KERNEL); 874 dai_link = devm_kcalloc(dev, li->link, sizeof(*dai_link), GFP_KERNEL); 875 if (!dai_props || !dai_link) 876 return -ENOMEM; 877 878 /* 879 * dais (= CPU+Codec) 880 * dlcs (= CPU+Codec+Platform) 881 */ 882 for (i = 0; i < li->link; i++) { 883 int cc = li->num[i].cpus + li->num[i].codecs; 884 885 dai_num += cc; 886 dlc_num += cc + li->num[i].platforms; 887 888 if (!li->num[i].cpus) 889 cnf_num += li->num[i].codecs; 890 } 891 892 dais = devm_kcalloc(dev, dai_num, sizeof(*dais), GFP_KERNEL); 893 dlcs = devm_kcalloc(dev, dlc_num, sizeof(*dlcs), GFP_KERNEL); 894 if (!dais || !dlcs) 895 return -ENOMEM; 896 897 if (cnf_num) { 898 cconf = devm_kcalloc(dev, cnf_num, sizeof(*cconf), GFP_KERNEL); 899 if (!cconf) 900 return -ENOMEM; 901 } 902 903 dev_dbg(dev, "link %d, dais %d, ccnf %d\n", 904 li->link, dai_num, cnf_num); 905 906 priv->dai_props = dai_props; 907 priv->dai_link = dai_link; 908 priv->dais = dais; 909 priv->dlcs = dlcs; 910 priv->codec_conf = cconf; 911 912 card->dai_link = priv->dai_link; 913 card->num_links = li->link; 914 card->codec_conf = cconf; 915 card->num_configs = cnf_num; 916 917 for (i = 0; i < li->link; i++) { 918 if (li->num[i].cpus) { 919 /* Normal CPU */ 920 dai_link[i].cpus = dlcs; 921 dai_props[i].num.cpus = 922 dai_link[i].num_cpus = li->num[i].cpus; 923 dai_props[i].cpu_dai = dais; 924 925 dlcs += li->num[i].cpus; 926 dais += li->num[i].cpus; 927 } else { 928 /* DPCM Be's CPU = dummy */ 929 dai_link[i].cpus = &snd_soc_dummy_dlc; 930 dai_props[i].num.cpus = 931 dai_link[i].num_cpus = 1; 932 } 933 934 if (li->num[i].codecs) { 935 /* Normal Codec */ 936 dai_link[i].codecs = dlcs; 937 dai_props[i].num.codecs = 938 dai_link[i].num_codecs = li->num[i].codecs; 939 dai_props[i].codec_dai = dais; 940 941 dlcs += li->num[i].codecs; 942 dais += li->num[i].codecs; 943 944 if (!li->num[i].cpus) { 945 /* DPCM Be's Codec */ 946 dai_props[i].codec_conf = cconf; 947 cconf += li->num[i].codecs; 948 } 949 } else { 950 /* DPCM Fe's Codec = dummy */ 951 dai_link[i].codecs = &snd_soc_dummy_dlc; 952 dai_props[i].num.codecs = 953 dai_link[i].num_codecs = 1; 954 } 955 956 if (li->num[i].platforms) { 957 /* Have Platform */ 958 dai_link[i].platforms = dlcs; 959 dai_props[i].num.platforms = 960 dai_link[i].num_platforms = li->num[i].platforms; 961 962 dlcs += li->num[i].platforms; 963 } else { 964 /* Doesn't have Platform */ 965 dai_link[i].platforms = NULL; 966 dai_props[i].num.platforms = 967 dai_link[i].num_platforms = 0; 968 } 969 } 970 971 return 0; 972 } 973 EXPORT_SYMBOL_GPL(simple_util_init_priv); 974 975 void simple_util_remove(struct platform_device *pdev) 976 { 977 struct snd_soc_card *card = platform_get_drvdata(pdev); 978 979 simple_util_clean_reference(card); 980 } 981 EXPORT_SYMBOL_GPL(simple_util_remove); 982 983 int graph_util_card_probe(struct snd_soc_card *card) 984 { 985 struct simple_util_priv *priv = snd_soc_card_get_drvdata(card); 986 int ret; 987 988 ret = simple_util_init_hp(card, &priv->hp_jack, NULL); 989 if (ret < 0) 990 return ret; 991 992 ret = simple_util_init_mic(card, &priv->mic_jack, NULL); 993 if (ret < 0) 994 return ret; 995 996 return 0; 997 } 998 EXPORT_SYMBOL_GPL(graph_util_card_probe); 999 1000 int graph_util_is_ports0(struct device_node *np) 1001 { 1002 struct device_node *port, *ports, *ports0, *top; 1003 int ret; 1004 1005 /* np is "endpoint" or "port" */ 1006 if (of_node_name_eq(np, "endpoint")) { 1007 port = of_get_parent(np); 1008 } else { 1009 port = np; 1010 of_node_get(port); 1011 } 1012 1013 ports = of_get_parent(port); 1014 top = of_get_parent(ports); 1015 ports0 = of_get_child_by_name(top, "ports"); 1016 1017 ret = ports0 == ports; 1018 1019 of_node_put(port); 1020 of_node_put(ports); 1021 of_node_put(ports0); 1022 of_node_put(top); 1023 1024 return ret; 1025 } 1026 EXPORT_SYMBOL_GPL(graph_util_is_ports0); 1027 1028 static int graph_get_dai_id(struct device_node *ep) 1029 { 1030 struct device_node *node; 1031 struct device_node *endpoint; 1032 struct of_endpoint info; 1033 int i, id; 1034 int ret; 1035 1036 /* use driver specified DAI ID if exist */ 1037 ret = snd_soc_get_dai_id(ep); 1038 if (ret != -ENOTSUPP) 1039 return ret; 1040 1041 /* use endpoint/port reg if exist */ 1042 ret = of_graph_parse_endpoint(ep, &info); 1043 if (ret == 0) { 1044 /* 1045 * Because it will count port/endpoint if it doesn't have "reg". 1046 * But, we can't judge whether it has "no reg", or "reg = <0>" 1047 * only of_graph_parse_endpoint(). 1048 * We need to check "reg" property 1049 */ 1050 if (of_property_present(ep, "reg")) 1051 return info.id; 1052 1053 node = of_get_parent(ep); 1054 ret = of_property_present(node, "reg"); 1055 of_node_put(node); 1056 if (ret) 1057 return info.port; 1058 } 1059 node = of_graph_get_port_parent(ep); 1060 1061 /* 1062 * Non HDMI sound case, counting port/endpoint on its DT 1063 * is enough. Let's count it. 1064 */ 1065 i = 0; 1066 id = -1; 1067 for_each_endpoint_of_node(node, endpoint) { 1068 if (endpoint == ep) 1069 id = i; 1070 i++; 1071 } 1072 1073 of_node_put(node); 1074 1075 if (id < 0) 1076 return -ENODEV; 1077 1078 return id; 1079 } 1080 1081 int graph_util_parse_dai(struct device *dev, struct device_node *ep, 1082 struct snd_soc_dai_link_component *dlc, int *is_single_link) 1083 { 1084 struct device_node *node; 1085 struct of_phandle_args args = {}; 1086 struct snd_soc_dai *dai; 1087 int ret; 1088 1089 if (!ep) 1090 return 0; 1091 1092 node = of_graph_get_port_parent(ep); 1093 1094 /* 1095 * Try to find from DAI node 1096 */ 1097 args.np = ep; 1098 dai = snd_soc_get_dai_via_args(&args); 1099 if (dai) { 1100 dlc->dai_name = snd_soc_dai_name_get(dai); 1101 dlc->dai_args = snd_soc_copy_dai_args(dev, &args); 1102 if (!dlc->dai_args) 1103 return -ENOMEM; 1104 1105 goto parse_dai_end; 1106 } 1107 1108 /* Get dai->name */ 1109 args.np = node; 1110 args.args[0] = graph_get_dai_id(ep); 1111 args.args_count = (of_graph_get_endpoint_count(node) > 1); 1112 1113 /* 1114 * FIXME 1115 * 1116 * Here, dlc->dai_name is pointer to CPU/Codec DAI name. 1117 * If user unbinded CPU or Codec driver, but not for Sound Card, 1118 * dlc->dai_name is keeping unbinded CPU or Codec 1119 * driver's pointer. 1120 * 1121 * If user re-bind CPU or Codec driver again, ALSA SoC will try 1122 * to rebind Card via snd_soc_try_rebind_card(), but because of 1123 * above reason, it might can't bind Sound Card. 1124 * Because Sound Card is pointing to released dai_name pointer. 1125 * 1126 * To avoid this rebind Card issue, 1127 * 1) It needs to alloc memory to keep dai_name eventhough 1128 * CPU or Codec driver was unbinded, or 1129 * 2) user need to rebind Sound Card everytime 1130 * if he unbinded CPU or Codec. 1131 */ 1132 ret = snd_soc_get_dlc(&args, dlc); 1133 if (ret < 0) { 1134 of_node_put(node); 1135 return ret; 1136 } 1137 1138 parse_dai_end: 1139 if (is_single_link) 1140 *is_single_link = of_graph_get_endpoint_count(node) == 1; 1141 1142 return 0; 1143 } 1144 EXPORT_SYMBOL_GPL(graph_util_parse_dai); 1145 1146 void graph_util_parse_link_direction(struct device_node *np, 1147 bool *playback_only, bool *capture_only) 1148 { 1149 bool is_playback_only = of_property_read_bool(np, "playback-only"); 1150 bool is_capture_only = of_property_read_bool(np, "capture-only"); 1151 1152 if (is_playback_only) 1153 *playback_only = is_playback_only; 1154 if (is_capture_only) 1155 *capture_only = is_capture_only; 1156 } 1157 EXPORT_SYMBOL_GPL(graph_util_parse_link_direction); 1158 1159 static enum snd_soc_trigger_order 1160 __graph_util_parse_trigger_order(struct simple_util_priv *priv, 1161 struct device_node *np, 1162 const char *prop) 1163 { 1164 u32 val[SND_SOC_TRIGGER_SIZE]; 1165 int ret; 1166 1167 ret = of_property_read_u32_array(np, prop, val, SND_SOC_TRIGGER_SIZE); 1168 if (ret == 0) { 1169 struct device *dev = simple_priv_to_dev(priv); 1170 u32 order = (val[0] << 8) + 1171 (val[1] << 4) + 1172 (val[2]); 1173 1174 switch (order) { 1175 case (SND_SOC_TRIGGER_LINK << 8) + 1176 (SND_SOC_TRIGGER_COMPONENT << 4) + 1177 (SND_SOC_TRIGGER_DAI): 1178 return SND_SOC_TRIGGER_ORDER_DEFAULT; 1179 1180 case (SND_SOC_TRIGGER_LINK << 8) + 1181 (SND_SOC_TRIGGER_DAI << 4) + 1182 (SND_SOC_TRIGGER_COMPONENT): 1183 return SND_SOC_TRIGGER_ORDER_LDC; 1184 1185 default: 1186 dev_err(dev, "unsupported trigger order [0x%x]\n", order); 1187 } 1188 } 1189 1190 /* SND_SOC_TRIGGER_ORDER_MAX means error */ 1191 return SND_SOC_TRIGGER_ORDER_MAX; 1192 } 1193 1194 void graph_util_parse_trigger_order(struct simple_util_priv *priv, 1195 struct device_node *np, 1196 enum snd_soc_trigger_order *trigger_start, 1197 enum snd_soc_trigger_order *trigger_stop) 1198 { 1199 static enum snd_soc_trigger_order order; 1200 1201 /* 1202 * We can use it like below 1203 * 1204 * #include <dt-bindings/sound/audio-graph.h> 1205 * 1206 * link-trigger-order = <SND_SOC_TRIGGER_LINK 1207 * SND_SOC_TRIGGER_COMPONENT 1208 * SND_SOC_TRIGGER_DAI>; 1209 */ 1210 1211 order = __graph_util_parse_trigger_order(priv, np, "link-trigger-order"); 1212 if (order < SND_SOC_TRIGGER_ORDER_MAX) { 1213 *trigger_start = order; 1214 *trigger_stop = order; 1215 } 1216 1217 order = __graph_util_parse_trigger_order(priv, np, "link-trigger-order-start"); 1218 if (order < SND_SOC_TRIGGER_ORDER_MAX) 1219 *trigger_start = order; 1220 1221 order = __graph_util_parse_trigger_order(priv, np, "link-trigger-order-stop"); 1222 if (order < SND_SOC_TRIGGER_ORDER_MAX) 1223 *trigger_stop = order; 1224 1225 return; 1226 } 1227 EXPORT_SYMBOL_GPL(graph_util_parse_trigger_order); 1228 1229 /* Module information */ 1230 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 1231 MODULE_DESCRIPTION("ALSA SoC Simple Card Utils"); 1232 MODULE_LICENSE("GPL v2"); 1233