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