1 /* 2 * soc-dapm.c -- ALSA SoC Dynamic Audio Power Management 3 * 4 * Copyright 2005 Wolfson Microelectronics PLC. 5 * Author: Liam Girdwood <lrg@slimlogic.co.uk> 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License as published by the 9 * Free Software Foundation; either version 2 of the License, or (at your 10 * option) any later version. 11 * 12 * Features: 13 * o Changes power status of internal codec blocks depending on the 14 * dynamic configuration of codec internal audio paths and active 15 * DACs/ADCs. 16 * o Platform power domain - can support external components i.e. amps and 17 * mic/headphone insertion events. 18 * o Automatic Mic Bias support 19 * o Jack insertion power event initiation - e.g. hp insertion will enable 20 * sinks, dacs, etc 21 * o Delayed power down of audio subsystem to reduce pops between a quick 22 * device reopen. 23 * 24 */ 25 26 #include <linux/module.h> 27 #include <linux/moduleparam.h> 28 #include <linux/init.h> 29 #include <linux/async.h> 30 #include <linux/delay.h> 31 #include <linux/pm.h> 32 #include <linux/bitops.h> 33 #include <linux/platform_device.h> 34 #include <linux/jiffies.h> 35 #include <linux/debugfs.h> 36 #include <linux/pm_runtime.h> 37 #include <linux/regulator/consumer.h> 38 #include <linux/clk.h> 39 #include <linux/slab.h> 40 #include <sound/core.h> 41 #include <sound/pcm.h> 42 #include <sound/pcm_params.h> 43 #include <sound/soc.h> 44 #include <sound/initval.h> 45 46 #include <trace/events/asoc.h> 47 48 #define DAPM_UPDATE_STAT(widget, val) widget->dapm->card->dapm_stats.val++; 49 50 static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm, 51 struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink, 52 const char *control, 53 int (*connected)(struct snd_soc_dapm_widget *source, 54 struct snd_soc_dapm_widget *sink)); 55 static struct snd_soc_dapm_widget * 56 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm, 57 const struct snd_soc_dapm_widget *widget); 58 59 /* dapm power sequences - make this per codec in the future */ 60 static int dapm_up_seq[] = { 61 [snd_soc_dapm_pre] = 0, 62 [snd_soc_dapm_regulator_supply] = 1, 63 [snd_soc_dapm_clock_supply] = 1, 64 [snd_soc_dapm_supply] = 2, 65 [snd_soc_dapm_micbias] = 3, 66 [snd_soc_dapm_dai_link] = 2, 67 [snd_soc_dapm_dai_in] = 4, 68 [snd_soc_dapm_dai_out] = 4, 69 [snd_soc_dapm_aif_in] = 4, 70 [snd_soc_dapm_aif_out] = 4, 71 [snd_soc_dapm_mic] = 5, 72 [snd_soc_dapm_mux] = 6, 73 [snd_soc_dapm_dac] = 7, 74 [snd_soc_dapm_switch] = 8, 75 [snd_soc_dapm_mixer] = 8, 76 [snd_soc_dapm_mixer_named_ctl] = 8, 77 [snd_soc_dapm_pga] = 9, 78 [snd_soc_dapm_adc] = 10, 79 [snd_soc_dapm_out_drv] = 11, 80 [snd_soc_dapm_hp] = 11, 81 [snd_soc_dapm_spk] = 11, 82 [snd_soc_dapm_line] = 11, 83 [snd_soc_dapm_kcontrol] = 12, 84 [snd_soc_dapm_post] = 13, 85 }; 86 87 static int dapm_down_seq[] = { 88 [snd_soc_dapm_pre] = 0, 89 [snd_soc_dapm_kcontrol] = 1, 90 [snd_soc_dapm_adc] = 2, 91 [snd_soc_dapm_hp] = 3, 92 [snd_soc_dapm_spk] = 3, 93 [snd_soc_dapm_line] = 3, 94 [snd_soc_dapm_out_drv] = 3, 95 [snd_soc_dapm_pga] = 4, 96 [snd_soc_dapm_switch] = 5, 97 [snd_soc_dapm_mixer_named_ctl] = 5, 98 [snd_soc_dapm_mixer] = 5, 99 [snd_soc_dapm_dac] = 6, 100 [snd_soc_dapm_mic] = 7, 101 [snd_soc_dapm_micbias] = 8, 102 [snd_soc_dapm_mux] = 9, 103 [snd_soc_dapm_aif_in] = 10, 104 [snd_soc_dapm_aif_out] = 10, 105 [snd_soc_dapm_dai_in] = 10, 106 [snd_soc_dapm_dai_out] = 10, 107 [snd_soc_dapm_dai_link] = 11, 108 [snd_soc_dapm_supply] = 12, 109 [snd_soc_dapm_clock_supply] = 13, 110 [snd_soc_dapm_regulator_supply] = 13, 111 [snd_soc_dapm_post] = 14, 112 }; 113 114 static void dapm_assert_locked(struct snd_soc_dapm_context *dapm) 115 { 116 if (dapm->card && dapm->card->instantiated) 117 lockdep_assert_held(&dapm->card->dapm_mutex); 118 } 119 120 static void pop_wait(u32 pop_time) 121 { 122 if (pop_time) 123 schedule_timeout_uninterruptible(msecs_to_jiffies(pop_time)); 124 } 125 126 static void pop_dbg(struct device *dev, u32 pop_time, const char *fmt, ...) 127 { 128 va_list args; 129 char *buf; 130 131 if (!pop_time) 132 return; 133 134 buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 135 if (buf == NULL) 136 return; 137 138 va_start(args, fmt); 139 vsnprintf(buf, PAGE_SIZE, fmt, args); 140 dev_info(dev, "%s", buf); 141 va_end(args); 142 143 kfree(buf); 144 } 145 146 static bool dapm_dirty_widget(struct snd_soc_dapm_widget *w) 147 { 148 return !list_empty(&w->dirty); 149 } 150 151 static void dapm_mark_dirty(struct snd_soc_dapm_widget *w, const char *reason) 152 { 153 dapm_assert_locked(w->dapm); 154 155 if (!dapm_dirty_widget(w)) { 156 dev_vdbg(w->dapm->dev, "Marking %s dirty due to %s\n", 157 w->name, reason); 158 list_add_tail(&w->dirty, &w->dapm->card->dapm_dirty); 159 } 160 } 161 162 void dapm_mark_io_dirty(struct snd_soc_dapm_context *dapm) 163 { 164 struct snd_soc_card *card = dapm->card; 165 struct snd_soc_dapm_widget *w; 166 167 mutex_lock(&card->dapm_mutex); 168 169 list_for_each_entry(w, &card->widgets, list) { 170 switch (w->id) { 171 case snd_soc_dapm_input: 172 case snd_soc_dapm_output: 173 dapm_mark_dirty(w, "Rechecking inputs and outputs"); 174 break; 175 default: 176 break; 177 } 178 } 179 180 mutex_unlock(&card->dapm_mutex); 181 } 182 EXPORT_SYMBOL_GPL(dapm_mark_io_dirty); 183 184 /* create a new dapm widget */ 185 static inline struct snd_soc_dapm_widget *dapm_cnew_widget( 186 const struct snd_soc_dapm_widget *_widget) 187 { 188 return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL); 189 } 190 191 struct dapm_kcontrol_data { 192 unsigned int value; 193 struct snd_soc_dapm_widget *widget; 194 struct list_head paths; 195 struct snd_soc_dapm_widget_list *wlist; 196 }; 197 198 static int dapm_kcontrol_data_alloc(struct snd_soc_dapm_widget *widget, 199 struct snd_kcontrol *kcontrol) 200 { 201 struct dapm_kcontrol_data *data; 202 struct soc_mixer_control *mc; 203 204 data = kzalloc(sizeof(*data), GFP_KERNEL); 205 if (!data) { 206 dev_err(widget->dapm->dev, 207 "ASoC: can't allocate kcontrol data for %s\n", 208 widget->name); 209 return -ENOMEM; 210 } 211 212 INIT_LIST_HEAD(&data->paths); 213 214 switch (widget->id) { 215 case snd_soc_dapm_switch: 216 case snd_soc_dapm_mixer: 217 case snd_soc_dapm_mixer_named_ctl: 218 mc = (struct soc_mixer_control *)kcontrol->private_value; 219 220 if (mc->autodisable) { 221 struct snd_soc_dapm_widget template; 222 223 memset(&template, 0, sizeof(template)); 224 template.reg = mc->reg; 225 template.mask = (1 << fls(mc->max)) - 1; 226 template.shift = mc->shift; 227 if (mc->invert) 228 template.off_val = mc->max; 229 else 230 template.off_val = 0; 231 template.on_val = template.off_val; 232 template.id = snd_soc_dapm_kcontrol; 233 template.name = kcontrol->id.name; 234 235 data->value = template.on_val; 236 237 data->widget = snd_soc_dapm_new_control(widget->dapm, 238 &template); 239 if (!data->widget) { 240 kfree(data); 241 return -ENOMEM; 242 } 243 } 244 break; 245 default: 246 break; 247 } 248 249 kcontrol->private_data = data; 250 251 return 0; 252 } 253 254 static void dapm_kcontrol_free(struct snd_kcontrol *kctl) 255 { 256 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kctl); 257 kfree(data->wlist); 258 kfree(data); 259 } 260 261 static struct snd_soc_dapm_widget_list *dapm_kcontrol_get_wlist( 262 const struct snd_kcontrol *kcontrol) 263 { 264 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol); 265 266 return data->wlist; 267 } 268 269 static int dapm_kcontrol_add_widget(struct snd_kcontrol *kcontrol, 270 struct snd_soc_dapm_widget *widget) 271 { 272 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol); 273 struct snd_soc_dapm_widget_list *new_wlist; 274 unsigned int n; 275 276 if (data->wlist) 277 n = data->wlist->num_widgets + 1; 278 else 279 n = 1; 280 281 new_wlist = krealloc(data->wlist, 282 sizeof(*new_wlist) + sizeof(widget) * n, GFP_KERNEL); 283 if (!new_wlist) 284 return -ENOMEM; 285 286 new_wlist->widgets[n - 1] = widget; 287 new_wlist->num_widgets = n; 288 289 data->wlist = new_wlist; 290 291 return 0; 292 } 293 294 static void dapm_kcontrol_add_path(const struct snd_kcontrol *kcontrol, 295 struct snd_soc_dapm_path *path) 296 { 297 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol); 298 299 list_add_tail(&path->list_kcontrol, &data->paths); 300 301 if (data->widget) { 302 snd_soc_dapm_add_path(data->widget->dapm, data->widget, 303 path->source, NULL, NULL); 304 } 305 } 306 307 static bool dapm_kcontrol_is_powered(const struct snd_kcontrol *kcontrol) 308 { 309 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol); 310 311 if (!data->widget) 312 return true; 313 314 return data->widget->power; 315 } 316 317 static struct list_head *dapm_kcontrol_get_path_list( 318 const struct snd_kcontrol *kcontrol) 319 { 320 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol); 321 322 return &data->paths; 323 } 324 325 #define dapm_kcontrol_for_each_path(path, kcontrol) \ 326 list_for_each_entry(path, dapm_kcontrol_get_path_list(kcontrol), \ 327 list_kcontrol) 328 329 static unsigned int dapm_kcontrol_get_value(const struct snd_kcontrol *kcontrol) 330 { 331 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol); 332 333 return data->value; 334 } 335 336 static bool dapm_kcontrol_set_value(const struct snd_kcontrol *kcontrol, 337 unsigned int value) 338 { 339 struct dapm_kcontrol_data *data = snd_kcontrol_chip(kcontrol); 340 341 if (data->value == value) 342 return false; 343 344 if (data->widget) 345 data->widget->on_val = value; 346 347 data->value = value; 348 349 return true; 350 } 351 352 /** 353 * snd_soc_dapm_kcontrol_codec() - Returns the codec associated to a kcontrol 354 * @kcontrol: The kcontrol 355 */ 356 struct snd_soc_codec *snd_soc_dapm_kcontrol_codec(struct snd_kcontrol *kcontrol) 357 { 358 return dapm_kcontrol_get_wlist(kcontrol)->widgets[0]->codec; 359 } 360 EXPORT_SYMBOL_GPL(snd_soc_dapm_kcontrol_codec); 361 362 static void dapm_reset(struct snd_soc_card *card) 363 { 364 struct snd_soc_dapm_widget *w; 365 366 lockdep_assert_held(&card->dapm_mutex); 367 368 memset(&card->dapm_stats, 0, sizeof(card->dapm_stats)); 369 370 list_for_each_entry(w, &card->widgets, list) { 371 w->new_power = w->power; 372 w->power_checked = false; 373 w->inputs = -1; 374 w->outputs = -1; 375 } 376 } 377 378 static int soc_widget_read(struct snd_soc_dapm_widget *w, int reg, 379 unsigned int *value) 380 { 381 if (w->codec) { 382 *value = snd_soc_read(w->codec, reg); 383 return 0; 384 } else if (w->platform) { 385 *value = snd_soc_platform_read(w->platform, reg); 386 return 0; 387 } 388 389 dev_err(w->dapm->dev, "ASoC: no valid widget read method\n"); 390 return -1; 391 } 392 393 static int soc_widget_write(struct snd_soc_dapm_widget *w, int reg, 394 unsigned int val) 395 { 396 if (w->codec) 397 return snd_soc_write(w->codec, reg, val); 398 else if (w->platform) 399 return snd_soc_platform_write(w->platform, reg, val); 400 401 dev_err(w->dapm->dev, "ASoC: no valid widget write method\n"); 402 return -1; 403 } 404 405 static inline void soc_widget_lock(struct snd_soc_dapm_widget *w) 406 { 407 if (w->codec && !w->codec->using_regmap) 408 mutex_lock(&w->codec->mutex); 409 else if (w->platform) 410 mutex_lock(&w->platform->mutex); 411 } 412 413 static inline void soc_widget_unlock(struct snd_soc_dapm_widget *w) 414 { 415 if (w->codec && !w->codec->using_regmap) 416 mutex_unlock(&w->codec->mutex); 417 else if (w->platform) 418 mutex_unlock(&w->platform->mutex); 419 } 420 421 static void soc_dapm_async_complete(struct snd_soc_dapm_context *dapm) 422 { 423 if (dapm->codec && dapm->codec->using_regmap) 424 regmap_async_complete(dapm->codec->control_data); 425 } 426 427 static int soc_widget_update_bits_locked(struct snd_soc_dapm_widget *w, 428 unsigned short reg, unsigned int mask, unsigned int value) 429 { 430 bool change; 431 unsigned int old, new; 432 int ret; 433 434 if (w->codec && w->codec->using_regmap) { 435 ret = regmap_update_bits_check_async(w->codec->control_data, 436 reg, mask, value, 437 &change); 438 if (ret != 0) 439 return ret; 440 } else { 441 soc_widget_lock(w); 442 ret = soc_widget_read(w, reg, &old); 443 if (ret < 0) { 444 soc_widget_unlock(w); 445 return ret; 446 } 447 448 new = (old & ~mask) | (value & mask); 449 change = old != new; 450 if (change) { 451 ret = soc_widget_write(w, reg, new); 452 if (ret < 0) { 453 soc_widget_unlock(w); 454 return ret; 455 } 456 } 457 soc_widget_unlock(w); 458 } 459 460 return change; 461 } 462 463 /** 464 * snd_soc_dapm_set_bias_level - set the bias level for the system 465 * @dapm: DAPM context 466 * @level: level to configure 467 * 468 * Configure the bias (power) levels for the SoC audio device. 469 * 470 * Returns 0 for success else error. 471 */ 472 static int snd_soc_dapm_set_bias_level(struct snd_soc_dapm_context *dapm, 473 enum snd_soc_bias_level level) 474 { 475 struct snd_soc_card *card = dapm->card; 476 int ret = 0; 477 478 trace_snd_soc_bias_level_start(card, level); 479 480 if (card && card->set_bias_level) 481 ret = card->set_bias_level(card, dapm, level); 482 if (ret != 0) 483 goto out; 484 485 if (dapm->codec) { 486 if (dapm->codec->driver->set_bias_level) 487 ret = dapm->codec->driver->set_bias_level(dapm->codec, 488 level); 489 else 490 dapm->bias_level = level; 491 } else if (!card || dapm != &card->dapm) { 492 dapm->bias_level = level; 493 } 494 495 if (ret != 0) 496 goto out; 497 498 if (card && card->set_bias_level_post) 499 ret = card->set_bias_level_post(card, dapm, level); 500 out: 501 trace_snd_soc_bias_level_done(card, level); 502 503 return ret; 504 } 505 506 /* connect mux widget to its interconnecting audio paths */ 507 static int dapm_connect_mux(struct snd_soc_dapm_context *dapm, 508 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest, 509 struct snd_soc_dapm_path *path, const char *control_name, 510 const struct snd_kcontrol_new *kcontrol) 511 { 512 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 513 unsigned int val, item; 514 int i; 515 516 if (e->reg != SND_SOC_NOPM) { 517 soc_widget_read(dest, e->reg, &val); 518 val = (val >> e->shift_l) & e->mask; 519 item = snd_soc_enum_val_to_item(e, val); 520 } else { 521 /* since a virtual mux has no backing registers to 522 * decide which path to connect, it will try to match 523 * with the first enumeration. This is to ensure 524 * that the default mux choice (the first) will be 525 * correctly powered up during initialization. 526 */ 527 item = 0; 528 } 529 530 for (i = 0; i < e->items; i++) { 531 if (!(strcmp(control_name, e->texts[i]))) { 532 list_add(&path->list, &dapm->card->paths); 533 list_add(&path->list_sink, &dest->sources); 534 list_add(&path->list_source, &src->sinks); 535 path->name = (char*)e->texts[i]; 536 if (i == item) 537 path->connect = 1; 538 else 539 path->connect = 0; 540 return 0; 541 } 542 } 543 544 return -ENODEV; 545 } 546 547 /* set up initial codec paths */ 548 static void dapm_set_mixer_path_status(struct snd_soc_dapm_widget *w, 549 struct snd_soc_dapm_path *p, int i) 550 { 551 struct soc_mixer_control *mc = (struct soc_mixer_control *) 552 w->kcontrol_news[i].private_value; 553 unsigned int reg = mc->reg; 554 unsigned int shift = mc->shift; 555 unsigned int max = mc->max; 556 unsigned int mask = (1 << fls(max)) - 1; 557 unsigned int invert = mc->invert; 558 unsigned int val; 559 560 if (reg != SND_SOC_NOPM) { 561 soc_widget_read(w, reg, &val); 562 val = (val >> shift) & mask; 563 if (invert) 564 val = max - val; 565 p->connect = !!val; 566 } else { 567 p->connect = 0; 568 } 569 } 570 571 /* connect mixer widget to its interconnecting audio paths */ 572 static int dapm_connect_mixer(struct snd_soc_dapm_context *dapm, 573 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest, 574 struct snd_soc_dapm_path *path, const char *control_name) 575 { 576 int i; 577 578 /* search for mixer kcontrol */ 579 for (i = 0; i < dest->num_kcontrols; i++) { 580 if (!strcmp(control_name, dest->kcontrol_news[i].name)) { 581 list_add(&path->list, &dapm->card->paths); 582 list_add(&path->list_sink, &dest->sources); 583 list_add(&path->list_source, &src->sinks); 584 path->name = dest->kcontrol_news[i].name; 585 dapm_set_mixer_path_status(dest, path, i); 586 return 0; 587 } 588 } 589 return -ENODEV; 590 } 591 592 static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm, 593 struct snd_soc_dapm_widget *kcontrolw, 594 const struct snd_kcontrol_new *kcontrol_new, 595 struct snd_kcontrol **kcontrol) 596 { 597 struct snd_soc_dapm_widget *w; 598 int i; 599 600 *kcontrol = NULL; 601 602 list_for_each_entry(w, &dapm->card->widgets, list) { 603 if (w == kcontrolw || w->dapm != kcontrolw->dapm) 604 continue; 605 for (i = 0; i < w->num_kcontrols; i++) { 606 if (&w->kcontrol_news[i] == kcontrol_new) { 607 if (w->kcontrols) 608 *kcontrol = w->kcontrols[i]; 609 return 1; 610 } 611 } 612 } 613 614 return 0; 615 } 616 617 /* 618 * Determine if a kcontrol is shared. If it is, look it up. If it isn't, 619 * create it. Either way, add the widget into the control's widget list 620 */ 621 static int dapm_create_or_share_mixmux_kcontrol(struct snd_soc_dapm_widget *w, 622 int kci) 623 { 624 struct snd_soc_dapm_context *dapm = w->dapm; 625 struct snd_card *card = dapm->card->snd_card; 626 const char *prefix; 627 size_t prefix_len; 628 int shared; 629 struct snd_kcontrol *kcontrol; 630 bool wname_in_long_name, kcname_in_long_name; 631 char *long_name; 632 const char *name; 633 int ret; 634 635 if (dapm->codec) 636 prefix = dapm->codec->name_prefix; 637 else 638 prefix = NULL; 639 640 if (prefix) 641 prefix_len = strlen(prefix) + 1; 642 else 643 prefix_len = 0; 644 645 shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci], 646 &kcontrol); 647 648 if (!kcontrol) { 649 if (shared) { 650 wname_in_long_name = false; 651 kcname_in_long_name = true; 652 } else { 653 switch (w->id) { 654 case snd_soc_dapm_switch: 655 case snd_soc_dapm_mixer: 656 wname_in_long_name = true; 657 kcname_in_long_name = true; 658 break; 659 case snd_soc_dapm_mixer_named_ctl: 660 wname_in_long_name = false; 661 kcname_in_long_name = true; 662 break; 663 case snd_soc_dapm_mux: 664 wname_in_long_name = true; 665 kcname_in_long_name = false; 666 break; 667 default: 668 return -EINVAL; 669 } 670 } 671 672 if (wname_in_long_name && kcname_in_long_name) { 673 /* 674 * The control will get a prefix from the control 675 * creation process but we're also using the same 676 * prefix for widgets so cut the prefix off the 677 * front of the widget name. 678 */ 679 long_name = kasprintf(GFP_KERNEL, "%s %s", 680 w->name + prefix_len, 681 w->kcontrol_news[kci].name); 682 if (long_name == NULL) 683 return -ENOMEM; 684 685 name = long_name; 686 } else if (wname_in_long_name) { 687 long_name = NULL; 688 name = w->name + prefix_len; 689 } else { 690 long_name = NULL; 691 name = w->kcontrol_news[kci].name; 692 } 693 694 kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], NULL, name, 695 prefix); 696 kfree(long_name); 697 if (!kcontrol) 698 return -ENOMEM; 699 kcontrol->private_free = dapm_kcontrol_free; 700 701 ret = dapm_kcontrol_data_alloc(w, kcontrol); 702 if (ret) { 703 snd_ctl_free_one(kcontrol); 704 return ret; 705 } 706 707 ret = snd_ctl_add(card, kcontrol); 708 if (ret < 0) { 709 dev_err(dapm->dev, 710 "ASoC: failed to add widget %s dapm kcontrol %s: %d\n", 711 w->name, name, ret); 712 return ret; 713 } 714 } 715 716 ret = dapm_kcontrol_add_widget(kcontrol, w); 717 if (ret) 718 return ret; 719 720 w->kcontrols[kci] = kcontrol; 721 722 return 0; 723 } 724 725 /* create new dapm mixer control */ 726 static int dapm_new_mixer(struct snd_soc_dapm_widget *w) 727 { 728 int i, ret; 729 struct snd_soc_dapm_path *path; 730 731 /* add kcontrol */ 732 for (i = 0; i < w->num_kcontrols; i++) { 733 /* match name */ 734 list_for_each_entry(path, &w->sources, list_sink) { 735 /* mixer/mux paths name must match control name */ 736 if (path->name != (char *)w->kcontrol_news[i].name) 737 continue; 738 739 if (w->kcontrols[i]) { 740 dapm_kcontrol_add_path(w->kcontrols[i], path); 741 continue; 742 } 743 744 ret = dapm_create_or_share_mixmux_kcontrol(w, i); 745 if (ret < 0) 746 return ret; 747 748 dapm_kcontrol_add_path(w->kcontrols[i], path); 749 } 750 } 751 752 return 0; 753 } 754 755 /* create new dapm mux control */ 756 static int dapm_new_mux(struct snd_soc_dapm_widget *w) 757 { 758 struct snd_soc_dapm_context *dapm = w->dapm; 759 struct snd_soc_dapm_path *path; 760 int ret; 761 762 if (w->num_kcontrols != 1) { 763 dev_err(dapm->dev, 764 "ASoC: mux %s has incorrect number of controls\n", 765 w->name); 766 return -EINVAL; 767 } 768 769 if (list_empty(&w->sources)) { 770 dev_err(dapm->dev, "ASoC: mux %s has no paths\n", w->name); 771 return -EINVAL; 772 } 773 774 ret = dapm_create_or_share_mixmux_kcontrol(w, 0); 775 if (ret < 0) 776 return ret; 777 778 list_for_each_entry(path, &w->sources, list_sink) 779 dapm_kcontrol_add_path(w->kcontrols[0], path); 780 781 return 0; 782 } 783 784 /* create new dapm volume control */ 785 static int dapm_new_pga(struct snd_soc_dapm_widget *w) 786 { 787 if (w->num_kcontrols) 788 dev_err(w->dapm->dev, 789 "ASoC: PGA controls not supported: '%s'\n", w->name); 790 791 return 0; 792 } 793 794 /* reset 'walked' bit for each dapm path */ 795 static void dapm_clear_walk_output(struct snd_soc_dapm_context *dapm, 796 struct list_head *sink) 797 { 798 struct snd_soc_dapm_path *p; 799 800 list_for_each_entry(p, sink, list_source) { 801 if (p->walked) { 802 p->walked = 0; 803 dapm_clear_walk_output(dapm, &p->sink->sinks); 804 } 805 } 806 } 807 808 static void dapm_clear_walk_input(struct snd_soc_dapm_context *dapm, 809 struct list_head *source) 810 { 811 struct snd_soc_dapm_path *p; 812 813 list_for_each_entry(p, source, list_sink) { 814 if (p->walked) { 815 p->walked = 0; 816 dapm_clear_walk_input(dapm, &p->source->sources); 817 } 818 } 819 } 820 821 822 /* We implement power down on suspend by checking the power state of 823 * the ALSA card - when we are suspending the ALSA state for the card 824 * is set to D3. 825 */ 826 static int snd_soc_dapm_suspend_check(struct snd_soc_dapm_widget *widget) 827 { 828 int level = snd_power_get_state(widget->dapm->card->snd_card); 829 830 switch (level) { 831 case SNDRV_CTL_POWER_D3hot: 832 case SNDRV_CTL_POWER_D3cold: 833 if (widget->ignore_suspend) 834 dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n", 835 widget->name); 836 return widget->ignore_suspend; 837 default: 838 return 1; 839 } 840 } 841 842 /* add widget to list if it's not already in the list */ 843 static int dapm_list_add_widget(struct snd_soc_dapm_widget_list **list, 844 struct snd_soc_dapm_widget *w) 845 { 846 struct snd_soc_dapm_widget_list *wlist; 847 int wlistsize, wlistentries, i; 848 849 if (*list == NULL) 850 return -EINVAL; 851 852 wlist = *list; 853 854 /* is this widget already in the list */ 855 for (i = 0; i < wlist->num_widgets; i++) { 856 if (wlist->widgets[i] == w) 857 return 0; 858 } 859 860 /* allocate some new space */ 861 wlistentries = wlist->num_widgets + 1; 862 wlistsize = sizeof(struct snd_soc_dapm_widget_list) + 863 wlistentries * sizeof(struct snd_soc_dapm_widget *); 864 *list = krealloc(wlist, wlistsize, GFP_KERNEL); 865 if (*list == NULL) { 866 dev_err(w->dapm->dev, "ASoC: can't allocate widget list for %s\n", 867 w->name); 868 return -ENOMEM; 869 } 870 wlist = *list; 871 872 /* insert the widget */ 873 dev_dbg(w->dapm->dev, "ASoC: added %s in widget list pos %d\n", 874 w->name, wlist->num_widgets); 875 876 wlist->widgets[wlist->num_widgets] = w; 877 wlist->num_widgets++; 878 return 1; 879 } 880 881 /* 882 * Recursively check for a completed path to an active or physically connected 883 * output widget. Returns number of complete paths. 884 */ 885 static int is_connected_output_ep(struct snd_soc_dapm_widget *widget, 886 struct snd_soc_dapm_widget_list **list) 887 { 888 struct snd_soc_dapm_path *path; 889 int con = 0; 890 891 if (widget->outputs >= 0) 892 return widget->outputs; 893 894 DAPM_UPDATE_STAT(widget, path_checks); 895 896 switch (widget->id) { 897 case snd_soc_dapm_supply: 898 case snd_soc_dapm_regulator_supply: 899 case snd_soc_dapm_clock_supply: 900 case snd_soc_dapm_kcontrol: 901 return 0; 902 default: 903 break; 904 } 905 906 switch (widget->id) { 907 case snd_soc_dapm_adc: 908 case snd_soc_dapm_aif_out: 909 case snd_soc_dapm_dai_out: 910 if (widget->active) { 911 widget->outputs = snd_soc_dapm_suspend_check(widget); 912 return widget->outputs; 913 } 914 default: 915 break; 916 } 917 918 if (widget->connected) { 919 /* connected pin ? */ 920 if (widget->id == snd_soc_dapm_output && !widget->ext) { 921 widget->outputs = snd_soc_dapm_suspend_check(widget); 922 return widget->outputs; 923 } 924 925 /* connected jack or spk ? */ 926 if (widget->id == snd_soc_dapm_hp || 927 widget->id == snd_soc_dapm_spk || 928 (widget->id == snd_soc_dapm_line && 929 !list_empty(&widget->sources))) { 930 widget->outputs = snd_soc_dapm_suspend_check(widget); 931 return widget->outputs; 932 } 933 } 934 935 list_for_each_entry(path, &widget->sinks, list_source) { 936 DAPM_UPDATE_STAT(widget, neighbour_checks); 937 938 if (path->weak) 939 continue; 940 941 if (path->walking) 942 return 1; 943 944 if (path->walked) 945 continue; 946 947 trace_snd_soc_dapm_output_path(widget, path); 948 949 if (path->sink && path->connect) { 950 path->walked = 1; 951 path->walking = 1; 952 953 /* do we need to add this widget to the list ? */ 954 if (list) { 955 int err; 956 err = dapm_list_add_widget(list, path->sink); 957 if (err < 0) { 958 dev_err(widget->dapm->dev, 959 "ASoC: could not add widget %s\n", 960 widget->name); 961 path->walking = 0; 962 return con; 963 } 964 } 965 966 con += is_connected_output_ep(path->sink, list); 967 968 path->walking = 0; 969 } 970 } 971 972 widget->outputs = con; 973 974 return con; 975 } 976 977 /* 978 * Recursively check for a completed path to an active or physically connected 979 * input widget. Returns number of complete paths. 980 */ 981 static int is_connected_input_ep(struct snd_soc_dapm_widget *widget, 982 struct snd_soc_dapm_widget_list **list) 983 { 984 struct snd_soc_dapm_path *path; 985 int con = 0; 986 987 if (widget->inputs >= 0) 988 return widget->inputs; 989 990 DAPM_UPDATE_STAT(widget, path_checks); 991 992 switch (widget->id) { 993 case snd_soc_dapm_supply: 994 case snd_soc_dapm_regulator_supply: 995 case snd_soc_dapm_clock_supply: 996 case snd_soc_dapm_kcontrol: 997 return 0; 998 default: 999 break; 1000 } 1001 1002 /* active stream ? */ 1003 switch (widget->id) { 1004 case snd_soc_dapm_dac: 1005 case snd_soc_dapm_aif_in: 1006 case snd_soc_dapm_dai_in: 1007 if (widget->active) { 1008 widget->inputs = snd_soc_dapm_suspend_check(widget); 1009 return widget->inputs; 1010 } 1011 default: 1012 break; 1013 } 1014 1015 if (widget->connected) { 1016 /* connected pin ? */ 1017 if (widget->id == snd_soc_dapm_input && !widget->ext) { 1018 widget->inputs = snd_soc_dapm_suspend_check(widget); 1019 return widget->inputs; 1020 } 1021 1022 /* connected VMID/Bias for lower pops */ 1023 if (widget->id == snd_soc_dapm_vmid) { 1024 widget->inputs = snd_soc_dapm_suspend_check(widget); 1025 return widget->inputs; 1026 } 1027 1028 /* connected jack ? */ 1029 if (widget->id == snd_soc_dapm_mic || 1030 (widget->id == snd_soc_dapm_line && 1031 !list_empty(&widget->sinks))) { 1032 widget->inputs = snd_soc_dapm_suspend_check(widget); 1033 return widget->inputs; 1034 } 1035 1036 /* signal generator */ 1037 if (widget->id == snd_soc_dapm_siggen) { 1038 widget->inputs = snd_soc_dapm_suspend_check(widget); 1039 return widget->inputs; 1040 } 1041 } 1042 1043 list_for_each_entry(path, &widget->sources, list_sink) { 1044 DAPM_UPDATE_STAT(widget, neighbour_checks); 1045 1046 if (path->weak) 1047 continue; 1048 1049 if (path->walking) 1050 return 1; 1051 1052 if (path->walked) 1053 continue; 1054 1055 trace_snd_soc_dapm_input_path(widget, path); 1056 1057 if (path->source && path->connect) { 1058 path->walked = 1; 1059 path->walking = 1; 1060 1061 /* do we need to add this widget to the list ? */ 1062 if (list) { 1063 int err; 1064 err = dapm_list_add_widget(list, path->source); 1065 if (err < 0) { 1066 dev_err(widget->dapm->dev, 1067 "ASoC: could not add widget %s\n", 1068 widget->name); 1069 path->walking = 0; 1070 return con; 1071 } 1072 } 1073 1074 con += is_connected_input_ep(path->source, list); 1075 1076 path->walking = 0; 1077 } 1078 } 1079 1080 widget->inputs = con; 1081 1082 return con; 1083 } 1084 1085 /** 1086 * snd_soc_dapm_get_connected_widgets - query audio path and it's widgets. 1087 * @dai: the soc DAI. 1088 * @stream: stream direction. 1089 * @list: list of active widgets for this stream. 1090 * 1091 * Queries DAPM graph as to whether an valid audio stream path exists for 1092 * the initial stream specified by name. This takes into account 1093 * current mixer and mux kcontrol settings. Creates list of valid widgets. 1094 * 1095 * Returns the number of valid paths or negative error. 1096 */ 1097 int snd_soc_dapm_dai_get_connected_widgets(struct snd_soc_dai *dai, int stream, 1098 struct snd_soc_dapm_widget_list **list) 1099 { 1100 struct snd_soc_card *card = dai->card; 1101 int paths; 1102 1103 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 1104 dapm_reset(card); 1105 1106 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 1107 paths = is_connected_output_ep(dai->playback_widget, list); 1108 dapm_clear_walk_output(&card->dapm, 1109 &dai->playback_widget->sinks); 1110 } else { 1111 paths = is_connected_input_ep(dai->capture_widget, list); 1112 dapm_clear_walk_input(&card->dapm, 1113 &dai->capture_widget->sources); 1114 } 1115 1116 trace_snd_soc_dapm_connected(paths, stream); 1117 mutex_unlock(&card->dapm_mutex); 1118 1119 return paths; 1120 } 1121 1122 /* 1123 * Handler for generic register modifier widget. 1124 */ 1125 int dapm_reg_event(struct snd_soc_dapm_widget *w, 1126 struct snd_kcontrol *kcontrol, int event) 1127 { 1128 unsigned int val; 1129 1130 if (SND_SOC_DAPM_EVENT_ON(event)) 1131 val = w->on_val; 1132 else 1133 val = w->off_val; 1134 1135 soc_widget_update_bits_locked(w, -(w->reg + 1), 1136 w->mask << w->shift, val << w->shift); 1137 1138 return 0; 1139 } 1140 EXPORT_SYMBOL_GPL(dapm_reg_event); 1141 1142 /* 1143 * Handler for regulator supply widget. 1144 */ 1145 int dapm_regulator_event(struct snd_soc_dapm_widget *w, 1146 struct snd_kcontrol *kcontrol, int event) 1147 { 1148 int ret; 1149 1150 soc_dapm_async_complete(w->dapm); 1151 1152 if (SND_SOC_DAPM_EVENT_ON(event)) { 1153 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) { 1154 ret = regulator_allow_bypass(w->regulator, false); 1155 if (ret != 0) 1156 dev_warn(w->dapm->dev, 1157 "ASoC: Failed to unbypass %s: %d\n", 1158 w->name, ret); 1159 } 1160 1161 return regulator_enable(w->regulator); 1162 } else { 1163 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) { 1164 ret = regulator_allow_bypass(w->regulator, true); 1165 if (ret != 0) 1166 dev_warn(w->dapm->dev, 1167 "ASoC: Failed to bypass %s: %d\n", 1168 w->name, ret); 1169 } 1170 1171 return regulator_disable_deferred(w->regulator, w->shift); 1172 } 1173 } 1174 EXPORT_SYMBOL_GPL(dapm_regulator_event); 1175 1176 /* 1177 * Handler for clock supply widget. 1178 */ 1179 int dapm_clock_event(struct snd_soc_dapm_widget *w, 1180 struct snd_kcontrol *kcontrol, int event) 1181 { 1182 if (!w->clk) 1183 return -EIO; 1184 1185 soc_dapm_async_complete(w->dapm); 1186 1187 #ifdef CONFIG_HAVE_CLK 1188 if (SND_SOC_DAPM_EVENT_ON(event)) { 1189 return clk_prepare_enable(w->clk); 1190 } else { 1191 clk_disable_unprepare(w->clk); 1192 return 0; 1193 } 1194 #endif 1195 return 0; 1196 } 1197 EXPORT_SYMBOL_GPL(dapm_clock_event); 1198 1199 static int dapm_widget_power_check(struct snd_soc_dapm_widget *w) 1200 { 1201 if (w->power_checked) 1202 return w->new_power; 1203 1204 if (w->force) 1205 w->new_power = 1; 1206 else 1207 w->new_power = w->power_check(w); 1208 1209 w->power_checked = true; 1210 1211 return w->new_power; 1212 } 1213 1214 /* Generic check to see if a widget should be powered. 1215 */ 1216 static int dapm_generic_check_power(struct snd_soc_dapm_widget *w) 1217 { 1218 int in, out; 1219 1220 DAPM_UPDATE_STAT(w, power_checks); 1221 1222 in = is_connected_input_ep(w, NULL); 1223 dapm_clear_walk_input(w->dapm, &w->sources); 1224 out = is_connected_output_ep(w, NULL); 1225 dapm_clear_walk_output(w->dapm, &w->sinks); 1226 return out != 0 && in != 0; 1227 } 1228 1229 /* Check to see if an ADC has power */ 1230 static int dapm_adc_check_power(struct snd_soc_dapm_widget *w) 1231 { 1232 int in; 1233 1234 DAPM_UPDATE_STAT(w, power_checks); 1235 1236 if (w->active) { 1237 in = is_connected_input_ep(w, NULL); 1238 dapm_clear_walk_input(w->dapm, &w->sources); 1239 return in != 0; 1240 } else { 1241 return dapm_generic_check_power(w); 1242 } 1243 } 1244 1245 /* Check to see if a DAC has power */ 1246 static int dapm_dac_check_power(struct snd_soc_dapm_widget *w) 1247 { 1248 int out; 1249 1250 DAPM_UPDATE_STAT(w, power_checks); 1251 1252 if (w->active) { 1253 out = is_connected_output_ep(w, NULL); 1254 dapm_clear_walk_output(w->dapm, &w->sinks); 1255 return out != 0; 1256 } else { 1257 return dapm_generic_check_power(w); 1258 } 1259 } 1260 1261 /* Check to see if a power supply is needed */ 1262 static int dapm_supply_check_power(struct snd_soc_dapm_widget *w) 1263 { 1264 struct snd_soc_dapm_path *path; 1265 1266 DAPM_UPDATE_STAT(w, power_checks); 1267 1268 /* Check if one of our outputs is connected */ 1269 list_for_each_entry(path, &w->sinks, list_source) { 1270 DAPM_UPDATE_STAT(w, neighbour_checks); 1271 1272 if (path->weak) 1273 continue; 1274 1275 if (path->connected && 1276 !path->connected(path->source, path->sink)) 1277 continue; 1278 1279 if (!path->sink) 1280 continue; 1281 1282 if (dapm_widget_power_check(path->sink)) 1283 return 1; 1284 } 1285 1286 return 0; 1287 } 1288 1289 static int dapm_always_on_check_power(struct snd_soc_dapm_widget *w) 1290 { 1291 return 1; 1292 } 1293 1294 static int dapm_seq_compare(struct snd_soc_dapm_widget *a, 1295 struct snd_soc_dapm_widget *b, 1296 bool power_up) 1297 { 1298 int *sort; 1299 1300 if (power_up) 1301 sort = dapm_up_seq; 1302 else 1303 sort = dapm_down_seq; 1304 1305 if (sort[a->id] != sort[b->id]) 1306 return sort[a->id] - sort[b->id]; 1307 if (a->subseq != b->subseq) { 1308 if (power_up) 1309 return a->subseq - b->subseq; 1310 else 1311 return b->subseq - a->subseq; 1312 } 1313 if (a->reg != b->reg) 1314 return a->reg - b->reg; 1315 if (a->dapm != b->dapm) 1316 return (unsigned long)a->dapm - (unsigned long)b->dapm; 1317 1318 return 0; 1319 } 1320 1321 /* Insert a widget in order into a DAPM power sequence. */ 1322 static void dapm_seq_insert(struct snd_soc_dapm_widget *new_widget, 1323 struct list_head *list, 1324 bool power_up) 1325 { 1326 struct snd_soc_dapm_widget *w; 1327 1328 list_for_each_entry(w, list, power_list) 1329 if (dapm_seq_compare(new_widget, w, power_up) < 0) { 1330 list_add_tail(&new_widget->power_list, &w->power_list); 1331 return; 1332 } 1333 1334 list_add_tail(&new_widget->power_list, list); 1335 } 1336 1337 static void dapm_seq_check_event(struct snd_soc_card *card, 1338 struct snd_soc_dapm_widget *w, int event) 1339 { 1340 const char *ev_name; 1341 int power, ret; 1342 1343 switch (event) { 1344 case SND_SOC_DAPM_PRE_PMU: 1345 ev_name = "PRE_PMU"; 1346 power = 1; 1347 break; 1348 case SND_SOC_DAPM_POST_PMU: 1349 ev_name = "POST_PMU"; 1350 power = 1; 1351 break; 1352 case SND_SOC_DAPM_PRE_PMD: 1353 ev_name = "PRE_PMD"; 1354 power = 0; 1355 break; 1356 case SND_SOC_DAPM_POST_PMD: 1357 ev_name = "POST_PMD"; 1358 power = 0; 1359 break; 1360 case SND_SOC_DAPM_WILL_PMU: 1361 ev_name = "WILL_PMU"; 1362 power = 1; 1363 break; 1364 case SND_SOC_DAPM_WILL_PMD: 1365 ev_name = "WILL_PMD"; 1366 power = 0; 1367 break; 1368 default: 1369 WARN(1, "Unknown event %d\n", event); 1370 return; 1371 } 1372 1373 if (w->new_power != power) 1374 return; 1375 1376 if (w->event && (w->event_flags & event)) { 1377 pop_dbg(w->dapm->dev, card->pop_time, "pop test : %s %s\n", 1378 w->name, ev_name); 1379 soc_dapm_async_complete(w->dapm); 1380 trace_snd_soc_dapm_widget_event_start(w, event); 1381 ret = w->event(w, NULL, event); 1382 trace_snd_soc_dapm_widget_event_done(w, event); 1383 if (ret < 0) 1384 dev_err(w->dapm->dev, "ASoC: %s: %s event failed: %d\n", 1385 ev_name, w->name, ret); 1386 } 1387 } 1388 1389 /* Apply the coalesced changes from a DAPM sequence */ 1390 static void dapm_seq_run_coalesced(struct snd_soc_card *card, 1391 struct list_head *pending) 1392 { 1393 struct snd_soc_dapm_widget *w; 1394 int reg; 1395 unsigned int value = 0; 1396 unsigned int mask = 0; 1397 1398 reg = list_first_entry(pending, struct snd_soc_dapm_widget, 1399 power_list)->reg; 1400 1401 list_for_each_entry(w, pending, power_list) { 1402 WARN_ON(reg != w->reg); 1403 w->power = w->new_power; 1404 1405 mask |= w->mask << w->shift; 1406 if (w->power) 1407 value |= w->on_val << w->shift; 1408 else 1409 value |= w->off_val << w->shift; 1410 1411 pop_dbg(w->dapm->dev, card->pop_time, 1412 "pop test : Queue %s: reg=0x%x, 0x%x/0x%x\n", 1413 w->name, reg, value, mask); 1414 1415 /* Check for events */ 1416 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMU); 1417 dapm_seq_check_event(card, w, SND_SOC_DAPM_PRE_PMD); 1418 } 1419 1420 if (reg >= 0) { 1421 /* Any widget will do, they should all be updating the 1422 * same register. 1423 */ 1424 w = list_first_entry(pending, struct snd_soc_dapm_widget, 1425 power_list); 1426 1427 pop_dbg(w->dapm->dev, card->pop_time, 1428 "pop test : Applying 0x%x/0x%x to %x in %dms\n", 1429 value, mask, reg, card->pop_time); 1430 pop_wait(card->pop_time); 1431 soc_widget_update_bits_locked(w, reg, mask, value); 1432 } 1433 1434 list_for_each_entry(w, pending, power_list) { 1435 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMU); 1436 dapm_seq_check_event(card, w, SND_SOC_DAPM_POST_PMD); 1437 } 1438 } 1439 1440 /* Apply a DAPM power sequence. 1441 * 1442 * We walk over a pre-sorted list of widgets to apply power to. In 1443 * order to minimise the number of writes to the device required 1444 * multiple widgets will be updated in a single write where possible. 1445 * Currently anything that requires more than a single write is not 1446 * handled. 1447 */ 1448 static void dapm_seq_run(struct snd_soc_card *card, 1449 struct list_head *list, int event, bool power_up) 1450 { 1451 struct snd_soc_dapm_widget *w, *n; 1452 struct snd_soc_dapm_context *d; 1453 LIST_HEAD(pending); 1454 int cur_sort = -1; 1455 int cur_subseq = -1; 1456 int cur_reg = SND_SOC_NOPM; 1457 struct snd_soc_dapm_context *cur_dapm = NULL; 1458 int ret, i; 1459 int *sort; 1460 1461 if (power_up) 1462 sort = dapm_up_seq; 1463 else 1464 sort = dapm_down_seq; 1465 1466 list_for_each_entry_safe(w, n, list, power_list) { 1467 ret = 0; 1468 1469 /* Do we need to apply any queued changes? */ 1470 if (sort[w->id] != cur_sort || w->reg != cur_reg || 1471 w->dapm != cur_dapm || w->subseq != cur_subseq) { 1472 if (!list_empty(&pending)) 1473 dapm_seq_run_coalesced(card, &pending); 1474 1475 if (cur_dapm && cur_dapm->seq_notifier) { 1476 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++) 1477 if (sort[i] == cur_sort) 1478 cur_dapm->seq_notifier(cur_dapm, 1479 i, 1480 cur_subseq); 1481 } 1482 1483 if (cur_dapm && w->dapm != cur_dapm) 1484 soc_dapm_async_complete(cur_dapm); 1485 1486 INIT_LIST_HEAD(&pending); 1487 cur_sort = -1; 1488 cur_subseq = INT_MIN; 1489 cur_reg = SND_SOC_NOPM; 1490 cur_dapm = NULL; 1491 } 1492 1493 switch (w->id) { 1494 case snd_soc_dapm_pre: 1495 if (!w->event) 1496 list_for_each_entry_safe_continue(w, n, list, 1497 power_list); 1498 1499 if (event == SND_SOC_DAPM_STREAM_START) 1500 ret = w->event(w, 1501 NULL, SND_SOC_DAPM_PRE_PMU); 1502 else if (event == SND_SOC_DAPM_STREAM_STOP) 1503 ret = w->event(w, 1504 NULL, SND_SOC_DAPM_PRE_PMD); 1505 break; 1506 1507 case snd_soc_dapm_post: 1508 if (!w->event) 1509 list_for_each_entry_safe_continue(w, n, list, 1510 power_list); 1511 1512 if (event == SND_SOC_DAPM_STREAM_START) 1513 ret = w->event(w, 1514 NULL, SND_SOC_DAPM_POST_PMU); 1515 else if (event == SND_SOC_DAPM_STREAM_STOP) 1516 ret = w->event(w, 1517 NULL, SND_SOC_DAPM_POST_PMD); 1518 break; 1519 1520 default: 1521 /* Queue it up for application */ 1522 cur_sort = sort[w->id]; 1523 cur_subseq = w->subseq; 1524 cur_reg = w->reg; 1525 cur_dapm = w->dapm; 1526 list_move(&w->power_list, &pending); 1527 break; 1528 } 1529 1530 if (ret < 0) 1531 dev_err(w->dapm->dev, 1532 "ASoC: Failed to apply widget power: %d\n", ret); 1533 } 1534 1535 if (!list_empty(&pending)) 1536 dapm_seq_run_coalesced(card, &pending); 1537 1538 if (cur_dapm && cur_dapm->seq_notifier) { 1539 for (i = 0; i < ARRAY_SIZE(dapm_up_seq); i++) 1540 if (sort[i] == cur_sort) 1541 cur_dapm->seq_notifier(cur_dapm, 1542 i, cur_subseq); 1543 } 1544 1545 list_for_each_entry(d, &card->dapm_list, list) { 1546 soc_dapm_async_complete(d); 1547 } 1548 } 1549 1550 static void dapm_widget_update(struct snd_soc_card *card) 1551 { 1552 struct snd_soc_dapm_update *update = card->update; 1553 struct snd_soc_dapm_widget_list *wlist; 1554 struct snd_soc_dapm_widget *w = NULL; 1555 unsigned int wi; 1556 int ret; 1557 1558 if (!update || !dapm_kcontrol_is_powered(update->kcontrol)) 1559 return; 1560 1561 wlist = dapm_kcontrol_get_wlist(update->kcontrol); 1562 1563 for (wi = 0; wi < wlist->num_widgets; wi++) { 1564 w = wlist->widgets[wi]; 1565 1566 if (w->event && (w->event_flags & SND_SOC_DAPM_PRE_REG)) { 1567 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG); 1568 if (ret != 0) 1569 dev_err(w->dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n", 1570 w->name, ret); 1571 } 1572 } 1573 1574 if (!w) 1575 return; 1576 1577 ret = soc_widget_update_bits_locked(w, update->reg, update->mask, 1578 update->val); 1579 if (ret < 0) 1580 dev_err(w->dapm->dev, "ASoC: %s DAPM update failed: %d\n", 1581 w->name, ret); 1582 1583 for (wi = 0; wi < wlist->num_widgets; wi++) { 1584 w = wlist->widgets[wi]; 1585 1586 if (w->event && (w->event_flags & SND_SOC_DAPM_POST_REG)) { 1587 ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG); 1588 if (ret != 0) 1589 dev_err(w->dapm->dev, "ASoC: %s DAPM post-event failed: %d\n", 1590 w->name, ret); 1591 } 1592 } 1593 } 1594 1595 /* Async callback run prior to DAPM sequences - brings to _PREPARE if 1596 * they're changing state. 1597 */ 1598 static void dapm_pre_sequence_async(void *data, async_cookie_t cookie) 1599 { 1600 struct snd_soc_dapm_context *d = data; 1601 int ret; 1602 1603 /* If we're off and we're not supposed to be go into STANDBY */ 1604 if (d->bias_level == SND_SOC_BIAS_OFF && 1605 d->target_bias_level != SND_SOC_BIAS_OFF) { 1606 if (d->dev) 1607 pm_runtime_get_sync(d->dev); 1608 1609 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY); 1610 if (ret != 0) 1611 dev_err(d->dev, 1612 "ASoC: Failed to turn on bias: %d\n", ret); 1613 } 1614 1615 /* Prepare for a transition to ON or away from ON */ 1616 if ((d->target_bias_level == SND_SOC_BIAS_ON && 1617 d->bias_level != SND_SOC_BIAS_ON) || 1618 (d->target_bias_level != SND_SOC_BIAS_ON && 1619 d->bias_level == SND_SOC_BIAS_ON)) { 1620 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE); 1621 if (ret != 0) 1622 dev_err(d->dev, 1623 "ASoC: Failed to prepare bias: %d\n", ret); 1624 } 1625 } 1626 1627 /* Async callback run prior to DAPM sequences - brings to their final 1628 * state. 1629 */ 1630 static void dapm_post_sequence_async(void *data, async_cookie_t cookie) 1631 { 1632 struct snd_soc_dapm_context *d = data; 1633 int ret; 1634 1635 /* If we just powered the last thing off drop to standby bias */ 1636 if (d->bias_level == SND_SOC_BIAS_PREPARE && 1637 (d->target_bias_level == SND_SOC_BIAS_STANDBY || 1638 d->target_bias_level == SND_SOC_BIAS_OFF)) { 1639 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY); 1640 if (ret != 0) 1641 dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n", 1642 ret); 1643 } 1644 1645 /* If we're in standby and can support bias off then do that */ 1646 if (d->bias_level == SND_SOC_BIAS_STANDBY && 1647 d->target_bias_level == SND_SOC_BIAS_OFF) { 1648 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF); 1649 if (ret != 0) 1650 dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n", 1651 ret); 1652 1653 if (d->dev) 1654 pm_runtime_put(d->dev); 1655 } 1656 1657 /* If we just powered up then move to active bias */ 1658 if (d->bias_level == SND_SOC_BIAS_PREPARE && 1659 d->target_bias_level == SND_SOC_BIAS_ON) { 1660 ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON); 1661 if (ret != 0) 1662 dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n", 1663 ret); 1664 } 1665 } 1666 1667 static void dapm_widget_set_peer_power(struct snd_soc_dapm_widget *peer, 1668 bool power, bool connect) 1669 { 1670 /* If a connection is being made or broken then that update 1671 * will have marked the peer dirty, otherwise the widgets are 1672 * not connected and this update has no impact. */ 1673 if (!connect) 1674 return; 1675 1676 /* If the peer is already in the state we're moving to then we 1677 * won't have an impact on it. */ 1678 if (power != peer->power) 1679 dapm_mark_dirty(peer, "peer state change"); 1680 } 1681 1682 static void dapm_widget_set_power(struct snd_soc_dapm_widget *w, bool power, 1683 struct list_head *up_list, 1684 struct list_head *down_list) 1685 { 1686 struct snd_soc_dapm_path *path; 1687 1688 if (w->power == power) 1689 return; 1690 1691 trace_snd_soc_dapm_widget_power(w, power); 1692 1693 /* If we changed our power state perhaps our neigbours changed 1694 * also. 1695 */ 1696 list_for_each_entry(path, &w->sources, list_sink) { 1697 if (path->source) { 1698 dapm_widget_set_peer_power(path->source, power, 1699 path->connect); 1700 } 1701 } 1702 switch (w->id) { 1703 case snd_soc_dapm_supply: 1704 case snd_soc_dapm_regulator_supply: 1705 case snd_soc_dapm_clock_supply: 1706 case snd_soc_dapm_kcontrol: 1707 /* Supplies can't affect their outputs, only their inputs */ 1708 break; 1709 default: 1710 list_for_each_entry(path, &w->sinks, list_source) { 1711 if (path->sink) { 1712 dapm_widget_set_peer_power(path->sink, power, 1713 path->connect); 1714 } 1715 } 1716 break; 1717 } 1718 1719 if (power) 1720 dapm_seq_insert(w, up_list, true); 1721 else 1722 dapm_seq_insert(w, down_list, false); 1723 } 1724 1725 static void dapm_power_one_widget(struct snd_soc_dapm_widget *w, 1726 struct list_head *up_list, 1727 struct list_head *down_list) 1728 { 1729 int power; 1730 1731 switch (w->id) { 1732 case snd_soc_dapm_pre: 1733 dapm_seq_insert(w, down_list, false); 1734 break; 1735 case snd_soc_dapm_post: 1736 dapm_seq_insert(w, up_list, true); 1737 break; 1738 1739 default: 1740 power = dapm_widget_power_check(w); 1741 1742 dapm_widget_set_power(w, power, up_list, down_list); 1743 break; 1744 } 1745 } 1746 1747 /* 1748 * Scan each dapm widget for complete audio path. 1749 * A complete path is a route that has valid endpoints i.e.:- 1750 * 1751 * o DAC to output pin. 1752 * o Input Pin to ADC. 1753 * o Input pin to Output pin (bypass, sidetone) 1754 * o DAC to ADC (loopback). 1755 */ 1756 static int dapm_power_widgets(struct snd_soc_card *card, int event) 1757 { 1758 struct snd_soc_dapm_widget *w; 1759 struct snd_soc_dapm_context *d; 1760 LIST_HEAD(up_list); 1761 LIST_HEAD(down_list); 1762 ASYNC_DOMAIN_EXCLUSIVE(async_domain); 1763 enum snd_soc_bias_level bias; 1764 1765 lockdep_assert_held(&card->dapm_mutex); 1766 1767 trace_snd_soc_dapm_start(card); 1768 1769 list_for_each_entry(d, &card->dapm_list, list) { 1770 if (d->idle_bias_off) 1771 d->target_bias_level = SND_SOC_BIAS_OFF; 1772 else 1773 d->target_bias_level = SND_SOC_BIAS_STANDBY; 1774 } 1775 1776 dapm_reset(card); 1777 1778 /* Check which widgets we need to power and store them in 1779 * lists indicating if they should be powered up or down. We 1780 * only check widgets that have been flagged as dirty but note 1781 * that new widgets may be added to the dirty list while we 1782 * iterate. 1783 */ 1784 list_for_each_entry(w, &card->dapm_dirty, dirty) { 1785 dapm_power_one_widget(w, &up_list, &down_list); 1786 } 1787 1788 list_for_each_entry(w, &card->widgets, list) { 1789 switch (w->id) { 1790 case snd_soc_dapm_pre: 1791 case snd_soc_dapm_post: 1792 /* These widgets always need to be powered */ 1793 break; 1794 default: 1795 list_del_init(&w->dirty); 1796 break; 1797 } 1798 1799 if (w->new_power) { 1800 d = w->dapm; 1801 1802 /* Supplies and micbiases only bring the 1803 * context up to STANDBY as unless something 1804 * else is active and passing audio they 1805 * generally don't require full power. Signal 1806 * generators are virtual pins and have no 1807 * power impact themselves. 1808 */ 1809 switch (w->id) { 1810 case snd_soc_dapm_siggen: 1811 case snd_soc_dapm_vmid: 1812 break; 1813 case snd_soc_dapm_supply: 1814 case snd_soc_dapm_regulator_supply: 1815 case snd_soc_dapm_clock_supply: 1816 case snd_soc_dapm_micbias: 1817 if (d->target_bias_level < SND_SOC_BIAS_STANDBY) 1818 d->target_bias_level = SND_SOC_BIAS_STANDBY; 1819 break; 1820 default: 1821 d->target_bias_level = SND_SOC_BIAS_ON; 1822 break; 1823 } 1824 } 1825 1826 } 1827 1828 /* Force all contexts in the card to the same bias state if 1829 * they're not ground referenced. 1830 */ 1831 bias = SND_SOC_BIAS_OFF; 1832 list_for_each_entry(d, &card->dapm_list, list) 1833 if (d->target_bias_level > bias) 1834 bias = d->target_bias_level; 1835 list_for_each_entry(d, &card->dapm_list, list) 1836 if (!d->idle_bias_off) 1837 d->target_bias_level = bias; 1838 1839 trace_snd_soc_dapm_walk_done(card); 1840 1841 /* Run card bias changes at first */ 1842 dapm_pre_sequence_async(&card->dapm, 0); 1843 /* Run other bias changes in parallel */ 1844 list_for_each_entry(d, &card->dapm_list, list) { 1845 if (d != &card->dapm) 1846 async_schedule_domain(dapm_pre_sequence_async, d, 1847 &async_domain); 1848 } 1849 async_synchronize_full_domain(&async_domain); 1850 1851 list_for_each_entry(w, &down_list, power_list) { 1852 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMD); 1853 } 1854 1855 list_for_each_entry(w, &up_list, power_list) { 1856 dapm_seq_check_event(card, w, SND_SOC_DAPM_WILL_PMU); 1857 } 1858 1859 /* Power down widgets first; try to avoid amplifying pops. */ 1860 dapm_seq_run(card, &down_list, event, false); 1861 1862 dapm_widget_update(card); 1863 1864 /* Now power up. */ 1865 dapm_seq_run(card, &up_list, event, true); 1866 1867 /* Run all the bias changes in parallel */ 1868 list_for_each_entry(d, &card->dapm_list, list) { 1869 if (d != &card->dapm) 1870 async_schedule_domain(dapm_post_sequence_async, d, 1871 &async_domain); 1872 } 1873 async_synchronize_full_domain(&async_domain); 1874 /* Run card bias changes at last */ 1875 dapm_post_sequence_async(&card->dapm, 0); 1876 1877 /* do we need to notify any clients that DAPM event is complete */ 1878 list_for_each_entry(d, &card->dapm_list, list) { 1879 if (d->stream_event) 1880 d->stream_event(d, event); 1881 } 1882 1883 pop_dbg(card->dev, card->pop_time, 1884 "DAPM sequencing finished, waiting %dms\n", card->pop_time); 1885 pop_wait(card->pop_time); 1886 1887 trace_snd_soc_dapm_done(card); 1888 1889 return 0; 1890 } 1891 1892 #ifdef CONFIG_DEBUG_FS 1893 static ssize_t dapm_widget_power_read_file(struct file *file, 1894 char __user *user_buf, 1895 size_t count, loff_t *ppos) 1896 { 1897 struct snd_soc_dapm_widget *w = file->private_data; 1898 char *buf; 1899 int in, out; 1900 ssize_t ret; 1901 struct snd_soc_dapm_path *p = NULL; 1902 1903 buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 1904 if (!buf) 1905 return -ENOMEM; 1906 1907 in = is_connected_input_ep(w, NULL); 1908 dapm_clear_walk_input(w->dapm, &w->sources); 1909 out = is_connected_output_ep(w, NULL); 1910 dapm_clear_walk_output(w->dapm, &w->sinks); 1911 1912 ret = snprintf(buf, PAGE_SIZE, "%s: %s%s in %d out %d", 1913 w->name, w->power ? "On" : "Off", 1914 w->force ? " (forced)" : "", in, out); 1915 1916 if (w->reg >= 0) 1917 ret += snprintf(buf + ret, PAGE_SIZE - ret, 1918 " - R%d(0x%x) mask 0x%x", 1919 w->reg, w->reg, w->mask << w->shift); 1920 1921 ret += snprintf(buf + ret, PAGE_SIZE - ret, "\n"); 1922 1923 if (w->sname) 1924 ret += snprintf(buf + ret, PAGE_SIZE - ret, " stream %s %s\n", 1925 w->sname, 1926 w->active ? "active" : "inactive"); 1927 1928 list_for_each_entry(p, &w->sources, list_sink) { 1929 if (p->connected && !p->connected(w, p->source)) 1930 continue; 1931 1932 if (p->connect) 1933 ret += snprintf(buf + ret, PAGE_SIZE - ret, 1934 " in \"%s\" \"%s\"\n", 1935 p->name ? p->name : "static", 1936 p->source->name); 1937 } 1938 list_for_each_entry(p, &w->sinks, list_source) { 1939 if (p->connected && !p->connected(w, p->sink)) 1940 continue; 1941 1942 if (p->connect) 1943 ret += snprintf(buf + ret, PAGE_SIZE - ret, 1944 " out \"%s\" \"%s\"\n", 1945 p->name ? p->name : "static", 1946 p->sink->name); 1947 } 1948 1949 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret); 1950 1951 kfree(buf); 1952 return ret; 1953 } 1954 1955 static const struct file_operations dapm_widget_power_fops = { 1956 .open = simple_open, 1957 .read = dapm_widget_power_read_file, 1958 .llseek = default_llseek, 1959 }; 1960 1961 static ssize_t dapm_bias_read_file(struct file *file, char __user *user_buf, 1962 size_t count, loff_t *ppos) 1963 { 1964 struct snd_soc_dapm_context *dapm = file->private_data; 1965 char *level; 1966 1967 switch (dapm->bias_level) { 1968 case SND_SOC_BIAS_ON: 1969 level = "On\n"; 1970 break; 1971 case SND_SOC_BIAS_PREPARE: 1972 level = "Prepare\n"; 1973 break; 1974 case SND_SOC_BIAS_STANDBY: 1975 level = "Standby\n"; 1976 break; 1977 case SND_SOC_BIAS_OFF: 1978 level = "Off\n"; 1979 break; 1980 default: 1981 WARN(1, "Unknown bias_level %d\n", dapm->bias_level); 1982 level = "Unknown\n"; 1983 break; 1984 } 1985 1986 return simple_read_from_buffer(user_buf, count, ppos, level, 1987 strlen(level)); 1988 } 1989 1990 static const struct file_operations dapm_bias_fops = { 1991 .open = simple_open, 1992 .read = dapm_bias_read_file, 1993 .llseek = default_llseek, 1994 }; 1995 1996 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm, 1997 struct dentry *parent) 1998 { 1999 struct dentry *d; 2000 2001 dapm->debugfs_dapm = debugfs_create_dir("dapm", parent); 2002 2003 if (!dapm->debugfs_dapm) { 2004 dev_warn(dapm->dev, 2005 "ASoC: Failed to create DAPM debugfs directory\n"); 2006 return; 2007 } 2008 2009 d = debugfs_create_file("bias_level", 0444, 2010 dapm->debugfs_dapm, dapm, 2011 &dapm_bias_fops); 2012 if (!d) 2013 dev_warn(dapm->dev, 2014 "ASoC: Failed to create bias level debugfs file\n"); 2015 } 2016 2017 static void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w) 2018 { 2019 struct snd_soc_dapm_context *dapm = w->dapm; 2020 struct dentry *d; 2021 2022 if (!dapm->debugfs_dapm || !w->name) 2023 return; 2024 2025 d = debugfs_create_file(w->name, 0444, 2026 dapm->debugfs_dapm, w, 2027 &dapm_widget_power_fops); 2028 if (!d) 2029 dev_warn(w->dapm->dev, 2030 "ASoC: Failed to create %s debugfs file\n", 2031 w->name); 2032 } 2033 2034 static void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm) 2035 { 2036 debugfs_remove_recursive(dapm->debugfs_dapm); 2037 } 2038 2039 #else 2040 void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm, 2041 struct dentry *parent) 2042 { 2043 } 2044 2045 static inline void dapm_debugfs_add_widget(struct snd_soc_dapm_widget *w) 2046 { 2047 } 2048 2049 static inline void dapm_debugfs_cleanup(struct snd_soc_dapm_context *dapm) 2050 { 2051 } 2052 2053 #endif 2054 2055 /* test and update the power status of a mux widget */ 2056 static int soc_dapm_mux_update_power(struct snd_soc_card *card, 2057 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e) 2058 { 2059 struct snd_soc_dapm_path *path; 2060 int found = 0; 2061 2062 lockdep_assert_held(&card->dapm_mutex); 2063 2064 /* find dapm widget path assoc with kcontrol */ 2065 dapm_kcontrol_for_each_path(path, kcontrol) { 2066 if (!path->name || !e->texts[mux]) 2067 continue; 2068 2069 found = 1; 2070 /* we now need to match the string in the enum to the path */ 2071 if (!(strcmp(path->name, e->texts[mux]))) { 2072 path->connect = 1; /* new connection */ 2073 dapm_mark_dirty(path->source, "mux connection"); 2074 } else { 2075 if (path->connect) 2076 dapm_mark_dirty(path->source, 2077 "mux disconnection"); 2078 path->connect = 0; /* old connection must be powered down */ 2079 } 2080 dapm_mark_dirty(path->sink, "mux change"); 2081 } 2082 2083 if (found) 2084 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP); 2085 2086 return found; 2087 } 2088 2089 int snd_soc_dapm_mux_update_power(struct snd_soc_dapm_context *dapm, 2090 struct snd_kcontrol *kcontrol, int mux, struct soc_enum *e, 2091 struct snd_soc_dapm_update *update) 2092 { 2093 struct snd_soc_card *card = dapm->card; 2094 int ret; 2095 2096 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 2097 card->update = update; 2098 ret = soc_dapm_mux_update_power(card, kcontrol, mux, e); 2099 card->update = NULL; 2100 mutex_unlock(&card->dapm_mutex); 2101 if (ret > 0) 2102 soc_dpcm_runtime_update(card); 2103 return ret; 2104 } 2105 EXPORT_SYMBOL_GPL(snd_soc_dapm_mux_update_power); 2106 2107 /* test and update the power status of a mixer or switch widget */ 2108 static int soc_dapm_mixer_update_power(struct snd_soc_card *card, 2109 struct snd_kcontrol *kcontrol, int connect) 2110 { 2111 struct snd_soc_dapm_path *path; 2112 int found = 0; 2113 2114 lockdep_assert_held(&card->dapm_mutex); 2115 2116 /* find dapm widget path assoc with kcontrol */ 2117 dapm_kcontrol_for_each_path(path, kcontrol) { 2118 found = 1; 2119 path->connect = connect; 2120 dapm_mark_dirty(path->source, "mixer connection"); 2121 dapm_mark_dirty(path->sink, "mixer update"); 2122 } 2123 2124 if (found) 2125 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP); 2126 2127 return found; 2128 } 2129 2130 int snd_soc_dapm_mixer_update_power(struct snd_soc_dapm_context *dapm, 2131 struct snd_kcontrol *kcontrol, int connect, 2132 struct snd_soc_dapm_update *update) 2133 { 2134 struct snd_soc_card *card = dapm->card; 2135 int ret; 2136 2137 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 2138 card->update = update; 2139 ret = soc_dapm_mixer_update_power(card, kcontrol, connect); 2140 card->update = NULL; 2141 mutex_unlock(&card->dapm_mutex); 2142 if (ret > 0) 2143 soc_dpcm_runtime_update(card); 2144 return ret; 2145 } 2146 EXPORT_SYMBOL_GPL(snd_soc_dapm_mixer_update_power); 2147 2148 /* show dapm widget status in sys fs */ 2149 static ssize_t dapm_widget_show(struct device *dev, 2150 struct device_attribute *attr, char *buf) 2151 { 2152 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev); 2153 struct snd_soc_codec *codec =rtd->codec; 2154 struct snd_soc_dapm_widget *w; 2155 int count = 0; 2156 char *state = "not set"; 2157 2158 list_for_each_entry(w, &codec->card->widgets, list) { 2159 if (w->dapm != &codec->dapm) 2160 continue; 2161 2162 /* only display widgets that burnm power */ 2163 switch (w->id) { 2164 case snd_soc_dapm_hp: 2165 case snd_soc_dapm_mic: 2166 case snd_soc_dapm_spk: 2167 case snd_soc_dapm_line: 2168 case snd_soc_dapm_micbias: 2169 case snd_soc_dapm_dac: 2170 case snd_soc_dapm_adc: 2171 case snd_soc_dapm_pga: 2172 case snd_soc_dapm_out_drv: 2173 case snd_soc_dapm_mixer: 2174 case snd_soc_dapm_mixer_named_ctl: 2175 case snd_soc_dapm_supply: 2176 case snd_soc_dapm_regulator_supply: 2177 case snd_soc_dapm_clock_supply: 2178 if (w->name) 2179 count += sprintf(buf + count, "%s: %s\n", 2180 w->name, w->power ? "On":"Off"); 2181 break; 2182 default: 2183 break; 2184 } 2185 } 2186 2187 switch (codec->dapm.bias_level) { 2188 case SND_SOC_BIAS_ON: 2189 state = "On"; 2190 break; 2191 case SND_SOC_BIAS_PREPARE: 2192 state = "Prepare"; 2193 break; 2194 case SND_SOC_BIAS_STANDBY: 2195 state = "Standby"; 2196 break; 2197 case SND_SOC_BIAS_OFF: 2198 state = "Off"; 2199 break; 2200 } 2201 count += sprintf(buf + count, "PM State: %s\n", state); 2202 2203 return count; 2204 } 2205 2206 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL); 2207 2208 int snd_soc_dapm_sys_add(struct device *dev) 2209 { 2210 return device_create_file(dev, &dev_attr_dapm_widget); 2211 } 2212 2213 static void snd_soc_dapm_sys_remove(struct device *dev) 2214 { 2215 device_remove_file(dev, &dev_attr_dapm_widget); 2216 } 2217 2218 static void dapm_free_path(struct snd_soc_dapm_path *path) 2219 { 2220 list_del(&path->list_sink); 2221 list_del(&path->list_source); 2222 list_del(&path->list_kcontrol); 2223 list_del(&path->list); 2224 kfree(path); 2225 } 2226 2227 /* free all dapm widgets and resources */ 2228 static void dapm_free_widgets(struct snd_soc_dapm_context *dapm) 2229 { 2230 struct snd_soc_dapm_widget *w, *next_w; 2231 struct snd_soc_dapm_path *p, *next_p; 2232 2233 list_for_each_entry_safe(w, next_w, &dapm->card->widgets, list) { 2234 if (w->dapm != dapm) 2235 continue; 2236 list_del(&w->list); 2237 /* 2238 * remove source and sink paths associated to this widget. 2239 * While removing the path, remove reference to it from both 2240 * source and sink widgets so that path is removed only once. 2241 */ 2242 list_for_each_entry_safe(p, next_p, &w->sources, list_sink) 2243 dapm_free_path(p); 2244 2245 list_for_each_entry_safe(p, next_p, &w->sinks, list_source) 2246 dapm_free_path(p); 2247 2248 kfree(w->kcontrols); 2249 kfree(w->name); 2250 kfree(w); 2251 } 2252 } 2253 2254 static struct snd_soc_dapm_widget *dapm_find_widget( 2255 struct snd_soc_dapm_context *dapm, const char *pin, 2256 bool search_other_contexts) 2257 { 2258 struct snd_soc_dapm_widget *w; 2259 struct snd_soc_dapm_widget *fallback = NULL; 2260 2261 list_for_each_entry(w, &dapm->card->widgets, list) { 2262 if (!strcmp(w->name, pin)) { 2263 if (w->dapm == dapm) 2264 return w; 2265 else 2266 fallback = w; 2267 } 2268 } 2269 2270 if (search_other_contexts) 2271 return fallback; 2272 2273 return NULL; 2274 } 2275 2276 static int snd_soc_dapm_set_pin(struct snd_soc_dapm_context *dapm, 2277 const char *pin, int status) 2278 { 2279 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true); 2280 2281 dapm_assert_locked(dapm); 2282 2283 if (!w) { 2284 dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin); 2285 return -EINVAL; 2286 } 2287 2288 if (w->connected != status) 2289 dapm_mark_dirty(w, "pin configuration"); 2290 2291 w->connected = status; 2292 if (status == 0) 2293 w->force = 0; 2294 2295 return 0; 2296 } 2297 2298 /** 2299 * snd_soc_dapm_sync_unlocked - scan and power dapm paths 2300 * @dapm: DAPM context 2301 * 2302 * Walks all dapm audio paths and powers widgets according to their 2303 * stream or path usage. 2304 * 2305 * Requires external locking. 2306 * 2307 * Returns 0 for success. 2308 */ 2309 int snd_soc_dapm_sync_unlocked(struct snd_soc_dapm_context *dapm) 2310 { 2311 /* 2312 * Suppress early reports (eg, jacks syncing their state) to avoid 2313 * silly DAPM runs during card startup. 2314 */ 2315 if (!dapm->card || !dapm->card->instantiated) 2316 return 0; 2317 2318 return dapm_power_widgets(dapm->card, SND_SOC_DAPM_STREAM_NOP); 2319 } 2320 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_unlocked); 2321 2322 /** 2323 * snd_soc_dapm_sync - scan and power dapm paths 2324 * @dapm: DAPM context 2325 * 2326 * Walks all dapm audio paths and powers widgets according to their 2327 * stream or path usage. 2328 * 2329 * Returns 0 for success. 2330 */ 2331 int snd_soc_dapm_sync(struct snd_soc_dapm_context *dapm) 2332 { 2333 int ret; 2334 2335 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 2336 ret = snd_soc_dapm_sync_unlocked(dapm); 2337 mutex_unlock(&dapm->card->dapm_mutex); 2338 return ret; 2339 } 2340 EXPORT_SYMBOL_GPL(snd_soc_dapm_sync); 2341 2342 static int snd_soc_dapm_add_path(struct snd_soc_dapm_context *dapm, 2343 struct snd_soc_dapm_widget *wsource, struct snd_soc_dapm_widget *wsink, 2344 const char *control, 2345 int (*connected)(struct snd_soc_dapm_widget *source, 2346 struct snd_soc_dapm_widget *sink)) 2347 { 2348 struct snd_soc_dapm_path *path; 2349 int ret; 2350 2351 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL); 2352 if (!path) 2353 return -ENOMEM; 2354 2355 path->source = wsource; 2356 path->sink = wsink; 2357 path->connected = connected; 2358 INIT_LIST_HEAD(&path->list); 2359 INIT_LIST_HEAD(&path->list_kcontrol); 2360 INIT_LIST_HEAD(&path->list_source); 2361 INIT_LIST_HEAD(&path->list_sink); 2362 2363 /* check for external widgets */ 2364 if (wsink->id == snd_soc_dapm_input) { 2365 if (wsource->id == snd_soc_dapm_micbias || 2366 wsource->id == snd_soc_dapm_mic || 2367 wsource->id == snd_soc_dapm_line || 2368 wsource->id == snd_soc_dapm_output) 2369 wsink->ext = 1; 2370 } 2371 if (wsource->id == snd_soc_dapm_output) { 2372 if (wsink->id == snd_soc_dapm_spk || 2373 wsink->id == snd_soc_dapm_hp || 2374 wsink->id == snd_soc_dapm_line || 2375 wsink->id == snd_soc_dapm_input) 2376 wsource->ext = 1; 2377 } 2378 2379 dapm_mark_dirty(wsource, "Route added"); 2380 dapm_mark_dirty(wsink, "Route added"); 2381 2382 /* connect static paths */ 2383 if (control == NULL) { 2384 list_add(&path->list, &dapm->card->paths); 2385 list_add(&path->list_sink, &wsink->sources); 2386 list_add(&path->list_source, &wsource->sinks); 2387 path->connect = 1; 2388 return 0; 2389 } 2390 2391 /* connect dynamic paths */ 2392 switch (wsink->id) { 2393 case snd_soc_dapm_adc: 2394 case snd_soc_dapm_dac: 2395 case snd_soc_dapm_pga: 2396 case snd_soc_dapm_out_drv: 2397 case snd_soc_dapm_input: 2398 case snd_soc_dapm_output: 2399 case snd_soc_dapm_siggen: 2400 case snd_soc_dapm_micbias: 2401 case snd_soc_dapm_vmid: 2402 case snd_soc_dapm_pre: 2403 case snd_soc_dapm_post: 2404 case snd_soc_dapm_supply: 2405 case snd_soc_dapm_regulator_supply: 2406 case snd_soc_dapm_clock_supply: 2407 case snd_soc_dapm_aif_in: 2408 case snd_soc_dapm_aif_out: 2409 case snd_soc_dapm_dai_in: 2410 case snd_soc_dapm_dai_out: 2411 case snd_soc_dapm_dai_link: 2412 case snd_soc_dapm_kcontrol: 2413 list_add(&path->list, &dapm->card->paths); 2414 list_add(&path->list_sink, &wsink->sources); 2415 list_add(&path->list_source, &wsource->sinks); 2416 path->connect = 1; 2417 return 0; 2418 case snd_soc_dapm_mux: 2419 ret = dapm_connect_mux(dapm, wsource, wsink, path, control, 2420 &wsink->kcontrol_news[0]); 2421 if (ret != 0) 2422 goto err; 2423 break; 2424 case snd_soc_dapm_switch: 2425 case snd_soc_dapm_mixer: 2426 case snd_soc_dapm_mixer_named_ctl: 2427 ret = dapm_connect_mixer(dapm, wsource, wsink, path, control); 2428 if (ret != 0) 2429 goto err; 2430 break; 2431 case snd_soc_dapm_hp: 2432 case snd_soc_dapm_mic: 2433 case snd_soc_dapm_line: 2434 case snd_soc_dapm_spk: 2435 list_add(&path->list, &dapm->card->paths); 2436 list_add(&path->list_sink, &wsink->sources); 2437 list_add(&path->list_source, &wsource->sinks); 2438 path->connect = 0; 2439 return 0; 2440 } 2441 2442 return 0; 2443 err: 2444 kfree(path); 2445 return ret; 2446 } 2447 2448 static int snd_soc_dapm_add_route(struct snd_soc_dapm_context *dapm, 2449 const struct snd_soc_dapm_route *route, 2450 unsigned int is_prefixed) 2451 { 2452 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w; 2453 struct snd_soc_dapm_widget *wtsource = NULL, *wtsink = NULL; 2454 const char *sink; 2455 const char *source; 2456 char prefixed_sink[80]; 2457 char prefixed_source[80]; 2458 int ret; 2459 2460 if (dapm->codec && dapm->codec->name_prefix && !is_prefixed) { 2461 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s", 2462 dapm->codec->name_prefix, route->sink); 2463 sink = prefixed_sink; 2464 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s", 2465 dapm->codec->name_prefix, route->source); 2466 source = prefixed_source; 2467 } else { 2468 sink = route->sink; 2469 source = route->source; 2470 } 2471 2472 /* 2473 * find src and dest widgets over all widgets but favor a widget from 2474 * current DAPM context 2475 */ 2476 list_for_each_entry(w, &dapm->card->widgets, list) { 2477 if (!wsink && !(strcmp(w->name, sink))) { 2478 wtsink = w; 2479 if (w->dapm == dapm) 2480 wsink = w; 2481 continue; 2482 } 2483 if (!wsource && !(strcmp(w->name, source))) { 2484 wtsource = w; 2485 if (w->dapm == dapm) 2486 wsource = w; 2487 } 2488 } 2489 /* use widget from another DAPM context if not found from this */ 2490 if (!wsink) 2491 wsink = wtsink; 2492 if (!wsource) 2493 wsource = wtsource; 2494 2495 if (wsource == NULL) { 2496 dev_err(dapm->dev, "ASoC: no source widget found for %s\n", 2497 route->source); 2498 return -ENODEV; 2499 } 2500 if (wsink == NULL) { 2501 dev_err(dapm->dev, "ASoC: no sink widget found for %s\n", 2502 route->sink); 2503 return -ENODEV; 2504 } 2505 2506 ret = snd_soc_dapm_add_path(dapm, wsource, wsink, route->control, 2507 route->connected); 2508 if (ret) 2509 goto err; 2510 2511 return 0; 2512 err: 2513 dev_warn(dapm->dev, "ASoC: no dapm match for %s --> %s --> %s\n", 2514 source, route->control, sink); 2515 return ret; 2516 } 2517 2518 static int snd_soc_dapm_del_route(struct snd_soc_dapm_context *dapm, 2519 const struct snd_soc_dapm_route *route) 2520 { 2521 struct snd_soc_dapm_path *path, *p; 2522 const char *sink; 2523 const char *source; 2524 char prefixed_sink[80]; 2525 char prefixed_source[80]; 2526 2527 if (route->control) { 2528 dev_err(dapm->dev, 2529 "ASoC: Removal of routes with controls not supported\n"); 2530 return -EINVAL; 2531 } 2532 2533 if (dapm->codec && dapm->codec->name_prefix) { 2534 snprintf(prefixed_sink, sizeof(prefixed_sink), "%s %s", 2535 dapm->codec->name_prefix, route->sink); 2536 sink = prefixed_sink; 2537 snprintf(prefixed_source, sizeof(prefixed_source), "%s %s", 2538 dapm->codec->name_prefix, route->source); 2539 source = prefixed_source; 2540 } else { 2541 sink = route->sink; 2542 source = route->source; 2543 } 2544 2545 path = NULL; 2546 list_for_each_entry(p, &dapm->card->paths, list) { 2547 if (strcmp(p->source->name, source) != 0) 2548 continue; 2549 if (strcmp(p->sink->name, sink) != 0) 2550 continue; 2551 path = p; 2552 break; 2553 } 2554 2555 if (path) { 2556 dapm_mark_dirty(path->source, "Route removed"); 2557 dapm_mark_dirty(path->sink, "Route removed"); 2558 2559 dapm_free_path(path); 2560 } else { 2561 dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n", 2562 source, sink); 2563 } 2564 2565 return 0; 2566 } 2567 2568 /** 2569 * snd_soc_dapm_add_routes - Add routes between DAPM widgets 2570 * @dapm: DAPM context 2571 * @route: audio routes 2572 * @num: number of routes 2573 * 2574 * Connects 2 dapm widgets together via a named audio path. The sink is 2575 * the widget receiving the audio signal, whilst the source is the sender 2576 * of the audio signal. 2577 * 2578 * Returns 0 for success else error. On error all resources can be freed 2579 * with a call to snd_soc_card_free(). 2580 */ 2581 int snd_soc_dapm_add_routes(struct snd_soc_dapm_context *dapm, 2582 const struct snd_soc_dapm_route *route, int num) 2583 { 2584 int i, r, ret = 0; 2585 2586 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT); 2587 for (i = 0; i < num; i++) { 2588 r = snd_soc_dapm_add_route(dapm, route, false); 2589 if (r < 0) { 2590 dev_err(dapm->dev, "ASoC: Failed to add route %s -> %s -> %s\n", 2591 route->source, 2592 route->control ? route->control : "direct", 2593 route->sink); 2594 ret = r; 2595 } 2596 route++; 2597 } 2598 mutex_unlock(&dapm->card->dapm_mutex); 2599 2600 return ret; 2601 } 2602 EXPORT_SYMBOL_GPL(snd_soc_dapm_add_routes); 2603 2604 /** 2605 * snd_soc_dapm_del_routes - Remove routes between DAPM widgets 2606 * @dapm: DAPM context 2607 * @route: audio routes 2608 * @num: number of routes 2609 * 2610 * Removes routes from the DAPM context. 2611 */ 2612 int snd_soc_dapm_del_routes(struct snd_soc_dapm_context *dapm, 2613 const struct snd_soc_dapm_route *route, int num) 2614 { 2615 int i, ret = 0; 2616 2617 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT); 2618 for (i = 0; i < num; i++) { 2619 snd_soc_dapm_del_route(dapm, route); 2620 route++; 2621 } 2622 mutex_unlock(&dapm->card->dapm_mutex); 2623 2624 return ret; 2625 } 2626 EXPORT_SYMBOL_GPL(snd_soc_dapm_del_routes); 2627 2628 static int snd_soc_dapm_weak_route(struct snd_soc_dapm_context *dapm, 2629 const struct snd_soc_dapm_route *route) 2630 { 2631 struct snd_soc_dapm_widget *source = dapm_find_widget(dapm, 2632 route->source, 2633 true); 2634 struct snd_soc_dapm_widget *sink = dapm_find_widget(dapm, 2635 route->sink, 2636 true); 2637 struct snd_soc_dapm_path *path; 2638 int count = 0; 2639 2640 if (!source) { 2641 dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n", 2642 route->source); 2643 return -ENODEV; 2644 } 2645 2646 if (!sink) { 2647 dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n", 2648 route->sink); 2649 return -ENODEV; 2650 } 2651 2652 if (route->control || route->connected) 2653 dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n", 2654 route->source, route->sink); 2655 2656 list_for_each_entry(path, &source->sinks, list_source) { 2657 if (path->sink == sink) { 2658 path->weak = 1; 2659 count++; 2660 } 2661 } 2662 2663 if (count == 0) 2664 dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n", 2665 route->source, route->sink); 2666 if (count > 1) 2667 dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n", 2668 count, route->source, route->sink); 2669 2670 return 0; 2671 } 2672 2673 /** 2674 * snd_soc_dapm_weak_routes - Mark routes between DAPM widgets as weak 2675 * @dapm: DAPM context 2676 * @route: audio routes 2677 * @num: number of routes 2678 * 2679 * Mark existing routes matching those specified in the passed array 2680 * as being weak, meaning that they are ignored for the purpose of 2681 * power decisions. The main intended use case is for sidetone paths 2682 * which couple audio between other independent paths if they are both 2683 * active in order to make the combination work better at the user 2684 * level but which aren't intended to be "used". 2685 * 2686 * Note that CODEC drivers should not use this as sidetone type paths 2687 * can frequently also be used as bypass paths. 2688 */ 2689 int snd_soc_dapm_weak_routes(struct snd_soc_dapm_context *dapm, 2690 const struct snd_soc_dapm_route *route, int num) 2691 { 2692 int i, err; 2693 int ret = 0; 2694 2695 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT); 2696 for (i = 0; i < num; i++) { 2697 err = snd_soc_dapm_weak_route(dapm, route); 2698 if (err) 2699 ret = err; 2700 route++; 2701 } 2702 mutex_unlock(&dapm->card->dapm_mutex); 2703 2704 return ret; 2705 } 2706 EXPORT_SYMBOL_GPL(snd_soc_dapm_weak_routes); 2707 2708 /** 2709 * snd_soc_dapm_new_widgets - add new dapm widgets 2710 * @dapm: DAPM context 2711 * 2712 * Checks the codec for any new dapm widgets and creates them if found. 2713 * 2714 * Returns 0 for success. 2715 */ 2716 int snd_soc_dapm_new_widgets(struct snd_soc_card *card) 2717 { 2718 struct snd_soc_dapm_widget *w; 2719 unsigned int val; 2720 2721 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT); 2722 2723 list_for_each_entry(w, &card->widgets, list) 2724 { 2725 if (w->new) 2726 continue; 2727 2728 if (w->num_kcontrols) { 2729 w->kcontrols = kzalloc(w->num_kcontrols * 2730 sizeof(struct snd_kcontrol *), 2731 GFP_KERNEL); 2732 if (!w->kcontrols) { 2733 mutex_unlock(&card->dapm_mutex); 2734 return -ENOMEM; 2735 } 2736 } 2737 2738 switch(w->id) { 2739 case snd_soc_dapm_switch: 2740 case snd_soc_dapm_mixer: 2741 case snd_soc_dapm_mixer_named_ctl: 2742 dapm_new_mixer(w); 2743 break; 2744 case snd_soc_dapm_mux: 2745 dapm_new_mux(w); 2746 break; 2747 case snd_soc_dapm_pga: 2748 case snd_soc_dapm_out_drv: 2749 dapm_new_pga(w); 2750 break; 2751 default: 2752 break; 2753 } 2754 2755 /* Read the initial power state from the device */ 2756 if (w->reg >= 0) { 2757 soc_widget_read(w, w->reg, &val); 2758 val = val >> w->shift; 2759 val &= w->mask; 2760 if (val == w->on_val) 2761 w->power = 1; 2762 } 2763 2764 w->new = 1; 2765 2766 dapm_mark_dirty(w, "new widget"); 2767 dapm_debugfs_add_widget(w); 2768 } 2769 2770 dapm_power_widgets(card, SND_SOC_DAPM_STREAM_NOP); 2771 mutex_unlock(&card->dapm_mutex); 2772 return 0; 2773 } 2774 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets); 2775 2776 /** 2777 * snd_soc_dapm_get_volsw - dapm mixer get callback 2778 * @kcontrol: mixer control 2779 * @ucontrol: control element information 2780 * 2781 * Callback to get the value of a dapm mixer control. 2782 * 2783 * Returns 0 for success. 2784 */ 2785 int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol, 2786 struct snd_ctl_elem_value *ucontrol) 2787 { 2788 struct snd_soc_codec *codec = snd_soc_dapm_kcontrol_codec(kcontrol); 2789 struct snd_soc_card *card = codec->card; 2790 struct soc_mixer_control *mc = 2791 (struct soc_mixer_control *)kcontrol->private_value; 2792 int reg = mc->reg; 2793 unsigned int shift = mc->shift; 2794 int max = mc->max; 2795 unsigned int mask = (1 << fls(max)) - 1; 2796 unsigned int invert = mc->invert; 2797 unsigned int val; 2798 2799 if (snd_soc_volsw_is_stereo(mc)) 2800 dev_warn(codec->dapm.dev, 2801 "ASoC: Control '%s' is stereo, which is not supported\n", 2802 kcontrol->id.name); 2803 2804 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 2805 if (dapm_kcontrol_is_powered(kcontrol) && reg != SND_SOC_NOPM) 2806 val = (snd_soc_read(codec, reg) >> shift) & mask; 2807 else 2808 val = dapm_kcontrol_get_value(kcontrol); 2809 mutex_unlock(&card->dapm_mutex); 2810 2811 if (invert) 2812 ucontrol->value.integer.value[0] = max - val; 2813 else 2814 ucontrol->value.integer.value[0] = val; 2815 2816 return 0; 2817 } 2818 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw); 2819 2820 /** 2821 * snd_soc_dapm_put_volsw - dapm mixer set callback 2822 * @kcontrol: mixer control 2823 * @ucontrol: control element information 2824 * 2825 * Callback to set the value of a dapm mixer control. 2826 * 2827 * Returns 0 for success. 2828 */ 2829 int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol, 2830 struct snd_ctl_elem_value *ucontrol) 2831 { 2832 struct snd_soc_codec *codec = snd_soc_dapm_kcontrol_codec(kcontrol); 2833 struct snd_soc_card *card = codec->card; 2834 struct soc_mixer_control *mc = 2835 (struct soc_mixer_control *)kcontrol->private_value; 2836 int reg = mc->reg; 2837 unsigned int shift = mc->shift; 2838 int max = mc->max; 2839 unsigned int mask = (1 << fls(max)) - 1; 2840 unsigned int invert = mc->invert; 2841 unsigned int val; 2842 int connect, change; 2843 struct snd_soc_dapm_update update; 2844 int ret = 0; 2845 2846 if (snd_soc_volsw_is_stereo(mc)) 2847 dev_warn(codec->dapm.dev, 2848 "ASoC: Control '%s' is stereo, which is not supported\n", 2849 kcontrol->id.name); 2850 2851 val = (ucontrol->value.integer.value[0] & mask); 2852 connect = !!val; 2853 2854 if (invert) 2855 val = max - val; 2856 2857 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 2858 2859 change = dapm_kcontrol_set_value(kcontrol, val); 2860 2861 if (reg != SND_SOC_NOPM) { 2862 mask = mask << shift; 2863 val = val << shift; 2864 2865 change = snd_soc_test_bits(codec, reg, mask, val); 2866 } 2867 2868 if (change) { 2869 if (reg != SND_SOC_NOPM) { 2870 update.kcontrol = kcontrol; 2871 update.reg = reg; 2872 update.mask = mask; 2873 update.val = val; 2874 2875 card->update = &update; 2876 } 2877 2878 ret = soc_dapm_mixer_update_power(card, kcontrol, connect); 2879 2880 card->update = NULL; 2881 } 2882 2883 mutex_unlock(&card->dapm_mutex); 2884 2885 if (ret > 0) 2886 soc_dpcm_runtime_update(card); 2887 2888 return change; 2889 } 2890 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw); 2891 2892 /** 2893 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback 2894 * @kcontrol: mixer control 2895 * @ucontrol: control element information 2896 * 2897 * Callback to get the value of a dapm enumerated double mixer control. 2898 * 2899 * Returns 0 for success. 2900 */ 2901 int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol, 2902 struct snd_ctl_elem_value *ucontrol) 2903 { 2904 struct snd_soc_codec *codec = snd_soc_dapm_kcontrol_codec(kcontrol); 2905 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 2906 unsigned int reg_val, val; 2907 2908 if (e->reg != SND_SOC_NOPM) 2909 reg_val = snd_soc_read(codec, e->reg); 2910 else 2911 reg_val = dapm_kcontrol_get_value(kcontrol); 2912 2913 val = (reg_val >> e->shift_l) & e->mask; 2914 ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val); 2915 if (e->shift_l != e->shift_r) { 2916 val = (reg_val >> e->shift_r) & e->mask; 2917 val = snd_soc_enum_val_to_item(e, val); 2918 ucontrol->value.enumerated.item[1] = val; 2919 } 2920 2921 return 0; 2922 } 2923 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double); 2924 2925 /** 2926 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback 2927 * @kcontrol: mixer control 2928 * @ucontrol: control element information 2929 * 2930 * Callback to set the value of a dapm enumerated double mixer control. 2931 * 2932 * Returns 0 for success. 2933 */ 2934 int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol, 2935 struct snd_ctl_elem_value *ucontrol) 2936 { 2937 struct snd_soc_codec *codec = snd_soc_dapm_kcontrol_codec(kcontrol); 2938 struct snd_soc_card *card = codec->card; 2939 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 2940 unsigned int *item = ucontrol->value.enumerated.item; 2941 unsigned int val, change; 2942 unsigned int mask; 2943 struct snd_soc_dapm_update update; 2944 int ret = 0; 2945 2946 if (item[0] >= e->items) 2947 return -EINVAL; 2948 2949 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l; 2950 mask = e->mask << e->shift_l; 2951 if (e->shift_l != e->shift_r) { 2952 if (item[1] > e->items) 2953 return -EINVAL; 2954 val |= snd_soc_enum_item_to_val(e, item[1]) << e->shift_l; 2955 mask |= e->mask << e->shift_r; 2956 } 2957 2958 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 2959 2960 if (e->reg != SND_SOC_NOPM) 2961 change = snd_soc_test_bits(codec, e->reg, mask, val); 2962 else 2963 change = dapm_kcontrol_set_value(kcontrol, val); 2964 2965 if (change) { 2966 if (e->reg != SND_SOC_NOPM) { 2967 update.kcontrol = kcontrol; 2968 update.reg = e->reg; 2969 update.mask = mask; 2970 update.val = val; 2971 card->update = &update; 2972 } 2973 2974 ret = soc_dapm_mux_update_power(card, kcontrol, item[0], e); 2975 2976 card->update = NULL; 2977 } 2978 2979 mutex_unlock(&card->dapm_mutex); 2980 2981 if (ret > 0) 2982 soc_dpcm_runtime_update(card); 2983 2984 return change; 2985 } 2986 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double); 2987 2988 /** 2989 * snd_soc_dapm_info_pin_switch - Info for a pin switch 2990 * 2991 * @kcontrol: mixer control 2992 * @uinfo: control element information 2993 * 2994 * Callback to provide information about a pin switch control. 2995 */ 2996 int snd_soc_dapm_info_pin_switch(struct snd_kcontrol *kcontrol, 2997 struct snd_ctl_elem_info *uinfo) 2998 { 2999 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 3000 uinfo->count = 1; 3001 uinfo->value.integer.min = 0; 3002 uinfo->value.integer.max = 1; 3003 3004 return 0; 3005 } 3006 EXPORT_SYMBOL_GPL(snd_soc_dapm_info_pin_switch); 3007 3008 /** 3009 * snd_soc_dapm_get_pin_switch - Get information for a pin switch 3010 * 3011 * @kcontrol: mixer control 3012 * @ucontrol: Value 3013 */ 3014 int snd_soc_dapm_get_pin_switch(struct snd_kcontrol *kcontrol, 3015 struct snd_ctl_elem_value *ucontrol) 3016 { 3017 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol); 3018 const char *pin = (const char *)kcontrol->private_value; 3019 3020 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 3021 3022 ucontrol->value.integer.value[0] = 3023 snd_soc_dapm_get_pin_status(&card->dapm, pin); 3024 3025 mutex_unlock(&card->dapm_mutex); 3026 3027 return 0; 3028 } 3029 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_switch); 3030 3031 /** 3032 * snd_soc_dapm_put_pin_switch - Set information for a pin switch 3033 * 3034 * @kcontrol: mixer control 3035 * @ucontrol: Value 3036 */ 3037 int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol, 3038 struct snd_ctl_elem_value *ucontrol) 3039 { 3040 struct snd_soc_card *card = snd_kcontrol_chip(kcontrol); 3041 const char *pin = (const char *)kcontrol->private_value; 3042 3043 if (ucontrol->value.integer.value[0]) 3044 snd_soc_dapm_enable_pin(&card->dapm, pin); 3045 else 3046 snd_soc_dapm_disable_pin(&card->dapm, pin); 3047 3048 snd_soc_dapm_sync(&card->dapm); 3049 return 0; 3050 } 3051 EXPORT_SYMBOL_GPL(snd_soc_dapm_put_pin_switch); 3052 3053 static struct snd_soc_dapm_widget * 3054 snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm, 3055 const struct snd_soc_dapm_widget *widget) 3056 { 3057 struct snd_soc_dapm_widget *w; 3058 int ret; 3059 3060 if ((w = dapm_cnew_widget(widget)) == NULL) 3061 return NULL; 3062 3063 switch (w->id) { 3064 case snd_soc_dapm_regulator_supply: 3065 w->regulator = devm_regulator_get(dapm->dev, w->name); 3066 if (IS_ERR(w->regulator)) { 3067 ret = PTR_ERR(w->regulator); 3068 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n", 3069 w->name, ret); 3070 return NULL; 3071 } 3072 3073 if (w->on_val & SND_SOC_DAPM_REGULATOR_BYPASS) { 3074 ret = regulator_allow_bypass(w->regulator, true); 3075 if (ret != 0) 3076 dev_warn(w->dapm->dev, 3077 "ASoC: Failed to bypass %s: %d\n", 3078 w->name, ret); 3079 } 3080 break; 3081 case snd_soc_dapm_clock_supply: 3082 #ifdef CONFIG_CLKDEV_LOOKUP 3083 w->clk = devm_clk_get(dapm->dev, w->name); 3084 if (IS_ERR(w->clk)) { 3085 ret = PTR_ERR(w->clk); 3086 dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n", 3087 w->name, ret); 3088 return NULL; 3089 } 3090 #else 3091 return NULL; 3092 #endif 3093 break; 3094 default: 3095 break; 3096 } 3097 3098 if (dapm->codec && dapm->codec->name_prefix) 3099 w->name = kasprintf(GFP_KERNEL, "%s %s", 3100 dapm->codec->name_prefix, widget->name); 3101 else 3102 w->name = kasprintf(GFP_KERNEL, "%s", widget->name); 3103 3104 if (w->name == NULL) { 3105 kfree(w); 3106 return NULL; 3107 } 3108 3109 switch (w->id) { 3110 case snd_soc_dapm_switch: 3111 case snd_soc_dapm_mixer: 3112 case snd_soc_dapm_mixer_named_ctl: 3113 w->power_check = dapm_generic_check_power; 3114 break; 3115 case snd_soc_dapm_mux: 3116 w->power_check = dapm_generic_check_power; 3117 break; 3118 case snd_soc_dapm_dai_out: 3119 w->power_check = dapm_adc_check_power; 3120 break; 3121 case snd_soc_dapm_dai_in: 3122 w->power_check = dapm_dac_check_power; 3123 break; 3124 case snd_soc_dapm_adc: 3125 case snd_soc_dapm_aif_out: 3126 case snd_soc_dapm_dac: 3127 case snd_soc_dapm_aif_in: 3128 case snd_soc_dapm_pga: 3129 case snd_soc_dapm_out_drv: 3130 case snd_soc_dapm_input: 3131 case snd_soc_dapm_output: 3132 case snd_soc_dapm_micbias: 3133 case snd_soc_dapm_spk: 3134 case snd_soc_dapm_hp: 3135 case snd_soc_dapm_mic: 3136 case snd_soc_dapm_line: 3137 case snd_soc_dapm_dai_link: 3138 w->power_check = dapm_generic_check_power; 3139 break; 3140 case snd_soc_dapm_supply: 3141 case snd_soc_dapm_regulator_supply: 3142 case snd_soc_dapm_clock_supply: 3143 case snd_soc_dapm_kcontrol: 3144 w->power_check = dapm_supply_check_power; 3145 break; 3146 default: 3147 w->power_check = dapm_always_on_check_power; 3148 break; 3149 } 3150 3151 w->dapm = dapm; 3152 w->codec = dapm->codec; 3153 w->platform = dapm->platform; 3154 INIT_LIST_HEAD(&w->sources); 3155 INIT_LIST_HEAD(&w->sinks); 3156 INIT_LIST_HEAD(&w->list); 3157 INIT_LIST_HEAD(&w->dirty); 3158 list_add(&w->list, &dapm->card->widgets); 3159 3160 /* machine layer set ups unconnected pins and insertions */ 3161 w->connected = 1; 3162 return w; 3163 } 3164 3165 /** 3166 * snd_soc_dapm_new_controls - create new dapm controls 3167 * @dapm: DAPM context 3168 * @widget: widget array 3169 * @num: number of widgets 3170 * 3171 * Creates new DAPM controls based upon the templates. 3172 * 3173 * Returns 0 for success else error. 3174 */ 3175 int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm, 3176 const struct snd_soc_dapm_widget *widget, 3177 int num) 3178 { 3179 struct snd_soc_dapm_widget *w; 3180 int i; 3181 int ret = 0; 3182 3183 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_INIT); 3184 for (i = 0; i < num; i++) { 3185 w = snd_soc_dapm_new_control(dapm, widget); 3186 if (!w) { 3187 dev_err(dapm->dev, 3188 "ASoC: Failed to create DAPM control %s\n", 3189 widget->name); 3190 ret = -ENOMEM; 3191 break; 3192 } 3193 widget++; 3194 } 3195 mutex_unlock(&dapm->card->dapm_mutex); 3196 return ret; 3197 } 3198 EXPORT_SYMBOL_GPL(snd_soc_dapm_new_controls); 3199 3200 static int snd_soc_dai_link_event(struct snd_soc_dapm_widget *w, 3201 struct snd_kcontrol *kcontrol, int event) 3202 { 3203 struct snd_soc_dapm_path *source_p, *sink_p; 3204 struct snd_soc_dai *source, *sink; 3205 const struct snd_soc_pcm_stream *config = w->params; 3206 struct snd_pcm_substream substream; 3207 struct snd_pcm_hw_params *params = NULL; 3208 u64 fmt; 3209 int ret; 3210 3211 if (WARN_ON(!config) || 3212 WARN_ON(list_empty(&w->sources) || list_empty(&w->sinks))) 3213 return -EINVAL; 3214 3215 /* We only support a single source and sink, pick the first */ 3216 source_p = list_first_entry(&w->sources, struct snd_soc_dapm_path, 3217 list_sink); 3218 sink_p = list_first_entry(&w->sinks, struct snd_soc_dapm_path, 3219 list_source); 3220 3221 if (WARN_ON(!source_p || !sink_p) || 3222 WARN_ON(!sink_p->source || !source_p->sink) || 3223 WARN_ON(!source_p->source || !sink_p->sink)) 3224 return -EINVAL; 3225 3226 source = source_p->source->priv; 3227 sink = sink_p->sink->priv; 3228 3229 /* Be a little careful as we don't want to overflow the mask array */ 3230 if (config->formats) { 3231 fmt = ffs(config->formats) - 1; 3232 } else { 3233 dev_warn(w->dapm->dev, "ASoC: Invalid format %llx specified\n", 3234 config->formats); 3235 fmt = 0; 3236 } 3237 3238 /* Currently very limited parameter selection */ 3239 params = kzalloc(sizeof(*params), GFP_KERNEL); 3240 if (!params) { 3241 ret = -ENOMEM; 3242 goto out; 3243 } 3244 snd_mask_set(hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT), fmt); 3245 3246 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->min = 3247 config->rate_min; 3248 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE)->max = 3249 config->rate_max; 3250 3251 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->min 3252 = config->channels_min; 3253 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS)->max 3254 = config->channels_max; 3255 3256 memset(&substream, 0, sizeof(substream)); 3257 3258 switch (event) { 3259 case SND_SOC_DAPM_PRE_PMU: 3260 if (source->driver->ops && source->driver->ops->hw_params) { 3261 substream.stream = SNDRV_PCM_STREAM_CAPTURE; 3262 ret = source->driver->ops->hw_params(&substream, 3263 params, source); 3264 if (ret != 0) { 3265 dev_err(source->dev, 3266 "ASoC: hw_params() failed: %d\n", ret); 3267 goto out; 3268 } 3269 } 3270 3271 if (sink->driver->ops && sink->driver->ops->hw_params) { 3272 substream.stream = SNDRV_PCM_STREAM_PLAYBACK; 3273 ret = sink->driver->ops->hw_params(&substream, params, 3274 sink); 3275 if (ret != 0) { 3276 dev_err(sink->dev, 3277 "ASoC: hw_params() failed: %d\n", ret); 3278 goto out; 3279 } 3280 } 3281 break; 3282 3283 case SND_SOC_DAPM_POST_PMU: 3284 ret = snd_soc_dai_digital_mute(sink, 0, 3285 SNDRV_PCM_STREAM_PLAYBACK); 3286 if (ret != 0 && ret != -ENOTSUPP) 3287 dev_warn(sink->dev, "ASoC: Failed to unmute: %d\n", ret); 3288 ret = 0; 3289 break; 3290 3291 case SND_SOC_DAPM_PRE_PMD: 3292 ret = snd_soc_dai_digital_mute(sink, 1, 3293 SNDRV_PCM_STREAM_PLAYBACK); 3294 if (ret != 0 && ret != -ENOTSUPP) 3295 dev_warn(sink->dev, "ASoC: Failed to mute: %d\n", ret); 3296 ret = 0; 3297 break; 3298 3299 default: 3300 WARN(1, "Unknown event %d\n", event); 3301 return -EINVAL; 3302 } 3303 3304 out: 3305 kfree(params); 3306 return ret; 3307 } 3308 3309 int snd_soc_dapm_new_pcm(struct snd_soc_card *card, 3310 const struct snd_soc_pcm_stream *params, 3311 struct snd_soc_dapm_widget *source, 3312 struct snd_soc_dapm_widget *sink) 3313 { 3314 struct snd_soc_dapm_route routes[2]; 3315 struct snd_soc_dapm_widget template; 3316 struct snd_soc_dapm_widget *w; 3317 size_t len; 3318 char *link_name; 3319 3320 len = strlen(source->name) + strlen(sink->name) + 2; 3321 link_name = devm_kzalloc(card->dev, len, GFP_KERNEL); 3322 if (!link_name) 3323 return -ENOMEM; 3324 snprintf(link_name, len, "%s-%s", source->name, sink->name); 3325 3326 memset(&template, 0, sizeof(template)); 3327 template.reg = SND_SOC_NOPM; 3328 template.id = snd_soc_dapm_dai_link; 3329 template.name = link_name; 3330 template.event = snd_soc_dai_link_event; 3331 template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU | 3332 SND_SOC_DAPM_PRE_PMD; 3333 3334 dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name); 3335 3336 w = snd_soc_dapm_new_control(&card->dapm, &template); 3337 if (!w) { 3338 dev_err(card->dev, "ASoC: Failed to create %s widget\n", 3339 link_name); 3340 return -ENOMEM; 3341 } 3342 3343 w->params = params; 3344 3345 memset(&routes, 0, sizeof(routes)); 3346 3347 routes[0].source = source->name; 3348 routes[0].sink = link_name; 3349 routes[1].source = link_name; 3350 routes[1].sink = sink->name; 3351 3352 return snd_soc_dapm_add_routes(&card->dapm, routes, 3353 ARRAY_SIZE(routes)); 3354 } 3355 3356 int snd_soc_dapm_new_dai_widgets(struct snd_soc_dapm_context *dapm, 3357 struct snd_soc_dai *dai) 3358 { 3359 struct snd_soc_dapm_widget template; 3360 struct snd_soc_dapm_widget *w; 3361 3362 WARN_ON(dapm->dev != dai->dev); 3363 3364 memset(&template, 0, sizeof(template)); 3365 template.reg = SND_SOC_NOPM; 3366 3367 if (dai->driver->playback.stream_name) { 3368 template.id = snd_soc_dapm_dai_in; 3369 template.name = dai->driver->playback.stream_name; 3370 template.sname = dai->driver->playback.stream_name; 3371 3372 dev_dbg(dai->dev, "ASoC: adding %s widget\n", 3373 template.name); 3374 3375 w = snd_soc_dapm_new_control(dapm, &template); 3376 if (!w) { 3377 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n", 3378 dai->driver->playback.stream_name); 3379 return -ENOMEM; 3380 } 3381 3382 w->priv = dai; 3383 dai->playback_widget = w; 3384 } 3385 3386 if (dai->driver->capture.stream_name) { 3387 template.id = snd_soc_dapm_dai_out; 3388 template.name = dai->driver->capture.stream_name; 3389 template.sname = dai->driver->capture.stream_name; 3390 3391 dev_dbg(dai->dev, "ASoC: adding %s widget\n", 3392 template.name); 3393 3394 w = snd_soc_dapm_new_control(dapm, &template); 3395 if (!w) { 3396 dev_err(dapm->dev, "ASoC: Failed to create %s widget\n", 3397 dai->driver->capture.stream_name); 3398 return -ENOMEM; 3399 } 3400 3401 w->priv = dai; 3402 dai->capture_widget = w; 3403 } 3404 3405 return 0; 3406 } 3407 3408 int snd_soc_dapm_link_dai_widgets(struct snd_soc_card *card) 3409 { 3410 struct snd_soc_dapm_widget *dai_w, *w; 3411 struct snd_soc_dai *dai; 3412 3413 /* For each DAI widget... */ 3414 list_for_each_entry(dai_w, &card->widgets, list) { 3415 switch (dai_w->id) { 3416 case snd_soc_dapm_dai_in: 3417 case snd_soc_dapm_dai_out: 3418 break; 3419 default: 3420 continue; 3421 } 3422 3423 dai = dai_w->priv; 3424 3425 /* ...find all widgets with the same stream and link them */ 3426 list_for_each_entry(w, &card->widgets, list) { 3427 if (w->dapm != dai_w->dapm) 3428 continue; 3429 3430 switch (w->id) { 3431 case snd_soc_dapm_dai_in: 3432 case snd_soc_dapm_dai_out: 3433 continue; 3434 default: 3435 break; 3436 } 3437 3438 if (!w->sname || !strstr(w->sname, dai_w->name)) 3439 continue; 3440 3441 if (dai->driver->playback.stream_name && 3442 strstr(w->sname, 3443 dai->driver->playback.stream_name)) { 3444 dev_dbg(dai->dev, "%s -> %s\n", 3445 dai->playback_widget->name, w->name); 3446 3447 snd_soc_dapm_add_path(w->dapm, 3448 dai->playback_widget, w, NULL, NULL); 3449 } 3450 3451 if (dai->driver->capture.stream_name && 3452 strstr(w->sname, 3453 dai->driver->capture.stream_name)) { 3454 dev_dbg(dai->dev, "%s -> %s\n", 3455 w->name, dai->capture_widget->name); 3456 3457 snd_soc_dapm_add_path(w->dapm, w, 3458 dai->capture_widget, NULL, NULL); 3459 } 3460 } 3461 } 3462 3463 return 0; 3464 } 3465 3466 void snd_soc_dapm_connect_dai_link_widgets(struct snd_soc_card *card) 3467 { 3468 struct snd_soc_pcm_runtime *rtd = card->rtd; 3469 struct snd_soc_dai *cpu_dai, *codec_dai; 3470 struct snd_soc_dapm_route r; 3471 int i; 3472 3473 memset(&r, 0, sizeof(r)); 3474 3475 /* for each BE DAI link... */ 3476 for (i = 0; i < card->num_rtd; i++) { 3477 rtd = &card->rtd[i]; 3478 cpu_dai = rtd->cpu_dai; 3479 codec_dai = rtd->codec_dai; 3480 3481 /* 3482 * dynamic FE links have no fixed DAI mapping. 3483 * CODEC<->CODEC links have no direct connection. 3484 */ 3485 if (rtd->dai_link->dynamic || rtd->dai_link->params) 3486 continue; 3487 3488 /* there is no point in connecting BE DAI links with dummies */ 3489 if (snd_soc_dai_is_dummy(codec_dai) || 3490 snd_soc_dai_is_dummy(cpu_dai)) 3491 continue; 3492 3493 /* connect BE DAI playback if widgets are valid */ 3494 if (codec_dai->playback_widget && cpu_dai->playback_widget) { 3495 r.source = cpu_dai->playback_widget->name; 3496 r.sink = codec_dai->playback_widget->name; 3497 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n", 3498 cpu_dai->codec->name, r.source, 3499 codec_dai->platform->name, r.sink); 3500 3501 snd_soc_dapm_add_route(&card->dapm, &r, true); 3502 } 3503 3504 /* connect BE DAI capture if widgets are valid */ 3505 if (codec_dai->capture_widget && cpu_dai->capture_widget) { 3506 r.source = codec_dai->capture_widget->name; 3507 r.sink = cpu_dai->capture_widget->name; 3508 dev_dbg(rtd->dev, "connected DAI link %s:%s -> %s:%s\n", 3509 codec_dai->codec->name, r.source, 3510 cpu_dai->platform->name, r.sink); 3511 3512 snd_soc_dapm_add_route(&card->dapm, &r, true); 3513 } 3514 3515 } 3516 } 3517 3518 static void soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream, 3519 int event) 3520 { 3521 3522 struct snd_soc_dapm_widget *w_cpu, *w_codec; 3523 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 3524 struct snd_soc_dai *codec_dai = rtd->codec_dai; 3525 3526 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 3527 w_cpu = cpu_dai->playback_widget; 3528 w_codec = codec_dai->playback_widget; 3529 } else { 3530 w_cpu = cpu_dai->capture_widget; 3531 w_codec = codec_dai->capture_widget; 3532 } 3533 3534 if (w_cpu) { 3535 3536 dapm_mark_dirty(w_cpu, "stream event"); 3537 3538 switch (event) { 3539 case SND_SOC_DAPM_STREAM_START: 3540 w_cpu->active = 1; 3541 break; 3542 case SND_SOC_DAPM_STREAM_STOP: 3543 w_cpu->active = 0; 3544 break; 3545 case SND_SOC_DAPM_STREAM_SUSPEND: 3546 case SND_SOC_DAPM_STREAM_RESUME: 3547 case SND_SOC_DAPM_STREAM_PAUSE_PUSH: 3548 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE: 3549 break; 3550 } 3551 } 3552 3553 if (w_codec) { 3554 3555 dapm_mark_dirty(w_codec, "stream event"); 3556 3557 switch (event) { 3558 case SND_SOC_DAPM_STREAM_START: 3559 w_codec->active = 1; 3560 break; 3561 case SND_SOC_DAPM_STREAM_STOP: 3562 w_codec->active = 0; 3563 break; 3564 case SND_SOC_DAPM_STREAM_SUSPEND: 3565 case SND_SOC_DAPM_STREAM_RESUME: 3566 case SND_SOC_DAPM_STREAM_PAUSE_PUSH: 3567 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE: 3568 break; 3569 } 3570 } 3571 3572 dapm_power_widgets(rtd->card, event); 3573 } 3574 3575 /** 3576 * snd_soc_dapm_stream_event - send a stream event to the dapm core 3577 * @rtd: PCM runtime data 3578 * @stream: stream name 3579 * @event: stream event 3580 * 3581 * Sends a stream event to the dapm core. The core then makes any 3582 * necessary widget power changes. 3583 * 3584 * Returns 0 for success else error. 3585 */ 3586 void snd_soc_dapm_stream_event(struct snd_soc_pcm_runtime *rtd, int stream, 3587 int event) 3588 { 3589 struct snd_soc_card *card = rtd->card; 3590 3591 mutex_lock_nested(&card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 3592 soc_dapm_stream_event(rtd, stream, event); 3593 mutex_unlock(&card->dapm_mutex); 3594 } 3595 3596 /** 3597 * snd_soc_dapm_enable_pin_unlocked - enable pin. 3598 * @dapm: DAPM context 3599 * @pin: pin name 3600 * 3601 * Enables input/output pin and its parents or children widgets iff there is 3602 * a valid audio route and active audio stream. 3603 * 3604 * Requires external locking. 3605 * 3606 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to 3607 * do any widget power switching. 3608 */ 3609 int snd_soc_dapm_enable_pin_unlocked(struct snd_soc_dapm_context *dapm, 3610 const char *pin) 3611 { 3612 return snd_soc_dapm_set_pin(dapm, pin, 1); 3613 } 3614 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin_unlocked); 3615 3616 /** 3617 * snd_soc_dapm_enable_pin - enable pin. 3618 * @dapm: DAPM context 3619 * @pin: pin name 3620 * 3621 * Enables input/output pin and its parents or children widgets iff there is 3622 * a valid audio route and active audio stream. 3623 * 3624 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to 3625 * do any widget power switching. 3626 */ 3627 int snd_soc_dapm_enable_pin(struct snd_soc_dapm_context *dapm, const char *pin) 3628 { 3629 int ret; 3630 3631 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 3632 3633 ret = snd_soc_dapm_set_pin(dapm, pin, 1); 3634 3635 mutex_unlock(&dapm->card->dapm_mutex); 3636 3637 return ret; 3638 } 3639 EXPORT_SYMBOL_GPL(snd_soc_dapm_enable_pin); 3640 3641 /** 3642 * snd_soc_dapm_force_enable_pin_unlocked - force a pin to be enabled 3643 * @dapm: DAPM context 3644 * @pin: pin name 3645 * 3646 * Enables input/output pin regardless of any other state. This is 3647 * intended for use with microphone bias supplies used in microphone 3648 * jack detection. 3649 * 3650 * Requires external locking. 3651 * 3652 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to 3653 * do any widget power switching. 3654 */ 3655 int snd_soc_dapm_force_enable_pin_unlocked(struct snd_soc_dapm_context *dapm, 3656 const char *pin) 3657 { 3658 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true); 3659 3660 if (!w) { 3661 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin); 3662 return -EINVAL; 3663 } 3664 3665 dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin); 3666 w->connected = 1; 3667 w->force = 1; 3668 dapm_mark_dirty(w, "force enable"); 3669 3670 return 0; 3671 } 3672 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin_unlocked); 3673 3674 /** 3675 * snd_soc_dapm_force_enable_pin - force a pin to be enabled 3676 * @dapm: DAPM context 3677 * @pin: pin name 3678 * 3679 * Enables input/output pin regardless of any other state. This is 3680 * intended for use with microphone bias supplies used in microphone 3681 * jack detection. 3682 * 3683 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to 3684 * do any widget power switching. 3685 */ 3686 int snd_soc_dapm_force_enable_pin(struct snd_soc_dapm_context *dapm, 3687 const char *pin) 3688 { 3689 int ret; 3690 3691 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 3692 3693 ret = snd_soc_dapm_force_enable_pin_unlocked(dapm, pin); 3694 3695 mutex_unlock(&dapm->card->dapm_mutex); 3696 3697 return ret; 3698 } 3699 EXPORT_SYMBOL_GPL(snd_soc_dapm_force_enable_pin); 3700 3701 /** 3702 * snd_soc_dapm_disable_pin_unlocked - disable pin. 3703 * @dapm: DAPM context 3704 * @pin: pin name 3705 * 3706 * Disables input/output pin and its parents or children widgets. 3707 * 3708 * Requires external locking. 3709 * 3710 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to 3711 * do any widget power switching. 3712 */ 3713 int snd_soc_dapm_disable_pin_unlocked(struct snd_soc_dapm_context *dapm, 3714 const char *pin) 3715 { 3716 return snd_soc_dapm_set_pin(dapm, pin, 0); 3717 } 3718 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin_unlocked); 3719 3720 /** 3721 * snd_soc_dapm_disable_pin - disable pin. 3722 * @dapm: DAPM context 3723 * @pin: pin name 3724 * 3725 * Disables input/output pin and its parents or children widgets. 3726 * 3727 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to 3728 * do any widget power switching. 3729 */ 3730 int snd_soc_dapm_disable_pin(struct snd_soc_dapm_context *dapm, 3731 const char *pin) 3732 { 3733 int ret; 3734 3735 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 3736 3737 ret = snd_soc_dapm_set_pin(dapm, pin, 0); 3738 3739 mutex_unlock(&dapm->card->dapm_mutex); 3740 3741 return ret; 3742 } 3743 EXPORT_SYMBOL_GPL(snd_soc_dapm_disable_pin); 3744 3745 /** 3746 * snd_soc_dapm_nc_pin_unlocked - permanently disable pin. 3747 * @dapm: DAPM context 3748 * @pin: pin name 3749 * 3750 * Marks the specified pin as being not connected, disabling it along 3751 * any parent or child widgets. At present this is identical to 3752 * snd_soc_dapm_disable_pin() but in future it will be extended to do 3753 * additional things such as disabling controls which only affect 3754 * paths through the pin. 3755 * 3756 * Requires external locking. 3757 * 3758 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to 3759 * do any widget power switching. 3760 */ 3761 int snd_soc_dapm_nc_pin_unlocked(struct snd_soc_dapm_context *dapm, 3762 const char *pin) 3763 { 3764 return snd_soc_dapm_set_pin(dapm, pin, 0); 3765 } 3766 EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin_unlocked); 3767 3768 /** 3769 * snd_soc_dapm_nc_pin - permanently disable pin. 3770 * @dapm: DAPM context 3771 * @pin: pin name 3772 * 3773 * Marks the specified pin as being not connected, disabling it along 3774 * any parent or child widgets. At present this is identical to 3775 * snd_soc_dapm_disable_pin() but in future it will be extended to do 3776 * additional things such as disabling controls which only affect 3777 * paths through the pin. 3778 * 3779 * NOTE: snd_soc_dapm_sync() needs to be called after this for DAPM to 3780 * do any widget power switching. 3781 */ 3782 int snd_soc_dapm_nc_pin(struct snd_soc_dapm_context *dapm, const char *pin) 3783 { 3784 int ret; 3785 3786 mutex_lock_nested(&dapm->card->dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME); 3787 3788 ret = snd_soc_dapm_set_pin(dapm, pin, 0); 3789 3790 mutex_unlock(&dapm->card->dapm_mutex); 3791 3792 return ret; 3793 } 3794 EXPORT_SYMBOL_GPL(snd_soc_dapm_nc_pin); 3795 3796 /** 3797 * snd_soc_dapm_get_pin_status - get audio pin status 3798 * @dapm: DAPM context 3799 * @pin: audio signal pin endpoint (or start point) 3800 * 3801 * Get audio pin status - connected or disconnected. 3802 * 3803 * Returns 1 for connected otherwise 0. 3804 */ 3805 int snd_soc_dapm_get_pin_status(struct snd_soc_dapm_context *dapm, 3806 const char *pin) 3807 { 3808 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true); 3809 3810 if (w) 3811 return w->connected; 3812 3813 return 0; 3814 } 3815 EXPORT_SYMBOL_GPL(snd_soc_dapm_get_pin_status); 3816 3817 /** 3818 * snd_soc_dapm_ignore_suspend - ignore suspend status for DAPM endpoint 3819 * @dapm: DAPM context 3820 * @pin: audio signal pin endpoint (or start point) 3821 * 3822 * Mark the given endpoint or pin as ignoring suspend. When the 3823 * system is disabled a path between two endpoints flagged as ignoring 3824 * suspend will not be disabled. The path must already be enabled via 3825 * normal means at suspend time, it will not be turned on if it was not 3826 * already enabled. 3827 */ 3828 int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm, 3829 const char *pin) 3830 { 3831 struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false); 3832 3833 if (!w) { 3834 dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin); 3835 return -EINVAL; 3836 } 3837 3838 w->ignore_suspend = 1; 3839 3840 return 0; 3841 } 3842 EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend); 3843 3844 static bool snd_soc_dapm_widget_in_card_paths(struct snd_soc_card *card, 3845 struct snd_soc_dapm_widget *w) 3846 { 3847 struct snd_soc_dapm_path *p; 3848 3849 list_for_each_entry(p, &card->paths, list) { 3850 if ((p->source == w) || (p->sink == w)) { 3851 dev_dbg(card->dev, 3852 "... Path %s(id:%d dapm:%p) - %s(id:%d dapm:%p)\n", 3853 p->source->name, p->source->id, p->source->dapm, 3854 p->sink->name, p->sink->id, p->sink->dapm); 3855 3856 /* Connected to something other than the codec */ 3857 if (p->source->dapm != p->sink->dapm) 3858 return true; 3859 /* 3860 * Loopback connection from codec external pin to 3861 * codec external pin 3862 */ 3863 if (p->sink->id == snd_soc_dapm_input) { 3864 switch (p->source->id) { 3865 case snd_soc_dapm_output: 3866 case snd_soc_dapm_micbias: 3867 return true; 3868 default: 3869 break; 3870 } 3871 } 3872 } 3873 } 3874 3875 return false; 3876 } 3877 3878 /** 3879 * snd_soc_dapm_auto_nc_codec_pins - call snd_soc_dapm_nc_pin for unused pins 3880 * @codec: The codec whose pins should be processed 3881 * 3882 * Automatically call snd_soc_dapm_nc_pin() for any external pins in the codec 3883 * which are unused. Pins are used if they are connected externally to the 3884 * codec, whether that be to some other device, or a loop-back connection to 3885 * the codec itself. 3886 */ 3887 void snd_soc_dapm_auto_nc_codec_pins(struct snd_soc_codec *codec) 3888 { 3889 struct snd_soc_card *card = codec->card; 3890 struct snd_soc_dapm_context *dapm = &codec->dapm; 3891 struct snd_soc_dapm_widget *w; 3892 3893 dev_dbg(codec->dev, "ASoC: Auto NC: DAPMs: card:%p codec:%p\n", 3894 &card->dapm, &codec->dapm); 3895 3896 list_for_each_entry(w, &card->widgets, list) { 3897 if (w->dapm != dapm) 3898 continue; 3899 switch (w->id) { 3900 case snd_soc_dapm_input: 3901 case snd_soc_dapm_output: 3902 case snd_soc_dapm_micbias: 3903 dev_dbg(codec->dev, "ASoC: Auto NC: Checking widget %s\n", 3904 w->name); 3905 if (!snd_soc_dapm_widget_in_card_paths(card, w)) { 3906 dev_dbg(codec->dev, 3907 "... Not in map; disabling\n"); 3908 snd_soc_dapm_nc_pin(dapm, w->name); 3909 } 3910 break; 3911 default: 3912 break; 3913 } 3914 } 3915 } 3916 3917 /** 3918 * snd_soc_dapm_free - free dapm resources 3919 * @dapm: DAPM context 3920 * 3921 * Free all dapm widgets and resources. 3922 */ 3923 void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm) 3924 { 3925 snd_soc_dapm_sys_remove(dapm->dev); 3926 dapm_debugfs_cleanup(dapm); 3927 dapm_free_widgets(dapm); 3928 list_del(&dapm->list); 3929 } 3930 EXPORT_SYMBOL_GPL(snd_soc_dapm_free); 3931 3932 static void soc_dapm_shutdown_dapm(struct snd_soc_dapm_context *dapm) 3933 { 3934 struct snd_soc_card *card = dapm->card; 3935 struct snd_soc_dapm_widget *w; 3936 LIST_HEAD(down_list); 3937 int powerdown = 0; 3938 3939 mutex_lock(&card->dapm_mutex); 3940 3941 list_for_each_entry(w, &dapm->card->widgets, list) { 3942 if (w->dapm != dapm) 3943 continue; 3944 if (w->power) { 3945 dapm_seq_insert(w, &down_list, false); 3946 w->power = 0; 3947 powerdown = 1; 3948 } 3949 } 3950 3951 /* If there were no widgets to power down we're already in 3952 * standby. 3953 */ 3954 if (powerdown) { 3955 if (dapm->bias_level == SND_SOC_BIAS_ON) 3956 snd_soc_dapm_set_bias_level(dapm, 3957 SND_SOC_BIAS_PREPARE); 3958 dapm_seq_run(card, &down_list, 0, false); 3959 if (dapm->bias_level == SND_SOC_BIAS_PREPARE) 3960 snd_soc_dapm_set_bias_level(dapm, 3961 SND_SOC_BIAS_STANDBY); 3962 } 3963 3964 mutex_unlock(&card->dapm_mutex); 3965 } 3966 3967 /* 3968 * snd_soc_dapm_shutdown - callback for system shutdown 3969 */ 3970 void snd_soc_dapm_shutdown(struct snd_soc_card *card) 3971 { 3972 struct snd_soc_dapm_context *dapm; 3973 3974 list_for_each_entry(dapm, &card->dapm_list, list) { 3975 if (dapm != &card->dapm) { 3976 soc_dapm_shutdown_dapm(dapm); 3977 if (dapm->bias_level == SND_SOC_BIAS_STANDBY) 3978 snd_soc_dapm_set_bias_level(dapm, 3979 SND_SOC_BIAS_OFF); 3980 } 3981 } 3982 3983 soc_dapm_shutdown_dapm(&card->dapm); 3984 if (card->dapm.bias_level == SND_SOC_BIAS_STANDBY) 3985 snd_soc_dapm_set_bias_level(&card->dapm, 3986 SND_SOC_BIAS_OFF); 3987 } 3988 3989 /* Module information */ 3990 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk"); 3991 MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC"); 3992 MODULE_LICENSE("GPL"); 3993