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