1/* 2 * soc-dapm.c -- ALSA SoC Dynamic Audio Power Management 3 * 4 * Copyright 2005 Wolfson Microelectronics PLC. 5 * Author: Liam Girdwood 6 * liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the 10 * Free Software Foundation; either version 2 of the License, or (at your 11 * option) any later version. 12 * 13 * Revision history 14 * 12th Aug 2005 Initial version. 15 * 25th Oct 2005 Implemented path power domain. 16 * 18th Dec 2005 Implemented machine and stream level power domain. 17 * 18 * Features: 19 * o Changes power status of internal codec blocks depending on the 20 * dynamic configuration of codec internal audio paths and active 21 * DAC's/ADC's. 22 * o Platform power domain - can support external components i.e. amps and 23 * mic/meadphone insertion events. 24 * o Automatic Mic Bias support 25 * o Jack insertion power event initiation - e.g. hp insertion will enable 26 * sinks, dacs, etc 27 * o Delayed powerdown of audio susbsytem to reduce pops between a quick 28 * device reopen. 29 * 30 * Todo: 31 * o DAPM power change sequencing - allow for configurable per 32 * codec sequences. 33 * o Support for analogue bias optimisation. 34 * o Support for reduced codec oversampling rates. 35 * o Support for reduced codec bias currents. 36 */ 37 38#include <linux/module.h> 39#include <linux/moduleparam.h> 40#include <linux/init.h> 41#include <linux/delay.h> 42#include <linux/pm.h> 43#include <linux/bitops.h> 44#include <linux/platform_device.h> 45#include <linux/jiffies.h> 46#include <sound/driver.h> 47#include <sound/core.h> 48#include <sound/pcm.h> 49#include <sound/pcm_params.h> 50#include <sound/soc-dapm.h> 51#include <sound/initval.h> 52 53/* debug */ 54#define DAPM_DEBUG 0 55#if DAPM_DEBUG 56#define dump_dapm(codec, action) dbg_dump_dapm(codec, action) 57#define dbg(format, arg...) printk(format, ## arg) 58#else 59#define dump_dapm(codec, action) 60#define dbg(format, arg...) 61#endif 62 63#define POP_DEBUG 0 64#if POP_DEBUG 65#define POP_TIME 500 /* 500 msecs - change if pop debug is too fast */ 66#define pop_wait(time) schedule_timeout_interruptible(msecs_to_jiffies(time)) 67#define pop_dbg(format, arg...) printk(format, ## arg); pop_wait(POP_TIME) 68#else 69#define pop_dbg(format, arg...) 70#define pop_wait(time) 71#endif 72 73/* dapm power sequences - make this per codec in the future */ 74static int dapm_up_seq[] = { 75 snd_soc_dapm_pre, snd_soc_dapm_micbias, snd_soc_dapm_mic, 76 snd_soc_dapm_mux, snd_soc_dapm_dac, snd_soc_dapm_mixer, snd_soc_dapm_pga, 77 snd_soc_dapm_adc, snd_soc_dapm_hp, snd_soc_dapm_spk, snd_soc_dapm_post 78}; 79static int dapm_down_seq[] = { 80 snd_soc_dapm_pre, snd_soc_dapm_adc, snd_soc_dapm_hp, snd_soc_dapm_spk, 81 snd_soc_dapm_pga, snd_soc_dapm_mixer, snd_soc_dapm_dac, snd_soc_dapm_mic, 82 snd_soc_dapm_micbias, snd_soc_dapm_mux, snd_soc_dapm_post 83}; 84 85static int dapm_status = 1; 86module_param(dapm_status, int, 0); 87MODULE_PARM_DESC(dapm_status, "enable DPM sysfs entries"); 88 89/* create a new dapm widget */ 90static inline struct snd_soc_dapm_widget *dapm_cnew_widget( 91 const struct snd_soc_dapm_widget *_widget) 92{ 93 return kmemdup(_widget, sizeof(*_widget), GFP_KERNEL); 94} 95 96/* set up initial codec paths */ 97static void dapm_set_path_status(struct snd_soc_dapm_widget *w, 98 struct snd_soc_dapm_path *p, int i) 99{ 100 switch (w->id) { 101 case snd_soc_dapm_switch: 102 case snd_soc_dapm_mixer: { 103 int val; 104 int reg = w->kcontrols[i].private_value & 0xff; 105 int shift = (w->kcontrols[i].private_value >> 8) & 0x0f; 106 int mask = (w->kcontrols[i].private_value >> 16) & 0xff; 107 int invert = (w->kcontrols[i].private_value >> 24) & 0x01; 108 109 val = snd_soc_read(w->codec, reg); 110 val = (val >> shift) & mask; 111 112 if ((invert && !val) || (!invert && val)) 113 p->connect = 1; 114 else 115 p->connect = 0; 116 } 117 break; 118 case snd_soc_dapm_mux: { 119 struct soc_enum *e = (struct soc_enum *)w->kcontrols[i].private_value; 120 int val, item, bitmask; 121 122 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1) 123 ; 124 val = snd_soc_read(w->codec, e->reg); 125 item = (val >> e->shift_l) & (bitmask - 1); 126 127 p->connect = 0; 128 for (i = 0; i < e->mask; i++) { 129 if (!(strcmp(p->name, e->texts[i])) && item == i) 130 p->connect = 1; 131 } 132 } 133 break; 134 /* does not effect routing - always connected */ 135 case snd_soc_dapm_pga: 136 case snd_soc_dapm_output: 137 case snd_soc_dapm_adc: 138 case snd_soc_dapm_input: 139 case snd_soc_dapm_dac: 140 case snd_soc_dapm_micbias: 141 case snd_soc_dapm_vmid: 142 p->connect = 1; 143 break; 144 /* does effect routing - dynamically connected */ 145 case snd_soc_dapm_hp: 146 case snd_soc_dapm_mic: 147 case snd_soc_dapm_spk: 148 case snd_soc_dapm_line: 149 case snd_soc_dapm_pre: 150 case snd_soc_dapm_post: 151 p->connect = 0; 152 break; 153 } 154} 155 156/* connect mux widget to it's interconnecting audio paths */ 157static int dapm_connect_mux(struct snd_soc_codec *codec, 158 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest, 159 struct snd_soc_dapm_path *path, const char *control_name, 160 const struct snd_kcontrol_new *kcontrol) 161{ 162 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 163 int i; 164 165 for (i = 0; i < e->mask; i++) { 166 if (!(strcmp(control_name, e->texts[i]))) { 167 list_add(&path->list, &codec->dapm_paths); 168 list_add(&path->list_sink, &dest->sources); 169 list_add(&path->list_source, &src->sinks); 170 path->name = (char*)e->texts[i]; 171 dapm_set_path_status(dest, path, 0); 172 return 0; 173 } 174 } 175 176 return -ENODEV; 177} 178 179/* connect mixer widget to it's interconnecting audio paths */ 180static int dapm_connect_mixer(struct snd_soc_codec *codec, 181 struct snd_soc_dapm_widget *src, struct snd_soc_dapm_widget *dest, 182 struct snd_soc_dapm_path *path, const char *control_name) 183{ 184 int i; 185 186 /* search for mixer kcontrol */ 187 for (i = 0; i < dest->num_kcontrols; i++) { 188 if (!strcmp(control_name, dest->kcontrols[i].name)) { 189 list_add(&path->list, &codec->dapm_paths); 190 list_add(&path->list_sink, &dest->sources); 191 list_add(&path->list_source, &src->sinks); 192 path->name = dest->kcontrols[i].name; 193 dapm_set_path_status(dest, path, i); 194 return 0; 195 } 196 } 197 return -ENODEV; 198} 199 200/* update dapm codec register bits */ 201static int dapm_update_bits(struct snd_soc_dapm_widget *widget) 202{ 203 int change, power; 204 unsigned short old, new; 205 struct snd_soc_codec *codec = widget->codec; 206 207 /* check for valid widgets */ 208 if (widget->reg < 0 || widget->id == snd_soc_dapm_input || 209 widget->id == snd_soc_dapm_output || 210 widget->id == snd_soc_dapm_hp || 211 widget->id == snd_soc_dapm_mic || 212 widget->id == snd_soc_dapm_line || 213 widget->id == snd_soc_dapm_spk) 214 return 0; 215 216 power = widget->power; 217 if (widget->invert) 218 power = (power ? 0:1); 219 220 old = snd_soc_read(codec, widget->reg); 221 new = (old & ~(0x1 << widget->shift)) | (power << widget->shift); 222 223 change = old != new; 224 if (change) { 225 pop_dbg("pop test %s : %s in %d ms\n", widget->name, 226 widget->power ? "on" : "off", POP_TIME); 227 snd_soc_write(codec, widget->reg, new); 228 pop_wait(POP_TIME); 229 } 230 dbg("reg old %x new %x change %d\n", old, new, change); 231 return change; 232} 233 234/* ramps the volume up or down to minimise pops before or after a 235 * DAPM power event */ 236static int dapm_set_pga(struct snd_soc_dapm_widget *widget, int power) 237{ 238 const struct snd_kcontrol_new *k = widget->kcontrols; 239 240 if (widget->muted && !power) 241 return 0; 242 if (!widget->muted && power) 243 return 0; 244 245 if (widget->num_kcontrols && k) { 246 int reg = k->private_value & 0xff; 247 int shift = (k->private_value >> 8) & 0x0f; 248 int mask = (k->private_value >> 16) & 0xff; 249 int invert = (k->private_value >> 24) & 0x01; 250 251 if (power) { 252 int i; 253 /* power up has happended, increase volume to last level */ 254 if (invert) { 255 for (i = mask; i > widget->saved_value; i--) 256 snd_soc_update_bits(widget->codec, reg, mask, i); 257 } else { 258 for (i = 0; i < widget->saved_value; i++) 259 snd_soc_update_bits(widget->codec, reg, mask, i); 260 } 261 widget->muted = 0; 262 } else { 263 /* power down is about to occur, decrease volume to mute */ 264 int val = snd_soc_read(widget->codec, reg); 265 int i = widget->saved_value = (val >> shift) & mask; 266 if (invert) { 267 for (; i < mask; i++) 268 snd_soc_update_bits(widget->codec, reg, mask, i); 269 } else { 270 for (; i > 0; i--) 271 snd_soc_update_bits(widget->codec, reg, mask, i); 272 } 273 widget->muted = 1; 274 } 275 } 276 return 0; 277} 278 279/* create new dapm mixer control */ 280static int dapm_new_mixer(struct snd_soc_codec *codec, 281 struct snd_soc_dapm_widget *w) 282{ 283 int i, ret = 0; 284 char name[32]; 285 struct snd_soc_dapm_path *path; 286 287 /* add kcontrol */ 288 for (i = 0; i < w->num_kcontrols; i++) { 289 290 /* match name */ 291 list_for_each_entry(path, &w->sources, list_sink) { 292 293 /* mixer/mux paths name must match control name */ 294 if (path->name != (char*)w->kcontrols[i].name) 295 continue; 296 297 /* add dapm control with long name */ 298 snprintf(name, 32, "%s %s", w->name, w->kcontrols[i].name); 299 path->long_name = kstrdup (name, GFP_KERNEL); 300 if (path->long_name == NULL) 301 return -ENOMEM; 302 303 path->kcontrol = snd_soc_cnew(&w->kcontrols[i], w, 304 path->long_name); 305 ret = snd_ctl_add(codec->card, path->kcontrol); 306 if (ret < 0) { 307 printk(KERN_ERR "asoc: failed to add dapm kcontrol %s\n", 308 path->long_name); 309 kfree(path->long_name); 310 path->long_name = NULL; 311 return ret; 312 } 313 } 314 } 315 return ret; 316} 317 318/* create new dapm mux control */ 319static int dapm_new_mux(struct snd_soc_codec *codec, 320 struct snd_soc_dapm_widget *w) 321{ 322 struct snd_soc_dapm_path *path = NULL; 323 struct snd_kcontrol *kcontrol; 324 int ret = 0; 325 326 if (!w->num_kcontrols) { 327 printk(KERN_ERR "asoc: mux %s has no controls\n", w->name); 328 return -EINVAL; 329 } 330 331 kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name); 332 ret = snd_ctl_add(codec->card, kcontrol); 333 if (ret < 0) 334 goto err; 335 336 list_for_each_entry(path, &w->sources, list_sink) 337 path->kcontrol = kcontrol; 338 339 return ret; 340 341err: 342 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name); 343 return ret; 344} 345 346/* create new dapm volume control */ 347static int dapm_new_pga(struct snd_soc_codec *codec, 348 struct snd_soc_dapm_widget *w) 349{ 350 struct snd_kcontrol *kcontrol; 351 int ret = 0; 352 353 if (!w->num_kcontrols) 354 return -EINVAL; 355 356 kcontrol = snd_soc_cnew(&w->kcontrols[0], w, w->name); 357 ret = snd_ctl_add(codec->card, kcontrol); 358 if (ret < 0) { 359 printk(KERN_ERR "asoc: failed to add kcontrol %s\n", w->name); 360 return ret; 361 } 362 363 return ret; 364} 365 366/* reset 'walked' bit for each dapm path */ 367static inline void dapm_clear_walk(struct snd_soc_codec *codec) 368{ 369 struct snd_soc_dapm_path *p; 370 371 list_for_each_entry(p, &codec->dapm_paths, list) 372 p->walked = 0; 373} 374 375/* 376 * Recursively check for a completed path to an active or physically connected 377 * output widget. Returns number of complete paths. 378 */ 379static int is_connected_output_ep(struct snd_soc_dapm_widget *widget) 380{ 381 struct snd_soc_dapm_path *path; 382 int con = 0; 383 384 if (widget->id == snd_soc_dapm_adc && widget->active) 385 return 1; 386 387 if (widget->connected) { 388 /* connected pin ? */ 389 if (widget->id == snd_soc_dapm_output && !widget->ext) 390 return 1; 391 392 /* connected jack or spk ? */ 393 if (widget->id == snd_soc_dapm_hp || widget->id == snd_soc_dapm_spk || 394 widget->id == snd_soc_dapm_line) 395 return 1; 396 } 397 398 list_for_each_entry(path, &widget->sinks, list_source) { 399 if (path->walked) 400 continue; 401 402 if (path->sink && path->connect) { 403 path->walked = 1; 404 con += is_connected_output_ep(path->sink); 405 } 406 } 407 408 return con; 409} 410 411/* 412 * Recursively check for a completed path to an active or physically connected 413 * input widget. Returns number of complete paths. 414 */ 415static int is_connected_input_ep(struct snd_soc_dapm_widget *widget) 416{ 417 struct snd_soc_dapm_path *path; 418 int con = 0; 419 420 /* active stream ? */ 421 if (widget->id == snd_soc_dapm_dac && widget->active) 422 return 1; 423 424 if (widget->connected) { 425 /* connected pin ? */ 426 if (widget->id == snd_soc_dapm_input && !widget->ext) 427 return 1; 428 429 /* connected VMID/Bias for lower pops */ 430 if (widget->id == snd_soc_dapm_vmid) 431 return 1; 432 433 /* connected jack ? */ 434 if (widget->id == snd_soc_dapm_mic || widget->id == snd_soc_dapm_line) 435 return 1; 436 } 437 438 list_for_each_entry(path, &widget->sources, list_sink) { 439 if (path->walked) 440 continue; 441 442 if (path->source && path->connect) { 443 path->walked = 1; 444 con += is_connected_input_ep(path->source); 445 } 446 } 447 448 return con; 449} 450 451/* 452 * Scan each dapm widget for complete audio path. 453 * A complete path is a route that has valid endpoints i.e.:- 454 * 455 * o DAC to output pin. 456 * o Input Pin to ADC. 457 * o Input pin to Output pin (bypass, sidetone) 458 * o DAC to ADC (loopback). 459 */ 460static int dapm_power_widgets(struct snd_soc_codec *codec, int event) 461{ 462 struct snd_soc_dapm_widget *w; 463 int in, out, i, c = 1, *seq = NULL, ret = 0, power_change, power; 464 465 /* do we have a sequenced stream event */ 466 if (event == SND_SOC_DAPM_STREAM_START) { 467 c = ARRAY_SIZE(dapm_up_seq); 468 seq = dapm_up_seq; 469 } else if (event == SND_SOC_DAPM_STREAM_STOP) { 470 c = ARRAY_SIZE(dapm_down_seq); 471 seq = dapm_down_seq; 472 } 473 474 for(i = 0; i < c; i++) { 475 list_for_each_entry(w, &codec->dapm_widgets, list) { 476 477 /* is widget in stream order */ 478 if (seq && seq[i] && w->id != seq[i]) 479 continue; 480 481 /* vmid - no action */ 482 if (w->id == snd_soc_dapm_vmid) 483 continue; 484 485 /* active ADC */ 486 if (w->id == snd_soc_dapm_adc && w->active) { 487 in = is_connected_input_ep(w); 488 dapm_clear_walk(w->codec); 489 w->power = (in != 0) ? 1 : 0; 490 dapm_update_bits(w); 491 continue; 492 } 493 494 /* active DAC */ 495 if (w->id == snd_soc_dapm_dac && w->active) { 496 out = is_connected_output_ep(w); 497 dapm_clear_walk(w->codec); 498 w->power = (out != 0) ? 1 : 0; 499 dapm_update_bits(w); 500 continue; 501 } 502 503 /* programmable gain/attenuation */ 504 if (w->id == snd_soc_dapm_pga) { 505 int on; 506 in = is_connected_input_ep(w); 507 dapm_clear_walk(w->codec); 508 out = is_connected_output_ep(w); 509 dapm_clear_walk(w->codec); 510 w->power = on = (out != 0 && in != 0) ? 1 : 0; 511 512 if (!on) 513 dapm_set_pga(w, on); /* lower volume to reduce pops */ 514 dapm_update_bits(w); 515 if (on) 516 dapm_set_pga(w, on); /* restore volume from zero */ 517 518 continue; 519 } 520 521 /* pre and post event widgets */ 522 if (w->id == snd_soc_dapm_pre) { 523 if (!w->event) 524 continue; 525 526 if (event == SND_SOC_DAPM_STREAM_START) { 527 ret = w->event(w, SND_SOC_DAPM_PRE_PMU); 528 if (ret < 0) 529 return ret; 530 } else if (event == SND_SOC_DAPM_STREAM_STOP) { 531 ret = w->event(w, SND_SOC_DAPM_PRE_PMD); 532 if (ret < 0) 533 return ret; 534 } 535 continue; 536 } 537 if (w->id == snd_soc_dapm_post) { 538 if (!w->event) 539 continue; 540 541 if (event == SND_SOC_DAPM_STREAM_START) { 542 ret = w->event(w, SND_SOC_DAPM_POST_PMU); 543 if (ret < 0) 544 return ret; 545 } else if (event == SND_SOC_DAPM_STREAM_STOP) { 546 ret = w->event(w, SND_SOC_DAPM_POST_PMD); 547 if (ret < 0) 548 return ret; 549 } 550 continue; 551 } 552 553 /* all other widgets */ 554 in = is_connected_input_ep(w); 555 dapm_clear_walk(w->codec); 556 out = is_connected_output_ep(w); 557 dapm_clear_walk(w->codec); 558 power = (out != 0 && in != 0) ? 1 : 0; 559 power_change = (w->power == power) ? 0: 1; 560 w->power = power; 561 562 /* call any power change event handlers */ 563 if (power_change) { 564 if (w->event) { 565 dbg("power %s event for %s flags %x\n", 566 w->power ? "on" : "off", w->name, w->event_flags); 567 if (power) { 568 /* power up event */ 569 if (w->event_flags & SND_SOC_DAPM_PRE_PMU) { 570 ret = w->event(w, SND_SOC_DAPM_PRE_PMU); 571 if (ret < 0) 572 return ret; 573 } 574 dapm_update_bits(w); 575 if (w->event_flags & SND_SOC_DAPM_POST_PMU){ 576 ret = w->event(w, SND_SOC_DAPM_POST_PMU); 577 if (ret < 0) 578 return ret; 579 } 580 } else { 581 /* power down event */ 582 if (w->event_flags & SND_SOC_DAPM_PRE_PMD) { 583 ret = w->event(w, SND_SOC_DAPM_PRE_PMD); 584 if (ret < 0) 585 return ret; 586 } 587 dapm_update_bits(w); 588 if (w->event_flags & SND_SOC_DAPM_POST_PMD) { 589 ret = w->event(w, SND_SOC_DAPM_POST_PMD); 590 if (ret < 0) 591 return ret; 592 } 593 } 594 } else 595 /* no event handler */ 596 dapm_update_bits(w); 597 } 598 } 599 } 600 601 return ret; 602} 603 604#if DAPM_DEBUG 605static void dbg_dump_dapm(struct snd_soc_codec* codec, const char *action) 606{ 607 struct snd_soc_dapm_widget *w; 608 struct snd_soc_dapm_path *p = NULL; 609 int in, out; 610 611 printk("DAPM %s %s\n", codec->name, action); 612 613 list_for_each_entry(w, &codec->dapm_widgets, list) { 614 615 /* only display widgets that effect routing */ 616 switch (w->id) { 617 case snd_soc_dapm_pre: 618 case snd_soc_dapm_post: 619 case snd_soc_dapm_vmid: 620 continue; 621 case snd_soc_dapm_mux: 622 case snd_soc_dapm_output: 623 case snd_soc_dapm_input: 624 case snd_soc_dapm_switch: 625 case snd_soc_dapm_hp: 626 case snd_soc_dapm_mic: 627 case snd_soc_dapm_spk: 628 case snd_soc_dapm_line: 629 case snd_soc_dapm_micbias: 630 case snd_soc_dapm_dac: 631 case snd_soc_dapm_adc: 632 case snd_soc_dapm_pga: 633 case snd_soc_dapm_mixer: 634 if (w->name) { 635 in = is_connected_input_ep(w); 636 dapm_clear_walk(w->codec); 637 out = is_connected_output_ep(w); 638 dapm_clear_walk(w->codec); 639 printk("%s: %s in %d out %d\n", w->name, 640 w->power ? "On":"Off",in, out); 641 642 list_for_each_entry(p, &w->sources, list_sink) { 643 if (p->connect) 644 printk(" in %s %s\n", p->name ? p->name : "static", 645 p->source->name); 646 } 647 list_for_each_entry(p, &w->sinks, list_source) { 648 if (p->connect) 649 printk(" out %s %s\n", p->name ? p->name : "static", 650 p->sink->name); 651 } 652 } 653 break; 654 } 655 } 656} 657#endif 658 659/* test and update the power status of a mux widget */ 660static int dapm_mux_update_power(struct snd_soc_dapm_widget *widget, 661 struct snd_kcontrol *kcontrol, int mask, 662 int val, struct soc_enum* e) 663{ 664 struct snd_soc_dapm_path *path; 665 int found = 0; 666 667 if (widget->id != snd_soc_dapm_mux) 668 return -ENODEV; 669 670 if (!snd_soc_test_bits(widget->codec, e->reg, mask, val)) 671 return 0; 672 673 /* find dapm widget path assoc with kcontrol */ 674 list_for_each_entry(path, &widget->codec->dapm_paths, list) { 675 if (path->kcontrol != kcontrol) 676 continue; 677 678 if (!path->name || ! e->texts[val]) 679 continue; 680 681 found = 1; 682 /* we now need to match the string in the enum to the path */ 683 if (!(strcmp(path->name, e->texts[val]))) 684 path->connect = 1; /* new connection */ 685 else 686 path->connect = 0; /* old connection must be powered down */ 687 } 688 689 if (found) 690 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP); 691 692 return 0; 693} 694 695/* test and update the power status of a mixer widget */ 696static int dapm_mixer_update_power(struct snd_soc_dapm_widget *widget, 697 struct snd_kcontrol *kcontrol, int reg, 698 int val_mask, int val, int invert) 699{ 700 struct snd_soc_dapm_path *path; 701 int found = 0; 702 703 if (widget->id != snd_soc_dapm_mixer) 704 return -ENODEV; 705 706 if (!snd_soc_test_bits(widget->codec, reg, val_mask, val)) 707 return 0; 708 709 /* find dapm widget path assoc with kcontrol */ 710 list_for_each_entry(path, &widget->codec->dapm_paths, list) { 711 if (path->kcontrol != kcontrol) 712 continue; 713 714 /* found, now check type */ 715 found = 1; 716 if (val) 717 /* new connection */ 718 path->connect = invert ? 0:1; 719 else 720 /* old connection must be powered down */ 721 path->connect = invert ? 1:0; 722 break; 723 } 724 725 if (found) 726 dapm_power_widgets(widget->codec, SND_SOC_DAPM_STREAM_NOP); 727 728 return 0; 729} 730 731/* show dapm widget status in sys fs */ 732static ssize_t dapm_widget_show(struct device *dev, 733 struct device_attribute *attr, char *buf) 734{ 735 struct snd_soc_device *devdata = dev_get_drvdata(dev); 736 struct snd_soc_codec *codec = devdata->codec; 737 struct snd_soc_dapm_widget *w; 738 int count = 0; 739 char *state = "not set"; 740 741 list_for_each_entry(w, &codec->dapm_widgets, list) { 742 743 /* only display widgets that burnm power */ 744 switch (w->id) { 745 case snd_soc_dapm_hp: 746 case snd_soc_dapm_mic: 747 case snd_soc_dapm_spk: 748 case snd_soc_dapm_line: 749 case snd_soc_dapm_micbias: 750 case snd_soc_dapm_dac: 751 case snd_soc_dapm_adc: 752 case snd_soc_dapm_pga: 753 case snd_soc_dapm_mixer: 754 if (w->name) 755 count += sprintf(buf + count, "%s: %s\n", 756 w->name, w->power ? "On":"Off"); 757 break; 758 default: 759 break; 760 } 761 } 762 763 switch(codec->dapm_state){ 764 case SNDRV_CTL_POWER_D0: 765 state = "D0"; 766 break; 767 case SNDRV_CTL_POWER_D1: 768 state = "D1"; 769 break; 770 case SNDRV_CTL_POWER_D2: 771 state = "D2"; 772 break; 773 case SNDRV_CTL_POWER_D3hot: 774 state = "D3hot"; 775 break; 776 case SNDRV_CTL_POWER_D3cold: 777 state = "D3cold"; 778 break; 779 } 780 count += sprintf(buf + count, "PM State: %s\n", state); 781 782 return count; 783} 784 785static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL); 786 787int snd_soc_dapm_sys_add(struct device *dev) 788{ 789 int ret = 0; 790 791 if (dapm_status) 792 ret = device_create_file(dev, &dev_attr_dapm_widget); 793 794 return ret; 795} 796 797static void snd_soc_dapm_sys_remove(struct device *dev) 798{ 799 if (dapm_status) 800 device_remove_file(dev, &dev_attr_dapm_widget); 801} 802 803/* free all dapm widgets and resources */ 804static void dapm_free_widgets(struct snd_soc_codec *codec) 805{ 806 struct snd_soc_dapm_widget *w, *next_w; 807 struct snd_soc_dapm_path *p, *next_p; 808 809 list_for_each_entry_safe(w, next_w, &codec->dapm_widgets, list) { 810 list_del(&w->list); 811 kfree(w); 812 } 813 814 list_for_each_entry_safe(p, next_p, &codec->dapm_paths, list) { 815 list_del(&p->list); 816 kfree(p->long_name); 817 kfree(p); 818 } 819} 820 821/** 822 * snd_soc_dapm_sync_endpoints - scan and power dapm paths 823 * @codec: audio codec 824 * 825 * Walks all dapm audio paths and powers widgets according to their 826 * stream or path usage. 827 * 828 * Returns 0 for success. 829 */ 830int snd_soc_dapm_sync_endpoints(struct snd_soc_codec *codec) 831{ 832 return dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP); 833} 834EXPORT_SYMBOL_GPL(snd_soc_dapm_sync_endpoints); 835 836/** 837 * snd_soc_dapm_connect_input - connect dapm widgets 838 * @codec: audio codec 839 * @sink: name of target widget 840 * @control: mixer control name 841 * @source: name of source name 842 * 843 * Connects 2 dapm widgets together via a named audio path. The sink is 844 * the widget receiving the audio signal, whilst the source is the sender 845 * of the audio signal. 846 * 847 * Returns 0 for success else error. 848 */ 849int snd_soc_dapm_connect_input(struct snd_soc_codec *codec, const char *sink, 850 const char * control, const char *source) 851{ 852 struct snd_soc_dapm_path *path; 853 struct snd_soc_dapm_widget *wsource = NULL, *wsink = NULL, *w; 854 int ret = 0; 855 856 /* find src and dest widgets */ 857 list_for_each_entry(w, &codec->dapm_widgets, list) { 858 859 if (!wsink && !(strcmp(w->name, sink))) { 860 wsink = w; 861 continue; 862 } 863 if (!wsource && !(strcmp(w->name, source))) { 864 wsource = w; 865 } 866 } 867 868 if (wsource == NULL || wsink == NULL) 869 return -ENODEV; 870 871 path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL); 872 if (!path) 873 return -ENOMEM; 874 875 path->source = wsource; 876 path->sink = wsink; 877 INIT_LIST_HEAD(&path->list); 878 INIT_LIST_HEAD(&path->list_source); 879 INIT_LIST_HEAD(&path->list_sink); 880 881 /* check for external widgets */ 882 if (wsink->id == snd_soc_dapm_input) { 883 if (wsource->id == snd_soc_dapm_micbias || 884 wsource->id == snd_soc_dapm_mic || 885 wsink->id == snd_soc_dapm_line || 886 wsink->id == snd_soc_dapm_output) 887 wsink->ext = 1; 888 } 889 if (wsource->id == snd_soc_dapm_output) { 890 if (wsink->id == snd_soc_dapm_spk || 891 wsink->id == snd_soc_dapm_hp || 892 wsink->id == snd_soc_dapm_line || 893 wsink->id == snd_soc_dapm_input) 894 wsource->ext = 1; 895 } 896 897 /* connect static paths */ 898 if (control == NULL) { 899 list_add(&path->list, &codec->dapm_paths); 900 list_add(&path->list_sink, &wsink->sources); 901 list_add(&path->list_source, &wsource->sinks); 902 path->connect = 1; 903 return 0; 904 } 905 906 /* connect dynamic paths */ 907 switch(wsink->id) { 908 case snd_soc_dapm_adc: 909 case snd_soc_dapm_dac: 910 case snd_soc_dapm_pga: 911 case snd_soc_dapm_input: 912 case snd_soc_dapm_output: 913 case snd_soc_dapm_micbias: 914 case snd_soc_dapm_vmid: 915 case snd_soc_dapm_pre: 916 case snd_soc_dapm_post: 917 list_add(&path->list, &codec->dapm_paths); 918 list_add(&path->list_sink, &wsink->sources); 919 list_add(&path->list_source, &wsource->sinks); 920 path->connect = 1; 921 return 0; 922 case snd_soc_dapm_mux: 923 ret = dapm_connect_mux(codec, wsource, wsink, path, control, 924 &wsink->kcontrols[0]); 925 if (ret != 0) 926 goto err; 927 break; 928 case snd_soc_dapm_switch: 929 case snd_soc_dapm_mixer: 930 ret = dapm_connect_mixer(codec, wsource, wsink, path, control); 931 if (ret != 0) 932 goto err; 933 break; 934 case snd_soc_dapm_hp: 935 case snd_soc_dapm_mic: 936 case snd_soc_dapm_line: 937 case snd_soc_dapm_spk: 938 list_add(&path->list, &codec->dapm_paths); 939 list_add(&path->list_sink, &wsink->sources); 940 list_add(&path->list_source, &wsource->sinks); 941 path->connect = 0; 942 return 0; 943 } 944 return 0; 945 946err: 947 printk(KERN_WARNING "asoc: no dapm match for %s --> %s --> %s\n", source, 948 control, sink); 949 kfree(path); 950 return ret; 951} 952EXPORT_SYMBOL_GPL(snd_soc_dapm_connect_input); 953 954/** 955 * snd_soc_dapm_new_widgets - add new dapm widgets 956 * @codec: audio codec 957 * 958 * Checks the codec for any new dapm widgets and creates them if found. 959 * 960 * Returns 0 for success. 961 */ 962int snd_soc_dapm_new_widgets(struct snd_soc_codec *codec) 963{ 964 struct snd_soc_dapm_widget *w; 965 966 mutex_lock(&codec->mutex); 967 list_for_each_entry(w, &codec->dapm_widgets, list) 968 { 969 if (w->new) 970 continue; 971 972 switch(w->id) { 973 case snd_soc_dapm_switch: 974 case snd_soc_dapm_mixer: 975 dapm_new_mixer(codec, w); 976 break; 977 case snd_soc_dapm_mux: 978 dapm_new_mux(codec, w); 979 break; 980 case snd_soc_dapm_adc: 981 case snd_soc_dapm_dac: 982 case snd_soc_dapm_pga: 983 dapm_new_pga(codec, w); 984 break; 985 case snd_soc_dapm_input: 986 case snd_soc_dapm_output: 987 case snd_soc_dapm_micbias: 988 case snd_soc_dapm_spk: 989 case snd_soc_dapm_hp: 990 case snd_soc_dapm_mic: 991 case snd_soc_dapm_line: 992 case snd_soc_dapm_vmid: 993 case snd_soc_dapm_pre: 994 case snd_soc_dapm_post: 995 break; 996 } 997 w->new = 1; 998 } 999 1000 dapm_power_widgets(codec, SND_SOC_DAPM_STREAM_NOP); 1001 mutex_unlock(&codec->mutex); 1002 return 0; 1003} 1004EXPORT_SYMBOL_GPL(snd_soc_dapm_new_widgets); 1005 1006/** 1007 * snd_soc_dapm_get_volsw - dapm mixer get callback 1008 * @kcontrol: mixer control 1009 * @uinfo: control element information 1010 * 1011 * Callback to get the value of a dapm mixer control. 1012 * 1013 * Returns 0 for success. 1014 */ 1015int snd_soc_dapm_get_volsw(struct snd_kcontrol *kcontrol, 1016 struct snd_ctl_elem_value *ucontrol) 1017{ 1018 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol); 1019 int reg = kcontrol->private_value & 0xff; 1020 int shift = (kcontrol->private_value >> 8) & 0x0f; 1021 int rshift = (kcontrol->private_value >> 12) & 0x0f; 1022 int mask = (kcontrol->private_value >> 16) & 0xff; 1023 int invert = (kcontrol->private_value >> 24) & 0x01; 1024 1025 /* return the saved value if we are powered down */ 1026 if (widget->id == snd_soc_dapm_pga && !widget->power) { 1027 ucontrol->value.integer.value[0] = widget->saved_value; 1028 return 0; 1029 } 1030 1031 ucontrol->value.integer.value[0] = 1032 (snd_soc_read(widget->codec, reg) >> shift) & mask; 1033 if (shift != rshift) 1034 ucontrol->value.integer.value[1] = 1035 (snd_soc_read(widget->codec, reg) >> rshift) & mask; 1036 if (invert) { 1037 ucontrol->value.integer.value[0] = 1038 mask - ucontrol->value.integer.value[0]; 1039 if (shift != rshift) 1040 ucontrol->value.integer.value[1] = 1041 mask - ucontrol->value.integer.value[1]; 1042 } 1043 1044 return 0; 1045} 1046EXPORT_SYMBOL_GPL(snd_soc_dapm_get_volsw); 1047 1048/** 1049 * snd_soc_dapm_put_volsw - dapm mixer set callback 1050 * @kcontrol: mixer control 1051 * @uinfo: control element information 1052 * 1053 * Callback to set the value of a dapm mixer control. 1054 * 1055 * Returns 0 for success. 1056 */ 1057int snd_soc_dapm_put_volsw(struct snd_kcontrol *kcontrol, 1058 struct snd_ctl_elem_value *ucontrol) 1059{ 1060 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol); 1061 int reg = kcontrol->private_value & 0xff; 1062 int shift = (kcontrol->private_value >> 8) & 0x0f; 1063 int rshift = (kcontrol->private_value >> 12) & 0x0f; 1064 int mask = (kcontrol->private_value >> 16) & 0xff; 1065 int invert = (kcontrol->private_value >> 24) & 0x01; 1066 unsigned short val, val2, val_mask; 1067 int ret; 1068 1069 val = (ucontrol->value.integer.value[0] & mask); 1070 1071 if (invert) 1072 val = mask - val; 1073 val_mask = mask << shift; 1074 val = val << shift; 1075 if (shift != rshift) { 1076 val2 = (ucontrol->value.integer.value[1] & mask); 1077 if (invert) 1078 val2 = mask - val2; 1079 val_mask |= mask << rshift; 1080 val |= val2 << rshift; 1081 } 1082 1083 mutex_lock(&widget->codec->mutex); 1084 widget->value = val; 1085 1086 /* save volume value if the widget is powered down */ 1087 if (widget->id == snd_soc_dapm_pga && !widget->power) { 1088 widget->saved_value = val; 1089 mutex_unlock(&widget->codec->mutex); 1090 return 1; 1091 } 1092 1093 dapm_mixer_update_power(widget, kcontrol, reg, val_mask, val, invert); 1094 if (widget->event) { 1095 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) { 1096 ret = widget->event(widget, SND_SOC_DAPM_PRE_REG); 1097 if (ret < 0) 1098 goto out; 1099 } 1100 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val); 1101 if (widget->event_flags & SND_SOC_DAPM_POST_REG) 1102 ret = widget->event(widget, SND_SOC_DAPM_POST_REG); 1103 } else 1104 ret = snd_soc_update_bits(widget->codec, reg, val_mask, val); 1105 1106out: 1107 mutex_unlock(&widget->codec->mutex); 1108 return ret; 1109} 1110EXPORT_SYMBOL_GPL(snd_soc_dapm_put_volsw); 1111 1112/** 1113 * snd_soc_dapm_get_enum_double - dapm enumerated double mixer get callback 1114 * @kcontrol: mixer control 1115 * @uinfo: control element information 1116 * 1117 * Callback to get the value of a dapm enumerated double mixer control. 1118 * 1119 * Returns 0 for success. 1120 */ 1121int snd_soc_dapm_get_enum_double(struct snd_kcontrol *kcontrol, 1122 struct snd_ctl_elem_value *ucontrol) 1123{ 1124 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol); 1125 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 1126 unsigned short val, bitmask; 1127 1128 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1) 1129 ; 1130 val = snd_soc_read(widget->codec, e->reg); 1131 ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1); 1132 if (e->shift_l != e->shift_r) 1133 ucontrol->value.enumerated.item[1] = 1134 (val >> e->shift_r) & (bitmask - 1); 1135 1136 return 0; 1137} 1138EXPORT_SYMBOL_GPL(snd_soc_dapm_get_enum_double); 1139 1140/** 1141 * snd_soc_dapm_put_enum_double - dapm enumerated double mixer set callback 1142 * @kcontrol: mixer control 1143 * @uinfo: control element information 1144 * 1145 * Callback to set the value of a dapm enumerated double mixer control. 1146 * 1147 * Returns 0 for success. 1148 */ 1149int snd_soc_dapm_put_enum_double(struct snd_kcontrol *kcontrol, 1150 struct snd_ctl_elem_value *ucontrol) 1151{ 1152 struct snd_soc_dapm_widget *widget = snd_kcontrol_chip(kcontrol); 1153 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 1154 unsigned short val, mux; 1155 unsigned short mask, bitmask; 1156 int ret = 0; 1157 1158 for (bitmask = 1; bitmask < e->mask; bitmask <<= 1) 1159 ; 1160 if (ucontrol->value.enumerated.item[0] > e->mask - 1) 1161 return -EINVAL; 1162 mux = ucontrol->value.enumerated.item[0]; 1163 val = mux << e->shift_l; 1164 mask = (bitmask - 1) << e->shift_l; 1165 if (e->shift_l != e->shift_r) { 1166 if (ucontrol->value.enumerated.item[1] > e->mask - 1) 1167 return -EINVAL; 1168 val |= ucontrol->value.enumerated.item[1] << e->shift_r; 1169 mask |= (bitmask - 1) << e->shift_r; 1170 } 1171 1172 mutex_lock(&widget->codec->mutex); 1173 widget->value = val; 1174 dapm_mux_update_power(widget, kcontrol, mask, mux, e); 1175 if (widget->event) { 1176 if (widget->event_flags & SND_SOC_DAPM_PRE_REG) { 1177 ret = widget->event(widget, SND_SOC_DAPM_PRE_REG); 1178 if (ret < 0) 1179 goto out; 1180 } 1181 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val); 1182 if (widget->event_flags & SND_SOC_DAPM_POST_REG) 1183 ret = widget->event(widget, SND_SOC_DAPM_POST_REG); 1184 } else 1185 ret = snd_soc_update_bits(widget->codec, e->reg, mask, val); 1186 1187out: 1188 mutex_unlock(&widget->codec->mutex); 1189 return ret; 1190} 1191EXPORT_SYMBOL_GPL(snd_soc_dapm_put_enum_double); 1192 1193/** 1194 * snd_soc_dapm_new_control - create new dapm control 1195 * @codec: audio codec 1196 * @widget: widget template 1197 * 1198 * Creates a new dapm control based upon the template. 1199 * 1200 * Returns 0 for success else error. 1201 */ 1202int snd_soc_dapm_new_control(struct snd_soc_codec *codec, 1203 const struct snd_soc_dapm_widget *widget) 1204{ 1205 struct snd_soc_dapm_widget *w; 1206 1207 if ((w = dapm_cnew_widget(widget)) == NULL) 1208 return -ENOMEM; 1209 1210 w->codec = codec; 1211 INIT_LIST_HEAD(&w->sources); 1212 INIT_LIST_HEAD(&w->sinks); 1213 INIT_LIST_HEAD(&w->list); 1214 list_add(&w->list, &codec->dapm_widgets); 1215 1216 /* machine layer set ups unconnected pins and insertions */ 1217 w->connected = 1; 1218 return 0; 1219} 1220EXPORT_SYMBOL_GPL(snd_soc_dapm_new_control); 1221 1222/** 1223 * snd_soc_dapm_stream_event - send a stream event to the dapm core 1224 * @codec: audio codec 1225 * @stream: stream name 1226 * @event: stream event 1227 * 1228 * Sends a stream event to the dapm core. The core then makes any 1229 * necessary widget power changes. 1230 * 1231 * Returns 0 for success else error. 1232 */ 1233int snd_soc_dapm_stream_event(struct snd_soc_codec *codec, 1234 char *stream, int event) 1235{ 1236 struct snd_soc_dapm_widget *w; 1237 1238 if (stream == NULL) 1239 return 0; 1240 1241 mutex_lock(&codec->mutex); 1242 list_for_each_entry(w, &codec->dapm_widgets, list) 1243 { 1244 if (!w->sname) 1245 continue; 1246 dbg("widget %s\n %s stream %s event %d\n", w->name, w->sname, 1247 stream, event); 1248 if (strstr(w->sname, stream)) { 1249 switch(event) { 1250 case SND_SOC_DAPM_STREAM_START: 1251 w->active = 1; 1252 break; 1253 case SND_SOC_DAPM_STREAM_STOP: 1254 w->active = 0; 1255 break; 1256 case SND_SOC_DAPM_STREAM_SUSPEND: 1257 if (w->active) 1258 w->suspend = 1; 1259 w->active = 0; 1260 break; 1261 case SND_SOC_DAPM_STREAM_RESUME: 1262 if (w->suspend) { 1263 w->active = 1; 1264 w->suspend = 0; 1265 } 1266 break; 1267 case SND_SOC_DAPM_STREAM_PAUSE_PUSH: 1268 break; 1269 case SND_SOC_DAPM_STREAM_PAUSE_RELEASE: 1270 break; 1271 } 1272 } 1273 } 1274 mutex_unlock(&codec->mutex); 1275 1276 dapm_power_widgets(codec, event); 1277 dump_dapm(codec, __FUNCTION__); 1278 return 0; 1279} 1280EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_event); 1281 1282/** 1283 * snd_soc_dapm_set_endpoint - set audio endpoint status 1284 * @codec: audio codec 1285 * @endpoint: audio signal endpoint (or start point) 1286 * @status: point status 1287 * 1288 * Set audio endpoint status - connected or disconnected. 1289 * 1290 * Returns 0 for success else error. 1291 */ 1292int snd_soc_dapm_set_endpoint(struct snd_soc_codec *codec, 1293 char *endpoint, int status) 1294{ 1295 struct snd_soc_dapm_widget *w; 1296 1297 list_for_each_entry(w, &codec->dapm_widgets, list) { 1298 if (!strcmp(w->name, endpoint)) { 1299 w->connected = status; 1300 } 1301 } 1302 1303 return 0; 1304} 1305EXPORT_SYMBOL_GPL(snd_soc_dapm_set_endpoint); 1306 1307/** 1308 * snd_soc_dapm_free - free dapm resources 1309 * @socdev: SoC device 1310 * 1311 * Free all dapm widgets and resources. 1312 */ 1313void snd_soc_dapm_free(struct snd_soc_device *socdev) 1314{ 1315 struct snd_soc_codec *codec = socdev->codec; 1316 1317 snd_soc_dapm_sys_remove(socdev->dev); 1318 dapm_free_widgets(codec); 1319} 1320EXPORT_SYMBOL_GPL(snd_soc_dapm_free); 1321 1322/* Module information */ 1323MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com, www.wolfsonmicro.com"); 1324MODULE_DESCRIPTION("Dynamic Audio Power Management core for ALSA SoC"); 1325MODULE_LICENSE("GPL"); 1326