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 <linux/clk.h> 8 #include <linux/gpio.h> 9 #include <linux/gpio/consumer.h> 10 #include <linux/module.h> 11 #include <linux/of.h> 12 #include <linux/of_graph.h> 13 #include <sound/jack.h> 14 #include <sound/pcm_params.h> 15 #include <sound/simple_card_utils.h> 16 17 static void asoc_simple_fixup_sample_fmt(struct asoc_simple_data *data, 18 struct snd_pcm_hw_params *params) 19 { 20 int i; 21 struct snd_mask *mask = hw_param_mask(params, 22 SNDRV_PCM_HW_PARAM_FORMAT); 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 snd_mask_none(mask); 38 snd_mask_set(mask, of_sample_fmt_table[i].val); 39 break; 40 } 41 } 42 } 43 44 void asoc_simple_parse_convert(struct device_node *np, 45 char *prefix, 46 struct asoc_simple_data *data) 47 { 48 char prop[128]; 49 50 if (!prefix) 51 prefix = ""; 52 53 /* sampling rate convert */ 54 snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-rate"); 55 of_property_read_u32(np, prop, &data->convert_rate); 56 57 /* channels transfer */ 58 snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-channels"); 59 of_property_read_u32(np, prop, &data->convert_channels); 60 61 /* convert sample format */ 62 snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-sample-format"); 63 of_property_read_string(np, prop, &data->convert_sample_format); 64 } 65 EXPORT_SYMBOL_GPL(asoc_simple_parse_convert); 66 67 /** 68 * asoc_simple_is_convert_required() - Query if HW param conversion was requested 69 * @data: Link data. 70 * 71 * Returns true if any HW param conversion was requested for this DAI link with 72 * any "convert-xxx" properties. 73 */ 74 bool asoc_simple_is_convert_required(const struct asoc_simple_data *data) 75 { 76 return data->convert_rate || 77 data->convert_channels || 78 data->convert_sample_format; 79 } 80 EXPORT_SYMBOL_GPL(asoc_simple_is_convert_required); 81 82 int asoc_simple_parse_daifmt(struct device *dev, 83 struct device_node *node, 84 struct device_node *codec, 85 char *prefix, 86 unsigned int *retfmt) 87 { 88 struct device_node *bitclkmaster = NULL; 89 struct device_node *framemaster = NULL; 90 unsigned int daifmt; 91 92 daifmt = snd_soc_daifmt_parse_format(node, prefix); 93 94 snd_soc_daifmt_parse_clock_provider_as_phandle(node, prefix, &bitclkmaster, &framemaster); 95 if (!bitclkmaster && !framemaster) { 96 /* 97 * No dai-link level and master setting was not found from 98 * sound node level, revert back to legacy DT parsing and 99 * take the settings from codec node. 100 */ 101 dev_dbg(dev, "Revert to legacy daifmt parsing\n"); 102 103 daifmt |= snd_soc_daifmt_parse_clock_provider_as_flag(codec, NULL); 104 } else { 105 daifmt |= snd_soc_daifmt_clock_provider_from_bitmap( 106 ((codec == bitclkmaster) << 4) | (codec == framemaster)); 107 } 108 109 of_node_put(bitclkmaster); 110 of_node_put(framemaster); 111 112 *retfmt = daifmt; 113 114 return 0; 115 } 116 EXPORT_SYMBOL_GPL(asoc_simple_parse_daifmt); 117 118 int asoc_simple_parse_tdm_width_map(struct device *dev, struct device_node *np, 119 struct asoc_simple_dai *dai) 120 { 121 u32 *array_values, *p; 122 int n, i, ret; 123 124 if (!of_property_read_bool(np, "dai-tdm-slot-width-map")) 125 return 0; 126 127 n = of_property_count_elems_of_size(np, "dai-tdm-slot-width-map", sizeof(u32)); 128 if (n % 3) { 129 dev_err(dev, "Invalid number of cells for dai-tdm-slot-width-map\n"); 130 return -EINVAL; 131 } 132 133 dai->tdm_width_map = devm_kcalloc(dev, n, sizeof(*dai->tdm_width_map), GFP_KERNEL); 134 if (!dai->tdm_width_map) 135 return -ENOMEM; 136 137 array_values = kcalloc(n, sizeof(*array_values), GFP_KERNEL); 138 if (!array_values) 139 return -ENOMEM; 140 141 ret = of_property_read_u32_array(np, "dai-tdm-slot-width-map", array_values, n); 142 if (ret < 0) { 143 dev_err(dev, "Could not read dai-tdm-slot-width-map: %d\n", ret); 144 goto out; 145 } 146 147 p = array_values; 148 for (i = 0; i < n / 3; ++i) { 149 dai->tdm_width_map[i].sample_bits = *p++; 150 dai->tdm_width_map[i].slot_width = *p++; 151 dai->tdm_width_map[i].slot_count = *p++; 152 } 153 154 dai->n_tdm_widths = i; 155 ret = 0; 156 out: 157 kfree(array_values); 158 159 return ret; 160 } 161 EXPORT_SYMBOL_GPL(asoc_simple_parse_tdm_width_map); 162 163 int asoc_simple_set_dailink_name(struct device *dev, 164 struct snd_soc_dai_link *dai_link, 165 const char *fmt, ...) 166 { 167 va_list ap; 168 char *name = NULL; 169 int ret = -ENOMEM; 170 171 va_start(ap, fmt); 172 name = devm_kvasprintf(dev, GFP_KERNEL, fmt, ap); 173 va_end(ap); 174 175 if (name) { 176 ret = 0; 177 178 dai_link->name = name; 179 dai_link->stream_name = name; 180 } 181 182 return ret; 183 } 184 EXPORT_SYMBOL_GPL(asoc_simple_set_dailink_name); 185 186 int asoc_simple_parse_card_name(struct snd_soc_card *card, 187 char *prefix) 188 { 189 int ret; 190 191 if (!prefix) 192 prefix = ""; 193 194 /* Parse the card name from DT */ 195 ret = snd_soc_of_parse_card_name(card, "label"); 196 if (ret < 0 || !card->name) { 197 char prop[128]; 198 199 snprintf(prop, sizeof(prop), "%sname", prefix); 200 ret = snd_soc_of_parse_card_name(card, prop); 201 if (ret < 0) 202 return ret; 203 } 204 205 if (!card->name && card->dai_link) 206 card->name = card->dai_link->name; 207 208 return 0; 209 } 210 EXPORT_SYMBOL_GPL(asoc_simple_parse_card_name); 211 212 static int asoc_simple_clk_enable(struct asoc_simple_dai *dai) 213 { 214 if (dai) 215 return clk_prepare_enable(dai->clk); 216 217 return 0; 218 } 219 220 static void asoc_simple_clk_disable(struct asoc_simple_dai *dai) 221 { 222 if (dai) 223 clk_disable_unprepare(dai->clk); 224 } 225 226 int asoc_simple_parse_clk(struct device *dev, 227 struct device_node *node, 228 struct asoc_simple_dai *simple_dai, 229 struct snd_soc_dai_link_component *dlc) 230 { 231 struct clk *clk; 232 u32 val; 233 234 /* 235 * Parse dai->sysclk come from "clocks = <&xxx>" 236 * (if system has common clock) 237 * or "system-clock-frequency = <xxx>" 238 * or device's module clock. 239 */ 240 clk = devm_get_clk_from_child(dev, node, NULL); 241 simple_dai->clk_fixed = of_property_read_bool( 242 node, "system-clock-fixed"); 243 if (!IS_ERR(clk)) { 244 simple_dai->sysclk = clk_get_rate(clk); 245 246 simple_dai->clk = clk; 247 } else if (!of_property_read_u32(node, "system-clock-frequency", &val)) { 248 simple_dai->sysclk = val; 249 simple_dai->clk_fixed = true; 250 } else { 251 clk = devm_get_clk_from_child(dev, dlc->of_node, NULL); 252 if (!IS_ERR(clk)) 253 simple_dai->sysclk = clk_get_rate(clk); 254 } 255 256 if (of_property_read_bool(node, "system-clock-direction-out")) 257 simple_dai->clk_direction = SND_SOC_CLOCK_OUT; 258 259 return 0; 260 } 261 EXPORT_SYMBOL_GPL(asoc_simple_parse_clk); 262 263 static int asoc_simple_check_fixed_sysclk(struct device *dev, 264 struct asoc_simple_dai *dai, 265 unsigned int *fixed_sysclk) 266 { 267 if (dai->clk_fixed) { 268 if (*fixed_sysclk && *fixed_sysclk != dai->sysclk) { 269 dev_err(dev, "inconsistent fixed sysclk rates (%u vs %u)\n", 270 *fixed_sysclk, dai->sysclk); 271 return -EINVAL; 272 } 273 *fixed_sysclk = dai->sysclk; 274 } 275 276 return 0; 277 } 278 279 int asoc_simple_startup(struct snd_pcm_substream *substream) 280 { 281 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 282 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card); 283 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num); 284 struct asoc_simple_dai *dai; 285 unsigned int fixed_sysclk = 0; 286 int i1, i2, i; 287 int ret; 288 289 for_each_prop_dai_cpu(props, i1, dai) { 290 ret = asoc_simple_clk_enable(dai); 291 if (ret) 292 goto cpu_err; 293 ret = asoc_simple_check_fixed_sysclk(rtd->dev, dai, &fixed_sysclk); 294 if (ret) 295 goto cpu_err; 296 } 297 298 for_each_prop_dai_codec(props, i2, dai) { 299 ret = asoc_simple_clk_enable(dai); 300 if (ret) 301 goto codec_err; 302 ret = asoc_simple_check_fixed_sysclk(rtd->dev, dai, &fixed_sysclk); 303 if (ret) 304 goto codec_err; 305 } 306 307 if (fixed_sysclk && props->mclk_fs) { 308 unsigned int fixed_rate = fixed_sysclk / props->mclk_fs; 309 310 if (fixed_sysclk % props->mclk_fs) { 311 dev_err(rtd->dev, "fixed sysclk %u not divisible by mclk_fs %u\n", 312 fixed_sysclk, props->mclk_fs); 313 return -EINVAL; 314 } 315 ret = snd_pcm_hw_constraint_minmax(substream->runtime, SNDRV_PCM_HW_PARAM_RATE, 316 fixed_rate, fixed_rate); 317 if (ret) 318 goto codec_err; 319 } 320 321 return 0; 322 323 codec_err: 324 for_each_prop_dai_codec(props, i, dai) { 325 if (i >= i2) 326 break; 327 asoc_simple_clk_disable(dai); 328 } 329 cpu_err: 330 for_each_prop_dai_cpu(props, i, dai) { 331 if (i >= i1) 332 break; 333 asoc_simple_clk_disable(dai); 334 } 335 return ret; 336 } 337 EXPORT_SYMBOL_GPL(asoc_simple_startup); 338 339 void asoc_simple_shutdown(struct snd_pcm_substream *substream) 340 { 341 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 342 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card); 343 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num); 344 struct asoc_simple_dai *dai; 345 int i; 346 347 for_each_prop_dai_cpu(props, i, dai) { 348 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, i); 349 350 if (props->mclk_fs && !dai->clk_fixed && !snd_soc_dai_active(cpu_dai)) 351 snd_soc_dai_set_sysclk(cpu_dai, 352 0, 0, SND_SOC_CLOCK_OUT); 353 354 asoc_simple_clk_disable(dai); 355 } 356 for_each_prop_dai_codec(props, i, dai) { 357 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, i); 358 359 if (props->mclk_fs && !dai->clk_fixed && !snd_soc_dai_active(codec_dai)) 360 snd_soc_dai_set_sysclk(codec_dai, 361 0, 0, SND_SOC_CLOCK_IN); 362 363 asoc_simple_clk_disable(dai); 364 } 365 } 366 EXPORT_SYMBOL_GPL(asoc_simple_shutdown); 367 368 static int asoc_simple_set_clk_rate(struct device *dev, 369 struct asoc_simple_dai *simple_dai, 370 unsigned long rate) 371 { 372 if (!simple_dai) 373 return 0; 374 375 if (simple_dai->clk_fixed && rate != simple_dai->sysclk) { 376 dev_err(dev, "dai %s invalid clock rate %lu\n", simple_dai->name, rate); 377 return -EINVAL; 378 } 379 380 if (!simple_dai->clk) 381 return 0; 382 383 if (clk_get_rate(simple_dai->clk) == rate) 384 return 0; 385 386 return clk_set_rate(simple_dai->clk, rate); 387 } 388 389 static int asoc_simple_set_tdm(struct snd_soc_dai *dai, 390 struct asoc_simple_dai *simple_dai, 391 struct snd_pcm_hw_params *params) 392 { 393 int sample_bits = params_width(params); 394 int slot_width, slot_count; 395 int i, ret; 396 397 if (!simple_dai || !simple_dai->tdm_width_map) 398 return 0; 399 400 slot_width = simple_dai->slot_width; 401 slot_count = simple_dai->slots; 402 403 if (slot_width == 0) 404 slot_width = sample_bits; 405 406 for (i = 0; i < simple_dai->n_tdm_widths; ++i) { 407 if (simple_dai->tdm_width_map[i].sample_bits == sample_bits) { 408 slot_width = simple_dai->tdm_width_map[i].slot_width; 409 slot_count = simple_dai->tdm_width_map[i].slot_count; 410 break; 411 } 412 } 413 414 ret = snd_soc_dai_set_tdm_slot(dai, 415 simple_dai->tx_slot_mask, 416 simple_dai->rx_slot_mask, 417 slot_count, 418 slot_width); 419 if (ret && ret != -ENOTSUPP) { 420 dev_err(dai->dev, "simple-card: set_tdm_slot error: %d\n", ret); 421 return ret; 422 } 423 424 return 0; 425 } 426 427 int asoc_simple_hw_params(struct snd_pcm_substream *substream, 428 struct snd_pcm_hw_params *params) 429 { 430 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 431 struct asoc_simple_dai *pdai; 432 struct snd_soc_dai *sdai; 433 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card); 434 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num); 435 unsigned int mclk, mclk_fs = 0; 436 int i, ret; 437 438 if (props->mclk_fs) 439 mclk_fs = props->mclk_fs; 440 441 if (mclk_fs) { 442 struct snd_soc_component *component; 443 mclk = params_rate(params) * mclk_fs; 444 445 for_each_prop_dai_codec(props, i, pdai) { 446 ret = asoc_simple_set_clk_rate(rtd->dev, pdai, mclk); 447 if (ret < 0) 448 return ret; 449 } 450 451 for_each_prop_dai_cpu(props, i, pdai) { 452 ret = asoc_simple_set_clk_rate(rtd->dev, pdai, mclk); 453 if (ret < 0) 454 return ret; 455 } 456 457 /* Ensure sysclk is set on all components in case any 458 * (such as platform components) are missed by calls to 459 * snd_soc_dai_set_sysclk. 460 */ 461 for_each_rtd_components(rtd, i, component) { 462 ret = snd_soc_component_set_sysclk(component, 0, 0, 463 mclk, SND_SOC_CLOCK_IN); 464 if (ret && ret != -ENOTSUPP) 465 return ret; 466 } 467 468 for_each_rtd_codec_dais(rtd, i, sdai) { 469 ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_IN); 470 if (ret && ret != -ENOTSUPP) 471 return ret; 472 } 473 474 for_each_rtd_cpu_dais(rtd, i, sdai) { 475 ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_OUT); 476 if (ret && ret != -ENOTSUPP) 477 return ret; 478 } 479 } 480 481 for_each_prop_dai_codec(props, i, pdai) { 482 sdai = asoc_rtd_to_codec(rtd, i); 483 ret = asoc_simple_set_tdm(sdai, pdai, params); 484 if (ret < 0) 485 return ret; 486 } 487 488 for_each_prop_dai_cpu(props, i, pdai) { 489 sdai = asoc_rtd_to_cpu(rtd, i); 490 ret = asoc_simple_set_tdm(sdai, pdai, params); 491 if (ret < 0) 492 return ret; 493 } 494 495 return 0; 496 } 497 EXPORT_SYMBOL_GPL(asoc_simple_hw_params); 498 499 int asoc_simple_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd, 500 struct snd_pcm_hw_params *params) 501 { 502 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card); 503 struct simple_dai_props *dai_props = simple_priv_to_props(priv, rtd->num); 504 struct asoc_simple_data *data = &dai_props->adata; 505 struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 506 struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 507 508 if (data->convert_rate) 509 rate->min = 510 rate->max = data->convert_rate; 511 512 if (data->convert_channels) 513 channels->min = 514 channels->max = data->convert_channels; 515 516 if (data->convert_sample_format) 517 asoc_simple_fixup_sample_fmt(data, params); 518 519 return 0; 520 } 521 EXPORT_SYMBOL_GPL(asoc_simple_be_hw_params_fixup); 522 523 static int asoc_simple_init_dai(struct snd_soc_dai *dai, 524 struct asoc_simple_dai *simple_dai) 525 { 526 int ret; 527 528 if (!simple_dai) 529 return 0; 530 531 if (simple_dai->sysclk) { 532 ret = snd_soc_dai_set_sysclk(dai, 0, simple_dai->sysclk, 533 simple_dai->clk_direction); 534 if (ret && ret != -ENOTSUPP) { 535 dev_err(dai->dev, "simple-card: set_sysclk error\n"); 536 return ret; 537 } 538 } 539 540 if (simple_dai->slots) { 541 ret = snd_soc_dai_set_tdm_slot(dai, 542 simple_dai->tx_slot_mask, 543 simple_dai->rx_slot_mask, 544 simple_dai->slots, 545 simple_dai->slot_width); 546 if (ret && ret != -ENOTSUPP) { 547 dev_err(dai->dev, "simple-card: set_tdm_slot error\n"); 548 return ret; 549 } 550 } 551 552 return 0; 553 } 554 555 static inline int asoc_simple_component_is_codec(struct snd_soc_component *component) 556 { 557 return component->driver->endianness; 558 } 559 560 static int asoc_simple_init_for_codec2codec(struct snd_soc_pcm_runtime *rtd, 561 struct simple_dai_props *dai_props) 562 { 563 struct snd_soc_dai_link *dai_link = rtd->dai_link; 564 struct snd_soc_component *component; 565 struct snd_soc_pcm_stream *params; 566 struct snd_pcm_hardware hw; 567 int i, ret, stream; 568 569 /* Do nothing if it already has Codec2Codec settings */ 570 if (dai_link->params) 571 return 0; 572 573 /* Do nothing if it was DPCM :: BE */ 574 if (dai_link->no_pcm) 575 return 0; 576 577 /* Only Codecs */ 578 for_each_rtd_components(rtd, i, component) { 579 if (!asoc_simple_component_is_codec(component)) 580 return 0; 581 } 582 583 /* Assumes the capabilities are the same for all supported streams */ 584 for_each_pcm_streams(stream) { 585 ret = snd_soc_runtime_calc_hw(rtd, &hw, stream); 586 if (ret == 0) 587 break; 588 } 589 590 if (ret < 0) { 591 dev_err(rtd->dev, "simple-card: no valid dai_link params\n"); 592 return ret; 593 } 594 595 params = devm_kzalloc(rtd->dev, sizeof(*params), GFP_KERNEL); 596 if (!params) 597 return -ENOMEM; 598 599 params->formats = hw.formats; 600 params->rates = hw.rates; 601 params->rate_min = hw.rate_min; 602 params->rate_max = hw.rate_max; 603 params->channels_min = hw.channels_min; 604 params->channels_max = hw.channels_max; 605 606 dai_link->params = params; 607 dai_link->num_params = 1; 608 609 return 0; 610 } 611 612 int asoc_simple_dai_init(struct snd_soc_pcm_runtime *rtd) 613 { 614 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card); 615 struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num); 616 struct asoc_simple_dai *dai; 617 int i, ret; 618 619 for_each_prop_dai_codec(props, i, dai) { 620 ret = asoc_simple_init_dai(asoc_rtd_to_codec(rtd, i), dai); 621 if (ret < 0) 622 return ret; 623 } 624 for_each_prop_dai_cpu(props, i, dai) { 625 ret = asoc_simple_init_dai(asoc_rtd_to_cpu(rtd, i), dai); 626 if (ret < 0) 627 return ret; 628 } 629 630 ret = asoc_simple_init_for_codec2codec(rtd, props); 631 if (ret < 0) 632 return ret; 633 634 return 0; 635 } 636 EXPORT_SYMBOL_GPL(asoc_simple_dai_init); 637 638 void asoc_simple_canonicalize_platform(struct snd_soc_dai_link_component *platforms, 639 struct snd_soc_dai_link_component *cpus) 640 { 641 /* Assumes platform == cpu */ 642 if (!platforms->of_node) 643 platforms->of_node = cpus->of_node; 644 } 645 EXPORT_SYMBOL_GPL(asoc_simple_canonicalize_platform); 646 647 void asoc_simple_canonicalize_cpu(struct snd_soc_dai_link_component *cpus, 648 int is_single_links) 649 { 650 /* 651 * In soc_bind_dai_link() will check cpu name after 652 * of_node matching if dai_link has cpu_dai_name. 653 * but, it will never match if name was created by 654 * fmt_single_name() remove cpu_dai_name if cpu_args 655 * was 0. See: 656 * fmt_single_name() 657 * fmt_multiple_name() 658 */ 659 if (is_single_links) 660 cpus->dai_name = NULL; 661 } 662 EXPORT_SYMBOL_GPL(asoc_simple_canonicalize_cpu); 663 664 void asoc_simple_clean_reference(struct snd_soc_card *card) 665 { 666 struct snd_soc_dai_link *dai_link; 667 struct snd_soc_dai_link_component *cpu; 668 struct snd_soc_dai_link_component *codec; 669 int i, j; 670 671 for_each_card_prelinks(card, i, dai_link) { 672 for_each_link_cpus(dai_link, j, cpu) 673 of_node_put(cpu->of_node); 674 for_each_link_codecs(dai_link, j, codec) 675 of_node_put(codec->of_node); 676 } 677 } 678 EXPORT_SYMBOL_GPL(asoc_simple_clean_reference); 679 680 int asoc_simple_parse_routing(struct snd_soc_card *card, 681 char *prefix) 682 { 683 struct device_node *node = card->dev->of_node; 684 char prop[128]; 685 686 if (!prefix) 687 prefix = ""; 688 689 snprintf(prop, sizeof(prop), "%s%s", prefix, "routing"); 690 691 if (!of_property_read_bool(node, prop)) 692 return 0; 693 694 return snd_soc_of_parse_audio_routing(card, prop); 695 } 696 EXPORT_SYMBOL_GPL(asoc_simple_parse_routing); 697 698 int asoc_simple_parse_widgets(struct snd_soc_card *card, 699 char *prefix) 700 { 701 struct device_node *node = card->dev->of_node; 702 char prop[128]; 703 704 if (!prefix) 705 prefix = ""; 706 707 snprintf(prop, sizeof(prop), "%s%s", prefix, "widgets"); 708 709 if (of_property_read_bool(node, prop)) 710 return snd_soc_of_parse_audio_simple_widgets(card, prop); 711 712 /* no widgets is not error */ 713 return 0; 714 } 715 EXPORT_SYMBOL_GPL(asoc_simple_parse_widgets); 716 717 int asoc_simple_parse_pin_switches(struct snd_soc_card *card, 718 char *prefix) 719 { 720 char prop[128]; 721 722 if (!prefix) 723 prefix = ""; 724 725 snprintf(prop, sizeof(prop), "%s%s", prefix, "pin-switches"); 726 727 return snd_soc_of_parse_pin_switches(card, prop); 728 } 729 EXPORT_SYMBOL_GPL(asoc_simple_parse_pin_switches); 730 731 int asoc_simple_init_jack(struct snd_soc_card *card, 732 struct asoc_simple_jack *sjack, 733 int is_hp, char *prefix, 734 char *pin) 735 { 736 struct device *dev = card->dev; 737 struct gpio_desc *desc; 738 char prop[128]; 739 char *pin_name; 740 char *gpio_name; 741 int mask; 742 int error; 743 744 if (!prefix) 745 prefix = ""; 746 747 sjack->gpio.gpio = -ENOENT; 748 749 if (is_hp) { 750 snprintf(prop, sizeof(prop), "%shp-det", prefix); 751 pin_name = pin ? pin : "Headphones"; 752 gpio_name = "Headphone detection"; 753 mask = SND_JACK_HEADPHONE; 754 } else { 755 snprintf(prop, sizeof(prop), "%smic-det", prefix); 756 pin_name = pin ? pin : "Mic Jack"; 757 gpio_name = "Mic detection"; 758 mask = SND_JACK_MICROPHONE; 759 } 760 761 desc = gpiod_get_optional(dev, prop, GPIOD_IN); 762 error = PTR_ERR_OR_ZERO(desc); 763 if (error) 764 return error; 765 766 if (desc) { 767 error = gpiod_set_consumer_name(desc, gpio_name); 768 if (error) 769 return error; 770 771 sjack->pin.pin = pin_name; 772 sjack->pin.mask = mask; 773 774 sjack->gpio.name = gpio_name; 775 sjack->gpio.report = mask; 776 sjack->gpio.desc = desc; 777 sjack->gpio.debounce_time = 150; 778 779 snd_soc_card_jack_new_pins(card, pin_name, mask, &sjack->jack, 780 &sjack->pin, 1); 781 782 snd_soc_jack_add_gpios(&sjack->jack, 1, &sjack->gpio); 783 } 784 785 return 0; 786 } 787 EXPORT_SYMBOL_GPL(asoc_simple_init_jack); 788 789 int asoc_simple_init_aux_jacks(struct asoc_simple_priv *priv, char *prefix) 790 { 791 struct snd_soc_card *card = simple_priv_to_card(priv); 792 struct snd_soc_component *component; 793 int found_jack_index = 0; 794 int type = 0; 795 int num = 0; 796 int ret; 797 798 if (priv->aux_jacks) 799 return 0; 800 801 for_each_card_auxs(card, component) { 802 type = snd_soc_component_get_jack_type(component); 803 if (type > 0) 804 num++; 805 } 806 if (num < 1) 807 return 0; 808 809 priv->aux_jacks = devm_kcalloc(card->dev, num, 810 sizeof(struct snd_soc_jack), GFP_KERNEL); 811 if (!priv->aux_jacks) 812 return -ENOMEM; 813 814 for_each_card_auxs(card, component) { 815 char id[128]; 816 struct snd_soc_jack *jack; 817 818 if (found_jack_index >= num) 819 break; 820 821 type = snd_soc_component_get_jack_type(component); 822 if (type <= 0) 823 continue; 824 825 /* create jack */ 826 jack = &(priv->aux_jacks[found_jack_index++]); 827 snprintf(id, sizeof(id), "%s-jack", component->name); 828 ret = snd_soc_card_jack_new(card, id, type, jack); 829 if (ret) 830 continue; 831 832 (void)snd_soc_component_set_jack(component, jack, NULL); 833 } 834 return 0; 835 } 836 EXPORT_SYMBOL_GPL(asoc_simple_init_aux_jacks); 837 838 int asoc_simple_init_priv(struct asoc_simple_priv *priv, 839 struct link_info *li) 840 { 841 struct snd_soc_card *card = simple_priv_to_card(priv); 842 struct device *dev = simple_priv_to_dev(priv); 843 struct snd_soc_dai_link *dai_link; 844 struct simple_dai_props *dai_props; 845 struct asoc_simple_dai *dais; 846 struct snd_soc_dai_link_component *dlcs; 847 struct snd_soc_codec_conf *cconf = NULL; 848 int i, dai_num = 0, dlc_num = 0, cnf_num = 0; 849 850 dai_props = devm_kcalloc(dev, li->link, sizeof(*dai_props), GFP_KERNEL); 851 dai_link = devm_kcalloc(dev, li->link, sizeof(*dai_link), GFP_KERNEL); 852 if (!dai_props || !dai_link) 853 return -ENOMEM; 854 855 /* 856 * dais (= CPU+Codec) 857 * dlcs (= CPU+Codec+Platform) 858 */ 859 for (i = 0; i < li->link; i++) { 860 int cc = li->num[i].cpus + li->num[i].codecs; 861 862 dai_num += cc; 863 dlc_num += cc + li->num[i].platforms; 864 865 if (!li->num[i].cpus) 866 cnf_num += li->num[i].codecs; 867 } 868 869 dais = devm_kcalloc(dev, dai_num, sizeof(*dais), GFP_KERNEL); 870 dlcs = devm_kcalloc(dev, dlc_num, sizeof(*dlcs), GFP_KERNEL); 871 if (!dais || !dlcs) 872 return -ENOMEM; 873 874 if (cnf_num) { 875 cconf = devm_kcalloc(dev, cnf_num, sizeof(*cconf), GFP_KERNEL); 876 if (!cconf) 877 return -ENOMEM; 878 } 879 880 dev_dbg(dev, "link %d, dais %d, ccnf %d\n", 881 li->link, dai_num, cnf_num); 882 883 /* dummy CPU/Codec */ 884 priv->dummy.of_node = NULL; 885 priv->dummy.dai_name = "snd-soc-dummy-dai"; 886 priv->dummy.name = "snd-soc-dummy"; 887 888 priv->dai_props = dai_props; 889 priv->dai_link = dai_link; 890 priv->dais = dais; 891 priv->dlcs = dlcs; 892 priv->codec_conf = cconf; 893 894 card->dai_link = priv->dai_link; 895 card->num_links = li->link; 896 card->codec_conf = cconf; 897 card->num_configs = cnf_num; 898 899 for (i = 0; i < li->link; i++) { 900 if (li->num[i].cpus) { 901 /* Normal CPU */ 902 dai_props[i].cpus = 903 dai_link[i].cpus = dlcs; 904 dai_props[i].num.cpus = 905 dai_link[i].num_cpus = li->num[i].cpus; 906 dai_props[i].cpu_dai = dais; 907 908 dlcs += li->num[i].cpus; 909 dais += li->num[i].cpus; 910 } else { 911 /* DPCM Be's CPU = dummy */ 912 dai_props[i].cpus = 913 dai_link[i].cpus = &priv->dummy; 914 dai_props[i].num.cpus = 915 dai_link[i].num_cpus = 1; 916 } 917 918 if (li->num[i].codecs) { 919 /* Normal Codec */ 920 dai_props[i].codecs = 921 dai_link[i].codecs = dlcs; 922 dai_props[i].num.codecs = 923 dai_link[i].num_codecs = li->num[i].codecs; 924 dai_props[i].codec_dai = dais; 925 926 dlcs += li->num[i].codecs; 927 dais += li->num[i].codecs; 928 929 if (!li->num[i].cpus) { 930 /* DPCM Be's Codec */ 931 dai_props[i].codec_conf = cconf; 932 cconf += li->num[i].codecs; 933 } 934 } else { 935 /* DPCM Fe's Codec = dummy */ 936 dai_props[i].codecs = 937 dai_link[i].codecs = &priv->dummy; 938 dai_props[i].num.codecs = 939 dai_link[i].num_codecs = 1; 940 } 941 942 if (li->num[i].platforms) { 943 /* Have Platform */ 944 dai_props[i].platforms = 945 dai_link[i].platforms = dlcs; 946 dai_props[i].num.platforms = 947 dai_link[i].num_platforms = li->num[i].platforms; 948 949 dlcs += li->num[i].platforms; 950 } else { 951 /* Doesn't have Platform */ 952 dai_props[i].platforms = 953 dai_link[i].platforms = NULL; 954 dai_props[i].num.platforms = 955 dai_link[i].num_platforms = 0; 956 } 957 } 958 959 return 0; 960 } 961 EXPORT_SYMBOL_GPL(asoc_simple_init_priv); 962 963 int asoc_simple_remove(struct platform_device *pdev) 964 { 965 struct snd_soc_card *card = platform_get_drvdata(pdev); 966 967 asoc_simple_clean_reference(card); 968 969 return 0; 970 } 971 EXPORT_SYMBOL_GPL(asoc_simple_remove); 972 973 int asoc_graph_card_probe(struct snd_soc_card *card) 974 { 975 struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(card); 976 int ret; 977 978 ret = asoc_simple_init_hp(card, &priv->hp_jack, NULL); 979 if (ret < 0) 980 return ret; 981 982 ret = asoc_simple_init_mic(card, &priv->mic_jack, NULL); 983 if (ret < 0) 984 return ret; 985 986 return 0; 987 } 988 EXPORT_SYMBOL_GPL(asoc_graph_card_probe); 989 990 int asoc_graph_is_ports0(struct device_node *np) 991 { 992 struct device_node *port, *ports, *ports0, *top; 993 int ret; 994 995 /* np is "endpoint" or "port" */ 996 if (of_node_name_eq(np, "endpoint")) { 997 port = of_get_parent(np); 998 } else { 999 port = np; 1000 of_node_get(port); 1001 } 1002 1003 ports = of_get_parent(port); 1004 top = of_get_parent(ports); 1005 ports0 = of_get_child_by_name(top, "ports"); 1006 1007 ret = ports0 == ports; 1008 1009 of_node_put(port); 1010 of_node_put(ports); 1011 of_node_put(ports0); 1012 of_node_put(top); 1013 1014 return ret; 1015 } 1016 EXPORT_SYMBOL_GPL(asoc_graph_is_ports0); 1017 1018 /* Module information */ 1019 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 1020 MODULE_DESCRIPTION("ALSA SoC Simple Card Utils"); 1021 MODULE_LICENSE("GPL v2"); 1022