1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Universal Interface for Intel High Definition Audio Codec 4 * 5 * Generic widget tree parser 6 * 7 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de> 8 */ 9 10 #include <linux/init.h> 11 #include <linux/slab.h> 12 #include <linux/export.h> 13 #include <linux/sort.h> 14 #include <linux/delay.h> 15 #include <linux/ctype.h> 16 #include <linux/string.h> 17 #include <linux/bitops.h> 18 #include <linux/module.h> 19 #include <linux/leds.h> 20 #include <sound/core.h> 21 #include <sound/jack.h> 22 #include <sound/tlv.h> 23 #include <sound/hda_codec.h> 24 #include "hda_local.h" 25 #include "hda_auto_parser.h" 26 #include "hda_jack.h" 27 #include "hda_beep.h" 28 #include "hda_generic.h" 29 30 31 /** 32 * snd_hda_gen_spec_init - initialize hda_gen_spec struct 33 * @spec: hda_gen_spec object to initialize 34 * 35 * Initialize the given hda_gen_spec object. 36 */ 37 int snd_hda_gen_spec_init(struct hda_gen_spec *spec) 38 { 39 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32); 40 snd_array_init(&spec->paths, sizeof(struct nid_path), 8); 41 snd_array_init(&spec->loopback_list, sizeof(struct hda_amp_list), 8); 42 mutex_init(&spec->pcm_mutex); 43 return 0; 44 } 45 EXPORT_SYMBOL_GPL(snd_hda_gen_spec_init); 46 47 /** 48 * snd_hda_gen_add_kctl - Add a new kctl_new struct from the template 49 * @spec: hda_gen_spec object 50 * @name: name string to override the template, NULL if unchanged 51 * @temp: template for the new kctl 52 * 53 * Add a new kctl (actually snd_kcontrol_new to be instantiated later) 54 * element based on the given snd_kcontrol_new template @temp and the 55 * name string @name to the list in @spec. 56 * Returns the newly created object or NULL as error. 57 */ 58 struct snd_kcontrol_new * 59 snd_hda_gen_add_kctl(struct hda_gen_spec *spec, const char *name, 60 const struct snd_kcontrol_new *temp) 61 { 62 struct snd_kcontrol_new *knew = snd_array_new(&spec->kctls); 63 if (!knew) 64 return NULL; 65 *knew = *temp; 66 if (name) 67 knew->name = kstrdup(name, GFP_KERNEL); 68 else if (knew->name) 69 knew->name = kstrdup(knew->name, GFP_KERNEL); 70 if (!knew->name) 71 return NULL; 72 return knew; 73 } 74 EXPORT_SYMBOL_GPL(snd_hda_gen_add_kctl); 75 76 static void free_kctls(struct hda_gen_spec *spec) 77 { 78 if (spec->kctls.list) { 79 struct snd_kcontrol_new *kctl = spec->kctls.list; 80 int i; 81 for (i = 0; i < spec->kctls.used; i++) 82 kfree(kctl[i].name); 83 } 84 snd_array_free(&spec->kctls); 85 } 86 87 static void snd_hda_gen_spec_free(struct hda_gen_spec *spec) 88 { 89 if (!spec) 90 return; 91 free_kctls(spec); 92 snd_array_free(&spec->paths); 93 snd_array_free(&spec->loopback_list); 94 } 95 96 /* 97 * store user hints 98 */ 99 static void parse_user_hints(struct hda_codec *codec) 100 { 101 struct hda_gen_spec *spec = codec->spec; 102 int val; 103 104 val = snd_hda_get_bool_hint(codec, "jack_detect"); 105 if (val >= 0) 106 codec->no_jack_detect = !val; 107 val = snd_hda_get_bool_hint(codec, "inv_jack_detect"); 108 if (val >= 0) 109 codec->inv_jack_detect = !!val; 110 val = snd_hda_get_bool_hint(codec, "trigger_sense"); 111 if (val >= 0) 112 codec->no_trigger_sense = !val; 113 val = snd_hda_get_bool_hint(codec, "inv_eapd"); 114 if (val >= 0) 115 codec->inv_eapd = !!val; 116 val = snd_hda_get_bool_hint(codec, "pcm_format_first"); 117 if (val >= 0) 118 codec->pcm_format_first = !!val; 119 val = snd_hda_get_bool_hint(codec, "sticky_stream"); 120 if (val >= 0) 121 codec->no_sticky_stream = !val; 122 val = snd_hda_get_bool_hint(codec, "spdif_status_reset"); 123 if (val >= 0) 124 codec->spdif_status_reset = !!val; 125 val = snd_hda_get_bool_hint(codec, "pin_amp_workaround"); 126 if (val >= 0) 127 codec->pin_amp_workaround = !!val; 128 val = snd_hda_get_bool_hint(codec, "single_adc_amp"); 129 if (val >= 0) 130 codec->single_adc_amp = !!val; 131 val = snd_hda_get_bool_hint(codec, "power_save_node"); 132 if (val >= 0) 133 codec->power_save_node = !!val; 134 135 val = snd_hda_get_bool_hint(codec, "auto_mute"); 136 if (val >= 0) 137 spec->suppress_auto_mute = !val; 138 val = snd_hda_get_bool_hint(codec, "auto_mic"); 139 if (val >= 0) 140 spec->suppress_auto_mic = !val; 141 val = snd_hda_get_bool_hint(codec, "line_in_auto_switch"); 142 if (val >= 0) 143 spec->line_in_auto_switch = !!val; 144 val = snd_hda_get_bool_hint(codec, "auto_mute_via_amp"); 145 if (val >= 0) 146 spec->auto_mute_via_amp = !!val; 147 val = snd_hda_get_bool_hint(codec, "need_dac_fix"); 148 if (val >= 0) 149 spec->need_dac_fix = !!val; 150 val = snd_hda_get_bool_hint(codec, "primary_hp"); 151 if (val >= 0) 152 spec->no_primary_hp = !val; 153 val = snd_hda_get_bool_hint(codec, "multi_io"); 154 if (val >= 0) 155 spec->no_multi_io = !val; 156 val = snd_hda_get_bool_hint(codec, "multi_cap_vol"); 157 if (val >= 0) 158 spec->multi_cap_vol = !!val; 159 val = snd_hda_get_bool_hint(codec, "inv_dmic_split"); 160 if (val >= 0) 161 spec->inv_dmic_split = !!val; 162 val = snd_hda_get_bool_hint(codec, "indep_hp"); 163 if (val >= 0) 164 spec->indep_hp = !!val; 165 val = snd_hda_get_bool_hint(codec, "add_stereo_mix_input"); 166 if (val >= 0) 167 spec->add_stereo_mix_input = !!val; 168 /* the following two are just for compatibility */ 169 val = snd_hda_get_bool_hint(codec, "add_out_jack_modes"); 170 if (val >= 0) 171 spec->add_jack_modes = !!val; 172 val = snd_hda_get_bool_hint(codec, "add_in_jack_modes"); 173 if (val >= 0) 174 spec->add_jack_modes = !!val; 175 val = snd_hda_get_bool_hint(codec, "add_jack_modes"); 176 if (val >= 0) 177 spec->add_jack_modes = !!val; 178 val = snd_hda_get_bool_hint(codec, "power_down_unused"); 179 if (val >= 0) 180 spec->power_down_unused = !!val; 181 val = snd_hda_get_bool_hint(codec, "add_hp_mic"); 182 if (val >= 0) 183 spec->hp_mic = !!val; 184 val = snd_hda_get_bool_hint(codec, "hp_mic_detect"); 185 if (val >= 0) 186 spec->suppress_hp_mic_detect = !val; 187 val = snd_hda_get_bool_hint(codec, "vmaster"); 188 if (val >= 0) 189 spec->suppress_vmaster = !val; 190 191 if (!snd_hda_get_int_hint(codec, "mixer_nid", &val)) 192 spec->mixer_nid = val; 193 } 194 195 /* 196 * pin control value accesses 197 */ 198 199 #define update_pin_ctl(codec, pin, val) \ 200 snd_hda_codec_write_cache(codec, pin, 0, \ 201 AC_VERB_SET_PIN_WIDGET_CONTROL, val) 202 203 /* restore the pinctl based on the cached value */ 204 static inline void restore_pin_ctl(struct hda_codec *codec, hda_nid_t pin) 205 { 206 update_pin_ctl(codec, pin, snd_hda_codec_get_pin_target(codec, pin)); 207 } 208 209 /* set the pinctl target value and write it if requested */ 210 static void set_pin_target(struct hda_codec *codec, hda_nid_t pin, 211 unsigned int val, bool do_write) 212 { 213 if (!pin) 214 return; 215 val = snd_hda_correct_pin_ctl(codec, pin, val); 216 snd_hda_codec_set_pin_target(codec, pin, val); 217 if (do_write) 218 update_pin_ctl(codec, pin, val); 219 } 220 221 /* set pinctl target values for all given pins */ 222 static void set_pin_targets(struct hda_codec *codec, int num_pins, 223 hda_nid_t *pins, unsigned int val) 224 { 225 int i; 226 for (i = 0; i < num_pins; i++) 227 set_pin_target(codec, pins[i], val, false); 228 } 229 230 /* 231 * parsing paths 232 */ 233 234 /* return the position of NID in the list, or -1 if not found */ 235 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 236 { 237 int i; 238 for (i = 0; i < nums; i++) 239 if (list[i] == nid) 240 return i; 241 return -1; 242 } 243 244 /* return true if the given NID is contained in the path */ 245 static bool is_nid_contained(struct nid_path *path, hda_nid_t nid) 246 { 247 return find_idx_in_nid_list(nid, path->path, path->depth) >= 0; 248 } 249 250 static struct nid_path *get_nid_path(struct hda_codec *codec, 251 hda_nid_t from_nid, hda_nid_t to_nid, 252 int anchor_nid) 253 { 254 struct hda_gen_spec *spec = codec->spec; 255 struct nid_path *path; 256 int i; 257 258 snd_array_for_each(&spec->paths, i, path) { 259 if (path->depth <= 0) 260 continue; 261 if ((!from_nid || path->path[0] == from_nid) && 262 (!to_nid || path->path[path->depth - 1] == to_nid)) { 263 if (!anchor_nid || 264 (anchor_nid > 0 && is_nid_contained(path, anchor_nid)) || 265 (anchor_nid < 0 && !is_nid_contained(path, anchor_nid))) 266 return path; 267 } 268 } 269 return NULL; 270 } 271 272 /** 273 * snd_hda_get_path_idx - get the index number corresponding to the path 274 * instance 275 * @codec: the HDA codec 276 * @path: nid_path object 277 * 278 * The returned index starts from 1, i.e. the actual array index with offset 1, 279 * and zero is handled as an invalid path 280 */ 281 int snd_hda_get_path_idx(struct hda_codec *codec, struct nid_path *path) 282 { 283 struct hda_gen_spec *spec = codec->spec; 284 struct nid_path *array = spec->paths.list; 285 ssize_t idx; 286 287 if (!spec->paths.used) 288 return 0; 289 idx = path - array; 290 if (idx < 0 || idx >= spec->paths.used) 291 return 0; 292 return idx + 1; 293 } 294 EXPORT_SYMBOL_GPL(snd_hda_get_path_idx); 295 296 /** 297 * snd_hda_get_path_from_idx - get the path instance corresponding to the 298 * given index number 299 * @codec: the HDA codec 300 * @idx: the path index 301 */ 302 struct nid_path *snd_hda_get_path_from_idx(struct hda_codec *codec, int idx) 303 { 304 struct hda_gen_spec *spec = codec->spec; 305 306 if (idx <= 0 || idx > spec->paths.used) 307 return NULL; 308 return snd_array_elem(&spec->paths, idx - 1); 309 } 310 EXPORT_SYMBOL_GPL(snd_hda_get_path_from_idx); 311 312 /* check whether the given DAC is already found in any existing paths */ 313 static bool is_dac_already_used(struct hda_codec *codec, hda_nid_t nid) 314 { 315 struct hda_gen_spec *spec = codec->spec; 316 const struct nid_path *path; 317 int i; 318 319 snd_array_for_each(&spec->paths, i, path) { 320 if (path->path[0] == nid) 321 return true; 322 } 323 return false; 324 } 325 326 /* check whether the given two widgets can be connected */ 327 static bool is_reachable_path(struct hda_codec *codec, 328 hda_nid_t from_nid, hda_nid_t to_nid) 329 { 330 if (!from_nid || !to_nid) 331 return false; 332 return snd_hda_get_conn_index(codec, to_nid, from_nid, true) >= 0; 333 } 334 335 /* nid, dir and idx */ 336 #define AMP_VAL_COMPARE_MASK (0xffff | (1U << 18) | (0x0f << 19)) 337 338 /* check whether the given ctl is already assigned in any path elements */ 339 static bool is_ctl_used(struct hda_codec *codec, unsigned int val, int type) 340 { 341 struct hda_gen_spec *spec = codec->spec; 342 const struct nid_path *path; 343 int i; 344 345 val &= AMP_VAL_COMPARE_MASK; 346 snd_array_for_each(&spec->paths, i, path) { 347 if ((path->ctls[type] & AMP_VAL_COMPARE_MASK) == val) 348 return true; 349 } 350 return false; 351 } 352 353 /* check whether a control with the given (nid, dir, idx) was assigned */ 354 static bool is_ctl_associated(struct hda_codec *codec, hda_nid_t nid, 355 int dir, int idx, int type) 356 { 357 unsigned int val = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir); 358 return is_ctl_used(codec, val, type); 359 } 360 361 static void print_nid_path(struct hda_codec *codec, 362 const char *pfx, struct nid_path *path) 363 { 364 char buf[40]; 365 char *pos = buf; 366 int i; 367 368 *pos = 0; 369 for (i = 0; i < path->depth; i++) 370 pos += scnprintf(pos, sizeof(buf) - (pos - buf), "%s%02x", 371 pos != buf ? ":" : "", 372 path->path[i]); 373 374 codec_dbg(codec, "%s path: depth=%d '%s'\n", pfx, path->depth, buf); 375 } 376 377 /* called recursively */ 378 static bool __parse_nid_path(struct hda_codec *codec, 379 hda_nid_t from_nid, hda_nid_t to_nid, 380 int anchor_nid, struct nid_path *path, 381 int depth) 382 { 383 const hda_nid_t *conn; 384 int i, nums; 385 386 if (to_nid == anchor_nid) 387 anchor_nid = 0; /* anchor passed */ 388 else if (to_nid == (hda_nid_t)(-anchor_nid)) 389 return false; /* hit the exclusive nid */ 390 391 nums = snd_hda_get_conn_list(codec, to_nid, &conn); 392 for (i = 0; i < nums; i++) { 393 if (conn[i] != from_nid) { 394 /* special case: when from_nid is 0, 395 * try to find an empty DAC 396 */ 397 if (from_nid || 398 get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT || 399 is_dac_already_used(codec, conn[i])) 400 continue; 401 } 402 /* anchor is not requested or already passed? */ 403 if (anchor_nid <= 0) 404 goto found; 405 } 406 if (depth >= MAX_NID_PATH_DEPTH) 407 return false; 408 for (i = 0; i < nums; i++) { 409 unsigned int type; 410 type = get_wcaps_type(get_wcaps(codec, conn[i])); 411 if (type == AC_WID_AUD_OUT || type == AC_WID_AUD_IN || 412 type == AC_WID_PIN) 413 continue; 414 if (__parse_nid_path(codec, from_nid, conn[i], 415 anchor_nid, path, depth + 1)) 416 goto found; 417 } 418 return false; 419 420 found: 421 path->path[path->depth] = conn[i]; 422 path->idx[path->depth + 1] = i; 423 if (nums > 1 && get_wcaps_type(get_wcaps(codec, to_nid)) != AC_WID_AUD_MIX) 424 path->multi[path->depth + 1] = 1; 425 path->depth++; 426 return true; 427 } 428 429 /* 430 * snd_hda_parse_nid_path - parse the widget path from the given nid to 431 * the target nid 432 * @codec: the HDA codec 433 * @from_nid: the NID where the path start from 434 * @to_nid: the NID where the path ends at 435 * @anchor_nid: the anchor indication 436 * @path: the path object to store the result 437 * 438 * Returns true if a matching path is found. 439 * 440 * The parsing behavior depends on parameters: 441 * when @from_nid is 0, try to find an empty DAC; 442 * when @anchor_nid is set to a positive value, only paths through the widget 443 * with the given value are evaluated. 444 * when @anchor_nid is set to a negative value, paths through the widget 445 * with the negative of given value are excluded, only other paths are chosen. 446 * when @anchor_nid is zero, no special handling about path selection. 447 */ 448 static bool snd_hda_parse_nid_path(struct hda_codec *codec, hda_nid_t from_nid, 449 hda_nid_t to_nid, int anchor_nid, 450 struct nid_path *path) 451 { 452 if (__parse_nid_path(codec, from_nid, to_nid, anchor_nid, path, 1)) { 453 path->path[path->depth] = to_nid; 454 path->depth++; 455 return true; 456 } 457 return false; 458 } 459 460 /** 461 * snd_hda_add_new_path - parse the path between the given NIDs and 462 * add to the path list 463 * @codec: the HDA codec 464 * @from_nid: the NID where the path start from 465 * @to_nid: the NID where the path ends at 466 * @anchor_nid: the anchor indication, see snd_hda_parse_nid_path() 467 * 468 * If no valid path is found, returns NULL. 469 */ 470 struct nid_path * 471 snd_hda_add_new_path(struct hda_codec *codec, hda_nid_t from_nid, 472 hda_nid_t to_nid, int anchor_nid) 473 { 474 struct hda_gen_spec *spec = codec->spec; 475 struct nid_path *path; 476 477 if (from_nid && to_nid && !is_reachable_path(codec, from_nid, to_nid)) 478 return NULL; 479 480 /* check whether the path has been already added */ 481 path = get_nid_path(codec, from_nid, to_nid, anchor_nid); 482 if (path) 483 return path; 484 485 path = snd_array_new(&spec->paths); 486 if (!path) 487 return NULL; 488 memset(path, 0, sizeof(*path)); 489 if (snd_hda_parse_nid_path(codec, from_nid, to_nid, anchor_nid, path)) 490 return path; 491 /* push back */ 492 spec->paths.used--; 493 return NULL; 494 } 495 EXPORT_SYMBOL_GPL(snd_hda_add_new_path); 496 497 /* clear the given path as invalid so that it won't be picked up later */ 498 static void invalidate_nid_path(struct hda_codec *codec, int idx) 499 { 500 struct nid_path *path = snd_hda_get_path_from_idx(codec, idx); 501 if (!path) 502 return; 503 memset(path, 0, sizeof(*path)); 504 } 505 506 /* return a DAC if paired to the given pin by codec driver */ 507 static hda_nid_t get_preferred_dac(struct hda_codec *codec, hda_nid_t pin) 508 { 509 struct hda_gen_spec *spec = codec->spec; 510 const hda_nid_t *list = spec->preferred_dacs; 511 512 if (!list) 513 return 0; 514 for (; *list; list += 2) 515 if (*list == pin) 516 return list[1]; 517 return 0; 518 } 519 520 /* look for an empty DAC slot */ 521 static hda_nid_t look_for_dac(struct hda_codec *codec, hda_nid_t pin, 522 bool is_digital) 523 { 524 struct hda_gen_spec *spec = codec->spec; 525 bool cap_digital; 526 int i; 527 528 for (i = 0; i < spec->num_all_dacs; i++) { 529 hda_nid_t nid = spec->all_dacs[i]; 530 if (!nid || is_dac_already_used(codec, nid)) 531 continue; 532 cap_digital = !!(get_wcaps(codec, nid) & AC_WCAP_DIGITAL); 533 if (is_digital != cap_digital) 534 continue; 535 if (is_reachable_path(codec, nid, pin)) 536 return nid; 537 } 538 return 0; 539 } 540 541 /* replace the channels in the composed amp value with the given number */ 542 static unsigned int amp_val_replace_channels(unsigned int val, unsigned int chs) 543 { 544 val &= ~(0x3U << 16); 545 val |= chs << 16; 546 return val; 547 } 548 549 static bool same_amp_caps(struct hda_codec *codec, hda_nid_t nid1, 550 hda_nid_t nid2, int dir) 551 { 552 if (!(get_wcaps(codec, nid1) & (1 << (dir + 1)))) 553 return !(get_wcaps(codec, nid2) & (1 << (dir + 1))); 554 return (query_amp_caps(codec, nid1, dir) == 555 query_amp_caps(codec, nid2, dir)); 556 } 557 558 /* look for a widget suitable for assigning a mute switch in the path */ 559 static hda_nid_t look_for_out_mute_nid(struct hda_codec *codec, 560 struct nid_path *path) 561 { 562 int i; 563 564 for (i = path->depth - 1; i >= 0; i--) { 565 if (nid_has_mute(codec, path->path[i], HDA_OUTPUT)) 566 return path->path[i]; 567 if (i != path->depth - 1 && i != 0 && 568 nid_has_mute(codec, path->path[i], HDA_INPUT)) 569 return path->path[i]; 570 } 571 return 0; 572 } 573 574 /* look for a widget suitable for assigning a volume ctl in the path */ 575 static hda_nid_t look_for_out_vol_nid(struct hda_codec *codec, 576 struct nid_path *path) 577 { 578 struct hda_gen_spec *spec = codec->spec; 579 int i; 580 581 for (i = path->depth - 1; i >= 0; i--) { 582 hda_nid_t nid = path->path[i]; 583 if ((spec->out_vol_mask >> nid) & 1) 584 continue; 585 if (nid_has_volume(codec, nid, HDA_OUTPUT)) 586 return nid; 587 } 588 return 0; 589 } 590 591 /* 592 * path activation / deactivation 593 */ 594 595 /* can have the amp-in capability? */ 596 static bool has_amp_in(struct hda_codec *codec, struct nid_path *path, int idx) 597 { 598 hda_nid_t nid = path->path[idx]; 599 unsigned int caps = get_wcaps(codec, nid); 600 unsigned int type = get_wcaps_type(caps); 601 602 if (!(caps & AC_WCAP_IN_AMP)) 603 return false; 604 if (type == AC_WID_PIN && idx > 0) /* only for input pins */ 605 return false; 606 return true; 607 } 608 609 /* can have the amp-out capability? */ 610 static bool has_amp_out(struct hda_codec *codec, struct nid_path *path, int idx) 611 { 612 hda_nid_t nid = path->path[idx]; 613 unsigned int caps = get_wcaps(codec, nid); 614 unsigned int type = get_wcaps_type(caps); 615 616 if (!(caps & AC_WCAP_OUT_AMP)) 617 return false; 618 if (type == AC_WID_PIN && !idx) /* only for output pins */ 619 return false; 620 return true; 621 } 622 623 /* check whether the given (nid,dir,idx) is active */ 624 static bool is_active_nid(struct hda_codec *codec, hda_nid_t nid, 625 unsigned int dir, unsigned int idx) 626 { 627 struct hda_gen_spec *spec = codec->spec; 628 int type = get_wcaps_type(get_wcaps(codec, nid)); 629 const struct nid_path *path; 630 int i, n; 631 632 if (nid == codec->core.afg) 633 return true; 634 635 snd_array_for_each(&spec->paths, n, path) { 636 if (!path->active) 637 continue; 638 if (codec->power_save_node) { 639 if (!path->stream_enabled) 640 continue; 641 /* ignore unplugged paths except for DAC/ADC */ 642 if (!(path->pin_enabled || path->pin_fixed) && 643 type != AC_WID_AUD_OUT && type != AC_WID_AUD_IN) 644 continue; 645 } 646 for (i = 0; i < path->depth; i++) { 647 if (path->path[i] == nid) { 648 if (dir == HDA_OUTPUT || idx == -1 || 649 path->idx[i] == idx) 650 return true; 651 break; 652 } 653 } 654 } 655 return false; 656 } 657 658 /* check whether the NID is referred by any active paths */ 659 #define is_active_nid_for_any(codec, nid) \ 660 is_active_nid(codec, nid, HDA_OUTPUT, -1) 661 662 /* get the default amp value for the target state */ 663 static int get_amp_val_to_activate(struct hda_codec *codec, hda_nid_t nid, 664 int dir, unsigned int caps, bool enable) 665 { 666 unsigned int val = 0; 667 668 if (caps & AC_AMPCAP_NUM_STEPS) { 669 /* set to 0dB */ 670 if (enable) 671 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT; 672 } 673 if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) { 674 if (!enable) 675 val |= HDA_AMP_MUTE; 676 } 677 return val; 678 } 679 680 /* is this a stereo widget or a stereo-to-mono mix? */ 681 static bool is_stereo_amps(struct hda_codec *codec, hda_nid_t nid, int dir) 682 { 683 unsigned int wcaps = get_wcaps(codec, nid); 684 hda_nid_t conn; 685 686 if (wcaps & AC_WCAP_STEREO) 687 return true; 688 if (dir != HDA_INPUT || get_wcaps_type(wcaps) != AC_WID_AUD_MIX) 689 return false; 690 if (snd_hda_get_num_conns(codec, nid) != 1) 691 return false; 692 if (snd_hda_get_connections(codec, nid, &conn, 1) < 0) 693 return false; 694 return !!(get_wcaps(codec, conn) & AC_WCAP_STEREO); 695 } 696 697 /* initialize the amp value (only at the first time) */ 698 static void init_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx) 699 { 700 unsigned int caps = query_amp_caps(codec, nid, dir); 701 int val = get_amp_val_to_activate(codec, nid, dir, caps, false); 702 703 if (is_stereo_amps(codec, nid, dir)) 704 snd_hda_codec_amp_init_stereo(codec, nid, dir, idx, 0xff, val); 705 else 706 snd_hda_codec_amp_init(codec, nid, 0, dir, idx, 0xff, val); 707 } 708 709 /* update the amp, doing in stereo or mono depending on NID */ 710 static int update_amp(struct hda_codec *codec, hda_nid_t nid, int dir, int idx, 711 unsigned int mask, unsigned int val) 712 { 713 if (is_stereo_amps(codec, nid, dir)) 714 return snd_hda_codec_amp_stereo(codec, nid, dir, idx, 715 mask, val); 716 else 717 return snd_hda_codec_amp_update(codec, nid, 0, dir, idx, 718 mask, val); 719 } 720 721 /* calculate amp value mask we can modify; 722 * if the given amp is controlled by mixers, don't touch it 723 */ 724 static unsigned int get_amp_mask_to_modify(struct hda_codec *codec, 725 hda_nid_t nid, int dir, int idx, 726 unsigned int caps) 727 { 728 unsigned int mask = 0xff; 729 730 if (caps & (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE)) { 731 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_MUTE_CTL)) 732 mask &= ~0x80; 733 } 734 if (caps & AC_AMPCAP_NUM_STEPS) { 735 if (is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) || 736 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL)) 737 mask &= ~0x7f; 738 } 739 return mask; 740 } 741 742 static void activate_amp(struct hda_codec *codec, hda_nid_t nid, int dir, 743 int idx, int idx_to_check, bool enable) 744 { 745 unsigned int caps; 746 unsigned int mask, val; 747 748 caps = query_amp_caps(codec, nid, dir); 749 val = get_amp_val_to_activate(codec, nid, dir, caps, enable); 750 mask = get_amp_mask_to_modify(codec, nid, dir, idx_to_check, caps); 751 if (!mask) 752 return; 753 754 val &= mask; 755 update_amp(codec, nid, dir, idx, mask, val); 756 } 757 758 static void check_and_activate_amp(struct hda_codec *codec, hda_nid_t nid, 759 int dir, int idx, int idx_to_check, 760 bool enable) 761 { 762 /* check whether the given amp is still used by others */ 763 if (!enable && is_active_nid(codec, nid, dir, idx_to_check)) 764 return; 765 activate_amp(codec, nid, dir, idx, idx_to_check, enable); 766 } 767 768 static void activate_amp_out(struct hda_codec *codec, struct nid_path *path, 769 int i, bool enable) 770 { 771 hda_nid_t nid = path->path[i]; 772 init_amp(codec, nid, HDA_OUTPUT, 0); 773 check_and_activate_amp(codec, nid, HDA_OUTPUT, 0, 0, enable); 774 } 775 776 static void activate_amp_in(struct hda_codec *codec, struct nid_path *path, 777 int i, bool enable, bool add_aamix) 778 { 779 struct hda_gen_spec *spec = codec->spec; 780 const hda_nid_t *conn; 781 int n, nums, idx; 782 int type; 783 hda_nid_t nid = path->path[i]; 784 785 nums = snd_hda_get_conn_list(codec, nid, &conn); 786 if (nums < 0) 787 return; 788 type = get_wcaps_type(get_wcaps(codec, nid)); 789 if (type == AC_WID_PIN || 790 (type == AC_WID_AUD_IN && codec->single_adc_amp)) { 791 nums = 1; 792 idx = 0; 793 } else 794 idx = path->idx[i]; 795 796 for (n = 0; n < nums; n++) 797 init_amp(codec, nid, HDA_INPUT, n); 798 799 /* here is a little bit tricky in comparison with activate_amp_out(); 800 * when aa-mixer is available, we need to enable the path as well 801 */ 802 for (n = 0; n < nums; n++) { 803 if (n != idx) { 804 if (conn[n] != spec->mixer_merge_nid) 805 continue; 806 /* when aamix is disabled, force to off */ 807 if (!add_aamix) { 808 activate_amp(codec, nid, HDA_INPUT, n, n, false); 809 continue; 810 } 811 } 812 check_and_activate_amp(codec, nid, HDA_INPUT, n, idx, enable); 813 } 814 } 815 816 /* sync power of each widget in the the given path */ 817 static hda_nid_t path_power_update(struct hda_codec *codec, 818 struct nid_path *path, 819 bool allow_powerdown) 820 { 821 hda_nid_t nid, changed = 0; 822 int i, state, power; 823 824 for (i = 0; i < path->depth; i++) { 825 nid = path->path[i]; 826 if (!(get_wcaps(codec, nid) & AC_WCAP_POWER)) 827 continue; 828 if (nid == codec->core.afg) 829 continue; 830 if (!allow_powerdown || is_active_nid_for_any(codec, nid)) 831 state = AC_PWRST_D0; 832 else 833 state = AC_PWRST_D3; 834 power = snd_hda_codec_read(codec, nid, 0, 835 AC_VERB_GET_POWER_STATE, 0); 836 if (power != (state | (state << 4))) { 837 snd_hda_codec_write(codec, nid, 0, 838 AC_VERB_SET_POWER_STATE, state); 839 changed = nid; 840 /* all known codecs seem to be capable to handl 841 * widgets state even in D3, so far. 842 * if any new codecs need to restore the widget 843 * states after D0 transition, call the function 844 * below. 845 */ 846 #if 0 /* disabled */ 847 if (state == AC_PWRST_D0) 848 snd_hdac_regmap_sync_node(&codec->core, nid); 849 #endif 850 } 851 } 852 return changed; 853 } 854 855 /* do sync with the last power state change */ 856 static void sync_power_state_change(struct hda_codec *codec, hda_nid_t nid) 857 { 858 if (nid) { 859 msleep(10); 860 snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_POWER_STATE, 0); 861 } 862 } 863 864 /** 865 * snd_hda_activate_path - activate or deactivate the given path 866 * @codec: the HDA codec 867 * @path: the path to activate/deactivate 868 * @enable: flag to activate or not 869 * @add_aamix: enable the input from aamix NID 870 * 871 * If @add_aamix is set, enable the input from aa-mix NID as well (if any). 872 */ 873 void snd_hda_activate_path(struct hda_codec *codec, struct nid_path *path, 874 bool enable, bool add_aamix) 875 { 876 struct hda_gen_spec *spec = codec->spec; 877 int i; 878 879 path->active = enable; 880 881 /* make sure the widget is powered up */ 882 if (enable && (spec->power_down_unused || codec->power_save_node)) 883 path_power_update(codec, path, codec->power_save_node); 884 885 for (i = path->depth - 1; i >= 0; i--) { 886 hda_nid_t nid = path->path[i]; 887 888 if (enable && path->multi[i]) 889 snd_hda_codec_write_cache(codec, nid, 0, 890 AC_VERB_SET_CONNECT_SEL, 891 path->idx[i]); 892 if (has_amp_in(codec, path, i)) 893 activate_amp_in(codec, path, i, enable, add_aamix); 894 if (has_amp_out(codec, path, i)) 895 activate_amp_out(codec, path, i, enable); 896 } 897 } 898 EXPORT_SYMBOL_GPL(snd_hda_activate_path); 899 900 /* if the given path is inactive, put widgets into D3 (only if suitable) */ 901 static void path_power_down_sync(struct hda_codec *codec, struct nid_path *path) 902 { 903 struct hda_gen_spec *spec = codec->spec; 904 905 if (!(spec->power_down_unused || codec->power_save_node) || path->active) 906 return; 907 sync_power_state_change(codec, path_power_update(codec, path, true)); 908 } 909 910 /* turn on/off EAPD on the given pin */ 911 static void set_pin_eapd(struct hda_codec *codec, hda_nid_t pin, bool enable) 912 { 913 struct hda_gen_spec *spec = codec->spec; 914 if (spec->own_eapd_ctl || 915 !(snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD)) 916 return; 917 if (spec->keep_eapd_on && !enable) 918 return; 919 if (codec->inv_eapd) 920 enable = !enable; 921 snd_hda_codec_write_cache(codec, pin, 0, 922 AC_VERB_SET_EAPD_BTLENABLE, 923 enable ? 0x02 : 0x00); 924 } 925 926 /* re-initialize the path specified by the given path index */ 927 static void resume_path_from_idx(struct hda_codec *codec, int path_idx) 928 { 929 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx); 930 if (path) 931 snd_hda_activate_path(codec, path, path->active, false); 932 } 933 934 935 /* 936 * Helper functions for creating mixer ctl elements 937 */ 938 939 static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol, 940 struct snd_ctl_elem_value *ucontrol); 941 static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol, 942 struct snd_ctl_elem_value *ucontrol); 943 static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol, 944 struct snd_ctl_elem_value *ucontrol); 945 946 enum { 947 HDA_CTL_WIDGET_VOL, 948 HDA_CTL_WIDGET_MUTE, 949 HDA_CTL_BIND_MUTE, 950 }; 951 static const struct snd_kcontrol_new control_templates[] = { 952 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 953 /* only the put callback is replaced for handling the special mute */ 954 { 955 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 956 .subdevice = HDA_SUBDEV_AMP_FLAG, 957 .info = snd_hda_mixer_amp_switch_info, 958 .get = snd_hda_mixer_amp_switch_get, 959 .put = hda_gen_mixer_mute_put, /* replaced */ 960 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0), 961 }, 962 { 963 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 964 .info = snd_hda_mixer_amp_switch_info, 965 .get = hda_gen_bind_mute_get, 966 .put = hda_gen_bind_mute_put, /* replaced */ 967 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0), 968 }, 969 }; 970 971 /* add dynamic controls from template */ 972 static struct snd_kcontrol_new * 973 add_control(struct hda_gen_spec *spec, int type, const char *name, 974 int cidx, unsigned long val) 975 { 976 struct snd_kcontrol_new *knew; 977 978 knew = snd_hda_gen_add_kctl(spec, name, &control_templates[type]); 979 if (!knew) 980 return NULL; 981 knew->index = cidx; 982 if (get_amp_nid_(val)) 983 knew->subdevice = HDA_SUBDEV_AMP_FLAG; 984 knew->private_value = val; 985 return knew; 986 } 987 988 static int add_control_with_pfx(struct hda_gen_spec *spec, int type, 989 const char *pfx, const char *dir, 990 const char *sfx, int cidx, unsigned long val) 991 { 992 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 993 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx); 994 if (!add_control(spec, type, name, cidx, val)) 995 return -ENOMEM; 996 return 0; 997 } 998 999 #define add_pb_vol_ctrl(spec, type, pfx, val) \ 1000 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val) 1001 #define add_pb_sw_ctrl(spec, type, pfx, val) \ 1002 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val) 1003 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \ 1004 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val) 1005 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \ 1006 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val) 1007 1008 static int add_vol_ctl(struct hda_codec *codec, const char *pfx, int cidx, 1009 unsigned int chs, struct nid_path *path) 1010 { 1011 unsigned int val; 1012 if (!path) 1013 return 0; 1014 val = path->ctls[NID_PATH_VOL_CTL]; 1015 if (!val) 1016 return 0; 1017 val = amp_val_replace_channels(val, chs); 1018 return __add_pb_vol_ctrl(codec->spec, HDA_CTL_WIDGET_VOL, pfx, cidx, val); 1019 } 1020 1021 /* return the channel bits suitable for the given path->ctls[] */ 1022 static int get_default_ch_nums(struct hda_codec *codec, struct nid_path *path, 1023 int type) 1024 { 1025 int chs = 1; /* mono (left only) */ 1026 if (path) { 1027 hda_nid_t nid = get_amp_nid_(path->ctls[type]); 1028 if (nid && (get_wcaps(codec, nid) & AC_WCAP_STEREO)) 1029 chs = 3; /* stereo */ 1030 } 1031 return chs; 1032 } 1033 1034 static int add_stereo_vol(struct hda_codec *codec, const char *pfx, int cidx, 1035 struct nid_path *path) 1036 { 1037 int chs = get_default_ch_nums(codec, path, NID_PATH_VOL_CTL); 1038 return add_vol_ctl(codec, pfx, cidx, chs, path); 1039 } 1040 1041 /* create a mute-switch for the given mixer widget; 1042 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute 1043 */ 1044 static int add_sw_ctl(struct hda_codec *codec, const char *pfx, int cidx, 1045 unsigned int chs, struct nid_path *path) 1046 { 1047 unsigned int val; 1048 int type = HDA_CTL_WIDGET_MUTE; 1049 1050 if (!path) 1051 return 0; 1052 val = path->ctls[NID_PATH_MUTE_CTL]; 1053 if (!val) 1054 return 0; 1055 val = amp_val_replace_channels(val, chs); 1056 if (get_amp_direction_(val) == HDA_INPUT) { 1057 hda_nid_t nid = get_amp_nid_(val); 1058 int nums = snd_hda_get_num_conns(codec, nid); 1059 if (nums > 1) { 1060 type = HDA_CTL_BIND_MUTE; 1061 val |= nums << 19; 1062 } 1063 } 1064 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val); 1065 } 1066 1067 static int add_stereo_sw(struct hda_codec *codec, const char *pfx, 1068 int cidx, struct nid_path *path) 1069 { 1070 int chs = get_default_ch_nums(codec, path, NID_PATH_MUTE_CTL); 1071 return add_sw_ctl(codec, pfx, cidx, chs, path); 1072 } 1073 1074 /* playback mute control with the software mute bit check */ 1075 static void sync_auto_mute_bits(struct snd_kcontrol *kcontrol, 1076 struct snd_ctl_elem_value *ucontrol) 1077 { 1078 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1079 struct hda_gen_spec *spec = codec->spec; 1080 1081 if (spec->auto_mute_via_amp) { 1082 hda_nid_t nid = get_amp_nid(kcontrol); 1083 bool enabled = !((spec->mute_bits >> nid) & 1); 1084 ucontrol->value.integer.value[0] &= enabled; 1085 ucontrol->value.integer.value[1] &= enabled; 1086 } 1087 } 1088 1089 static int hda_gen_mixer_mute_put(struct snd_kcontrol *kcontrol, 1090 struct snd_ctl_elem_value *ucontrol) 1091 { 1092 sync_auto_mute_bits(kcontrol, ucontrol); 1093 return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 1094 } 1095 1096 /* 1097 * Bound mute controls 1098 */ 1099 #define AMP_VAL_IDX_SHIFT 19 1100 #define AMP_VAL_IDX_MASK (0x0f<<19) 1101 1102 static int hda_gen_bind_mute_get(struct snd_kcontrol *kcontrol, 1103 struct snd_ctl_elem_value *ucontrol) 1104 { 1105 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1106 unsigned long pval; 1107 int err; 1108 1109 mutex_lock(&codec->control_mutex); 1110 pval = kcontrol->private_value; 1111 kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */ 1112 err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol); 1113 kcontrol->private_value = pval; 1114 mutex_unlock(&codec->control_mutex); 1115 return err; 1116 } 1117 1118 static int hda_gen_bind_mute_put(struct snd_kcontrol *kcontrol, 1119 struct snd_ctl_elem_value *ucontrol) 1120 { 1121 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1122 unsigned long pval; 1123 int i, indices, err = 0, change = 0; 1124 1125 sync_auto_mute_bits(kcontrol, ucontrol); 1126 1127 mutex_lock(&codec->control_mutex); 1128 pval = kcontrol->private_value; 1129 indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT; 1130 for (i = 0; i < indices; i++) { 1131 kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) | 1132 (i << AMP_VAL_IDX_SHIFT); 1133 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 1134 if (err < 0) 1135 break; 1136 change |= err; 1137 } 1138 kcontrol->private_value = pval; 1139 mutex_unlock(&codec->control_mutex); 1140 return err < 0 ? err : change; 1141 } 1142 1143 /* any ctl assigned to the path with the given index? */ 1144 static bool path_has_mixer(struct hda_codec *codec, int path_idx, int ctl_type) 1145 { 1146 struct nid_path *path = snd_hda_get_path_from_idx(codec, path_idx); 1147 return path && path->ctls[ctl_type]; 1148 } 1149 1150 static const char * const channel_name[4] = { 1151 "Front", "Surround", "CLFE", "Side" 1152 }; 1153 1154 /* give some appropriate ctl name prefix for the given line out channel */ 1155 static const char *get_line_out_pfx(struct hda_codec *codec, int ch, 1156 int *index, int ctl_type) 1157 { 1158 struct hda_gen_spec *spec = codec->spec; 1159 struct auto_pin_cfg *cfg = &spec->autocfg; 1160 1161 *index = 0; 1162 if (cfg->line_outs == 1 && !spec->multi_ios && 1163 !codec->force_pin_prefix && 1164 !cfg->hp_outs && !cfg->speaker_outs) 1165 return spec->vmaster_mute.hook ? "PCM" : "Master"; 1166 1167 /* if there is really a single DAC used in the whole output paths, 1168 * use it master (or "PCM" if a vmaster hook is present) 1169 */ 1170 if (spec->multiout.num_dacs == 1 && !spec->mixer_nid && 1171 !codec->force_pin_prefix && 1172 !spec->multiout.hp_out_nid[0] && !spec->multiout.extra_out_nid[0]) 1173 return spec->vmaster_mute.hook ? "PCM" : "Master"; 1174 1175 /* multi-io channels */ 1176 if (ch >= cfg->line_outs) 1177 return channel_name[ch]; 1178 1179 switch (cfg->line_out_type) { 1180 case AUTO_PIN_SPEAKER_OUT: 1181 /* if the primary channel vol/mute is shared with HP volume, 1182 * don't name it as Speaker 1183 */ 1184 if (!ch && cfg->hp_outs && 1185 !path_has_mixer(codec, spec->hp_paths[0], ctl_type)) 1186 break; 1187 if (cfg->line_outs == 1) 1188 return "Speaker"; 1189 if (cfg->line_outs == 2) 1190 return ch ? "Bass Speaker" : "Speaker"; 1191 break; 1192 case AUTO_PIN_HP_OUT: 1193 /* if the primary channel vol/mute is shared with spk volume, 1194 * don't name it as Headphone 1195 */ 1196 if (!ch && cfg->speaker_outs && 1197 !path_has_mixer(codec, spec->speaker_paths[0], ctl_type)) 1198 break; 1199 /* for multi-io case, only the primary out */ 1200 if (ch && spec->multi_ios) 1201 break; 1202 *index = ch; 1203 return "Headphone"; 1204 case AUTO_PIN_LINE_OUT: 1205 /* This deals with the case where we have two DACs and 1206 * one LO, one HP and one Speaker */ 1207 if (!ch && cfg->speaker_outs && cfg->hp_outs) { 1208 bool hp_lo_shared = !path_has_mixer(codec, spec->hp_paths[0], ctl_type); 1209 bool spk_lo_shared = !path_has_mixer(codec, spec->speaker_paths[0], ctl_type); 1210 if (hp_lo_shared && spk_lo_shared) 1211 return spec->vmaster_mute.hook ? "PCM" : "Master"; 1212 if (hp_lo_shared) 1213 return "Headphone+LO"; 1214 if (spk_lo_shared) 1215 return "Speaker+LO"; 1216 } 1217 } 1218 1219 /* for a single channel output, we don't have to name the channel */ 1220 if (cfg->line_outs == 1 && !spec->multi_ios) 1221 return "Line Out"; 1222 1223 if (ch >= ARRAY_SIZE(channel_name)) { 1224 snd_BUG(); 1225 return "PCM"; 1226 } 1227 1228 return channel_name[ch]; 1229 } 1230 1231 /* 1232 * Parse output paths 1233 */ 1234 1235 /* badness definition */ 1236 enum { 1237 /* No primary DAC is found for the main output */ 1238 BAD_NO_PRIMARY_DAC = 0x10000, 1239 /* No DAC is found for the extra output */ 1240 BAD_NO_DAC = 0x4000, 1241 /* No possible multi-ios */ 1242 BAD_MULTI_IO = 0x120, 1243 /* No individual DAC for extra output */ 1244 BAD_NO_EXTRA_DAC = 0x102, 1245 /* No individual DAC for extra surrounds */ 1246 BAD_NO_EXTRA_SURR_DAC = 0x101, 1247 /* Primary DAC shared with main surrounds */ 1248 BAD_SHARED_SURROUND = 0x100, 1249 /* No independent HP possible */ 1250 BAD_NO_INDEP_HP = 0x10, 1251 /* Primary DAC shared with main CLFE */ 1252 BAD_SHARED_CLFE = 0x10, 1253 /* Primary DAC shared with extra surrounds */ 1254 BAD_SHARED_EXTRA_SURROUND = 0x10, 1255 /* Volume widget is shared */ 1256 BAD_SHARED_VOL = 0x10, 1257 }; 1258 1259 /* look for widgets in the given path which are appropriate for 1260 * volume and mute controls, and assign the values to ctls[]. 1261 * 1262 * When no appropriate widget is found in the path, the badness value 1263 * is incremented depending on the situation. The function returns the 1264 * total badness for both volume and mute controls. 1265 */ 1266 static int assign_out_path_ctls(struct hda_codec *codec, struct nid_path *path) 1267 { 1268 struct hda_gen_spec *spec = codec->spec; 1269 hda_nid_t nid; 1270 unsigned int val; 1271 int badness = 0; 1272 1273 if (!path) 1274 return BAD_SHARED_VOL * 2; 1275 1276 if (path->ctls[NID_PATH_VOL_CTL] || 1277 path->ctls[NID_PATH_MUTE_CTL]) 1278 return 0; /* already evaluated */ 1279 1280 nid = look_for_out_vol_nid(codec, path); 1281 if (nid) { 1282 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 1283 if (spec->dac_min_mute) 1284 val |= HDA_AMP_VAL_MIN_MUTE; 1285 if (is_ctl_used(codec, val, NID_PATH_VOL_CTL)) 1286 badness += BAD_SHARED_VOL; 1287 else 1288 path->ctls[NID_PATH_VOL_CTL] = val; 1289 } else 1290 badness += BAD_SHARED_VOL; 1291 nid = look_for_out_mute_nid(codec, path); 1292 if (nid) { 1293 unsigned int wid_type = get_wcaps_type(get_wcaps(codec, nid)); 1294 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT || 1295 nid_has_mute(codec, nid, HDA_OUTPUT)) 1296 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 1297 else 1298 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT); 1299 if (is_ctl_used(codec, val, NID_PATH_MUTE_CTL)) 1300 badness += BAD_SHARED_VOL; 1301 else 1302 path->ctls[NID_PATH_MUTE_CTL] = val; 1303 } else 1304 badness += BAD_SHARED_VOL; 1305 return badness; 1306 } 1307 1308 const struct badness_table hda_main_out_badness = { 1309 .no_primary_dac = BAD_NO_PRIMARY_DAC, 1310 .no_dac = BAD_NO_DAC, 1311 .shared_primary = BAD_NO_PRIMARY_DAC, 1312 .shared_surr = BAD_SHARED_SURROUND, 1313 .shared_clfe = BAD_SHARED_CLFE, 1314 .shared_surr_main = BAD_SHARED_SURROUND, 1315 }; 1316 EXPORT_SYMBOL_GPL(hda_main_out_badness); 1317 1318 const struct badness_table hda_extra_out_badness = { 1319 .no_primary_dac = BAD_NO_DAC, 1320 .no_dac = BAD_NO_DAC, 1321 .shared_primary = BAD_NO_EXTRA_DAC, 1322 .shared_surr = BAD_SHARED_EXTRA_SURROUND, 1323 .shared_clfe = BAD_SHARED_EXTRA_SURROUND, 1324 .shared_surr_main = BAD_NO_EXTRA_SURR_DAC, 1325 }; 1326 EXPORT_SYMBOL_GPL(hda_extra_out_badness); 1327 1328 /* get the DAC of the primary output corresponding to the given array index */ 1329 static hda_nid_t get_primary_out(struct hda_codec *codec, int idx) 1330 { 1331 struct hda_gen_spec *spec = codec->spec; 1332 struct auto_pin_cfg *cfg = &spec->autocfg; 1333 1334 if (cfg->line_outs > idx) 1335 return spec->private_dac_nids[idx]; 1336 idx -= cfg->line_outs; 1337 if (spec->multi_ios > idx) 1338 return spec->multi_io[idx].dac; 1339 return 0; 1340 } 1341 1342 /* return the DAC if it's reachable, otherwise zero */ 1343 static inline hda_nid_t try_dac(struct hda_codec *codec, 1344 hda_nid_t dac, hda_nid_t pin) 1345 { 1346 return is_reachable_path(codec, dac, pin) ? dac : 0; 1347 } 1348 1349 /* try to assign DACs to pins and return the resultant badness */ 1350 static int try_assign_dacs(struct hda_codec *codec, int num_outs, 1351 const hda_nid_t *pins, hda_nid_t *dacs, 1352 int *path_idx, 1353 const struct badness_table *bad) 1354 { 1355 struct hda_gen_spec *spec = codec->spec; 1356 int i, j; 1357 int badness = 0; 1358 hda_nid_t dac; 1359 1360 if (!num_outs) 1361 return 0; 1362 1363 for (i = 0; i < num_outs; i++) { 1364 struct nid_path *path; 1365 hda_nid_t pin = pins[i]; 1366 1367 path = snd_hda_get_path_from_idx(codec, path_idx[i]); 1368 if (path) { 1369 badness += assign_out_path_ctls(codec, path); 1370 continue; 1371 } 1372 1373 dacs[i] = get_preferred_dac(codec, pin); 1374 if (dacs[i]) { 1375 if (is_dac_already_used(codec, dacs[i])) 1376 badness += bad->shared_primary; 1377 } 1378 1379 if (!dacs[i]) 1380 dacs[i] = look_for_dac(codec, pin, false); 1381 if (!dacs[i] && !i) { 1382 /* try to steal the DAC of surrounds for the front */ 1383 for (j = 1; j < num_outs; j++) { 1384 if (is_reachable_path(codec, dacs[j], pin)) { 1385 dacs[0] = dacs[j]; 1386 dacs[j] = 0; 1387 invalidate_nid_path(codec, path_idx[j]); 1388 path_idx[j] = 0; 1389 break; 1390 } 1391 } 1392 } 1393 dac = dacs[i]; 1394 if (!dac) { 1395 if (num_outs > 2) 1396 dac = try_dac(codec, get_primary_out(codec, i), pin); 1397 if (!dac) 1398 dac = try_dac(codec, dacs[0], pin); 1399 if (!dac) 1400 dac = try_dac(codec, get_primary_out(codec, i), pin); 1401 if (dac) { 1402 if (!i) 1403 badness += bad->shared_primary; 1404 else if (i == 1) 1405 badness += bad->shared_surr; 1406 else 1407 badness += bad->shared_clfe; 1408 } else if (is_reachable_path(codec, spec->private_dac_nids[0], pin)) { 1409 dac = spec->private_dac_nids[0]; 1410 badness += bad->shared_surr_main; 1411 } else if (!i) 1412 badness += bad->no_primary_dac; 1413 else 1414 badness += bad->no_dac; 1415 } 1416 if (!dac) 1417 continue; 1418 path = snd_hda_add_new_path(codec, dac, pin, -spec->mixer_nid); 1419 if (!path && !i && spec->mixer_nid) { 1420 /* try with aamix */ 1421 path = snd_hda_add_new_path(codec, dac, pin, 0); 1422 } 1423 if (!path) { 1424 dac = dacs[i] = 0; 1425 badness += bad->no_dac; 1426 } else { 1427 /* print_nid_path(codec, "output", path); */ 1428 path->active = true; 1429 path_idx[i] = snd_hda_get_path_idx(codec, path); 1430 badness += assign_out_path_ctls(codec, path); 1431 } 1432 } 1433 1434 return badness; 1435 } 1436 1437 /* return NID if the given pin has only a single connection to a certain DAC */ 1438 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin) 1439 { 1440 struct hda_gen_spec *spec = codec->spec; 1441 int i; 1442 hda_nid_t nid_found = 0; 1443 1444 for (i = 0; i < spec->num_all_dacs; i++) { 1445 hda_nid_t nid = spec->all_dacs[i]; 1446 if (!nid || is_dac_already_used(codec, nid)) 1447 continue; 1448 if (is_reachable_path(codec, nid, pin)) { 1449 if (nid_found) 1450 return 0; 1451 nid_found = nid; 1452 } 1453 } 1454 return nid_found; 1455 } 1456 1457 /* check whether the given pin can be a multi-io pin */ 1458 static bool can_be_multiio_pin(struct hda_codec *codec, 1459 unsigned int location, hda_nid_t nid) 1460 { 1461 unsigned int defcfg, caps; 1462 1463 defcfg = snd_hda_codec_get_pincfg(codec, nid); 1464 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX) 1465 return false; 1466 if (location && get_defcfg_location(defcfg) != location) 1467 return false; 1468 caps = snd_hda_query_pin_caps(codec, nid); 1469 if (!(caps & AC_PINCAP_OUT)) 1470 return false; 1471 return true; 1472 } 1473 1474 /* count the number of input pins that are capable to be multi-io */ 1475 static int count_multiio_pins(struct hda_codec *codec, hda_nid_t reference_pin) 1476 { 1477 struct hda_gen_spec *spec = codec->spec; 1478 struct auto_pin_cfg *cfg = &spec->autocfg; 1479 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin); 1480 unsigned int location = get_defcfg_location(defcfg); 1481 int type, i; 1482 int num_pins = 0; 1483 1484 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) { 1485 for (i = 0; i < cfg->num_inputs; i++) { 1486 if (cfg->inputs[i].type != type) 1487 continue; 1488 if (can_be_multiio_pin(codec, location, 1489 cfg->inputs[i].pin)) 1490 num_pins++; 1491 } 1492 } 1493 return num_pins; 1494 } 1495 1496 /* 1497 * multi-io helper 1498 * 1499 * When hardwired is set, try to fill ony hardwired pins, and returns 1500 * zero if any pins are filled, non-zero if nothing found. 1501 * When hardwired is off, try to fill possible input pins, and returns 1502 * the badness value. 1503 */ 1504 static int fill_multi_ios(struct hda_codec *codec, 1505 hda_nid_t reference_pin, 1506 bool hardwired) 1507 { 1508 struct hda_gen_spec *spec = codec->spec; 1509 struct auto_pin_cfg *cfg = &spec->autocfg; 1510 int type, i, j, num_pins, old_pins; 1511 unsigned int defcfg = snd_hda_codec_get_pincfg(codec, reference_pin); 1512 unsigned int location = get_defcfg_location(defcfg); 1513 int badness = 0; 1514 struct nid_path *path; 1515 1516 old_pins = spec->multi_ios; 1517 if (old_pins >= 2) 1518 goto end_fill; 1519 1520 num_pins = count_multiio_pins(codec, reference_pin); 1521 if (num_pins < 2) 1522 goto end_fill; 1523 1524 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) { 1525 for (i = 0; i < cfg->num_inputs; i++) { 1526 hda_nid_t nid = cfg->inputs[i].pin; 1527 hda_nid_t dac = 0; 1528 1529 if (cfg->inputs[i].type != type) 1530 continue; 1531 if (!can_be_multiio_pin(codec, location, nid)) 1532 continue; 1533 for (j = 0; j < spec->multi_ios; j++) { 1534 if (nid == spec->multi_io[j].pin) 1535 break; 1536 } 1537 if (j < spec->multi_ios) 1538 continue; 1539 1540 if (hardwired) 1541 dac = get_dac_if_single(codec, nid); 1542 else if (!dac) 1543 dac = look_for_dac(codec, nid, false); 1544 if (!dac) { 1545 badness++; 1546 continue; 1547 } 1548 path = snd_hda_add_new_path(codec, dac, nid, 1549 -spec->mixer_nid); 1550 if (!path) { 1551 badness++; 1552 continue; 1553 } 1554 /* print_nid_path(codec, "multiio", path); */ 1555 spec->multi_io[spec->multi_ios].pin = nid; 1556 spec->multi_io[spec->multi_ios].dac = dac; 1557 spec->out_paths[cfg->line_outs + spec->multi_ios] = 1558 snd_hda_get_path_idx(codec, path); 1559 spec->multi_ios++; 1560 if (spec->multi_ios >= 2) 1561 break; 1562 } 1563 } 1564 end_fill: 1565 if (badness) 1566 badness = BAD_MULTI_IO; 1567 if (old_pins == spec->multi_ios) { 1568 if (hardwired) 1569 return 1; /* nothing found */ 1570 else 1571 return badness; /* no badness if nothing found */ 1572 } 1573 if (!hardwired && spec->multi_ios < 2) { 1574 /* cancel newly assigned paths */ 1575 spec->paths.used -= spec->multi_ios - old_pins; 1576 spec->multi_ios = old_pins; 1577 return badness; 1578 } 1579 1580 /* assign volume and mute controls */ 1581 for (i = old_pins; i < spec->multi_ios; i++) { 1582 path = snd_hda_get_path_from_idx(codec, spec->out_paths[cfg->line_outs + i]); 1583 badness += assign_out_path_ctls(codec, path); 1584 } 1585 1586 return badness; 1587 } 1588 1589 /* map DACs for all pins in the list if they are single connections */ 1590 static bool map_singles(struct hda_codec *codec, int outs, 1591 const hda_nid_t *pins, hda_nid_t *dacs, int *path_idx) 1592 { 1593 struct hda_gen_spec *spec = codec->spec; 1594 int i; 1595 bool found = false; 1596 for (i = 0; i < outs; i++) { 1597 struct nid_path *path; 1598 hda_nid_t dac; 1599 if (dacs[i]) 1600 continue; 1601 dac = get_dac_if_single(codec, pins[i]); 1602 if (!dac) 1603 continue; 1604 path = snd_hda_add_new_path(codec, dac, pins[i], 1605 -spec->mixer_nid); 1606 if (!path && !i && spec->mixer_nid) 1607 path = snd_hda_add_new_path(codec, dac, pins[i], 0); 1608 if (path) { 1609 dacs[i] = dac; 1610 found = true; 1611 /* print_nid_path(codec, "output", path); */ 1612 path->active = true; 1613 path_idx[i] = snd_hda_get_path_idx(codec, path); 1614 } 1615 } 1616 return found; 1617 } 1618 1619 static inline bool has_aamix_out_paths(struct hda_gen_spec *spec) 1620 { 1621 return spec->aamix_out_paths[0] || spec->aamix_out_paths[1] || 1622 spec->aamix_out_paths[2]; 1623 } 1624 1625 /* create a new path including aamix if available, and return its index */ 1626 static int check_aamix_out_path(struct hda_codec *codec, int path_idx) 1627 { 1628 struct hda_gen_spec *spec = codec->spec; 1629 struct nid_path *path; 1630 hda_nid_t path_dac, dac, pin; 1631 1632 path = snd_hda_get_path_from_idx(codec, path_idx); 1633 if (!path || !path->depth || 1634 is_nid_contained(path, spec->mixer_nid)) 1635 return 0; 1636 path_dac = path->path[0]; 1637 dac = spec->private_dac_nids[0]; 1638 pin = path->path[path->depth - 1]; 1639 path = snd_hda_add_new_path(codec, dac, pin, spec->mixer_nid); 1640 if (!path) { 1641 if (dac != path_dac) 1642 dac = path_dac; 1643 else if (spec->multiout.hp_out_nid[0]) 1644 dac = spec->multiout.hp_out_nid[0]; 1645 else if (spec->multiout.extra_out_nid[0]) 1646 dac = spec->multiout.extra_out_nid[0]; 1647 else 1648 dac = 0; 1649 if (dac) 1650 path = snd_hda_add_new_path(codec, dac, pin, 1651 spec->mixer_nid); 1652 } 1653 if (!path) 1654 return 0; 1655 /* print_nid_path(codec, "output-aamix", path); */ 1656 path->active = false; /* unused as default */ 1657 path->pin_fixed = true; /* static route */ 1658 return snd_hda_get_path_idx(codec, path); 1659 } 1660 1661 /* check whether the independent HP is available with the current config */ 1662 static bool indep_hp_possible(struct hda_codec *codec) 1663 { 1664 struct hda_gen_spec *spec = codec->spec; 1665 struct auto_pin_cfg *cfg = &spec->autocfg; 1666 struct nid_path *path; 1667 int i, idx; 1668 1669 if (cfg->line_out_type == AUTO_PIN_HP_OUT) 1670 idx = spec->out_paths[0]; 1671 else 1672 idx = spec->hp_paths[0]; 1673 path = snd_hda_get_path_from_idx(codec, idx); 1674 if (!path) 1675 return false; 1676 1677 /* assume no path conflicts unless aamix is involved */ 1678 if (!spec->mixer_nid || !is_nid_contained(path, spec->mixer_nid)) 1679 return true; 1680 1681 /* check whether output paths contain aamix */ 1682 for (i = 0; i < cfg->line_outs; i++) { 1683 if (spec->out_paths[i] == idx) 1684 break; 1685 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]); 1686 if (path && is_nid_contained(path, spec->mixer_nid)) 1687 return false; 1688 } 1689 for (i = 0; i < cfg->speaker_outs; i++) { 1690 path = snd_hda_get_path_from_idx(codec, spec->speaker_paths[i]); 1691 if (path && is_nid_contained(path, spec->mixer_nid)) 1692 return false; 1693 } 1694 1695 return true; 1696 } 1697 1698 /* fill the empty entries in the dac array for speaker/hp with the 1699 * shared dac pointed by the paths 1700 */ 1701 static void refill_shared_dacs(struct hda_codec *codec, int num_outs, 1702 hda_nid_t *dacs, int *path_idx) 1703 { 1704 struct nid_path *path; 1705 int i; 1706 1707 for (i = 0; i < num_outs; i++) { 1708 if (dacs[i]) 1709 continue; 1710 path = snd_hda_get_path_from_idx(codec, path_idx[i]); 1711 if (!path) 1712 continue; 1713 dacs[i] = path->path[0]; 1714 } 1715 } 1716 1717 /* fill in the dac_nids table from the parsed pin configuration */ 1718 static int fill_and_eval_dacs(struct hda_codec *codec, 1719 bool fill_hardwired, 1720 bool fill_mio_first) 1721 { 1722 struct hda_gen_spec *spec = codec->spec; 1723 struct auto_pin_cfg *cfg = &spec->autocfg; 1724 int i, err, badness; 1725 1726 /* set num_dacs once to full for look_for_dac() */ 1727 spec->multiout.num_dacs = cfg->line_outs; 1728 spec->multiout.dac_nids = spec->private_dac_nids; 1729 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids)); 1730 memset(spec->multiout.hp_out_nid, 0, sizeof(spec->multiout.hp_out_nid)); 1731 memset(spec->multiout.extra_out_nid, 0, sizeof(spec->multiout.extra_out_nid)); 1732 spec->multi_ios = 0; 1733 snd_array_free(&spec->paths); 1734 1735 /* clear path indices */ 1736 memset(spec->out_paths, 0, sizeof(spec->out_paths)); 1737 memset(spec->hp_paths, 0, sizeof(spec->hp_paths)); 1738 memset(spec->speaker_paths, 0, sizeof(spec->speaker_paths)); 1739 memset(spec->aamix_out_paths, 0, sizeof(spec->aamix_out_paths)); 1740 memset(spec->digout_paths, 0, sizeof(spec->digout_paths)); 1741 memset(spec->input_paths, 0, sizeof(spec->input_paths)); 1742 memset(spec->loopback_paths, 0, sizeof(spec->loopback_paths)); 1743 memset(&spec->digin_path, 0, sizeof(spec->digin_path)); 1744 1745 badness = 0; 1746 1747 /* fill hard-wired DACs first */ 1748 if (fill_hardwired) { 1749 bool mapped; 1750 do { 1751 mapped = map_singles(codec, cfg->line_outs, 1752 cfg->line_out_pins, 1753 spec->private_dac_nids, 1754 spec->out_paths); 1755 mapped |= map_singles(codec, cfg->hp_outs, 1756 cfg->hp_pins, 1757 spec->multiout.hp_out_nid, 1758 spec->hp_paths); 1759 mapped |= map_singles(codec, cfg->speaker_outs, 1760 cfg->speaker_pins, 1761 spec->multiout.extra_out_nid, 1762 spec->speaker_paths); 1763 if (!spec->no_multi_io && 1764 fill_mio_first && cfg->line_outs == 1 && 1765 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 1766 err = fill_multi_ios(codec, cfg->line_out_pins[0], true); 1767 if (!err) 1768 mapped = true; 1769 } 1770 } while (mapped); 1771 } 1772 1773 badness += try_assign_dacs(codec, cfg->line_outs, cfg->line_out_pins, 1774 spec->private_dac_nids, spec->out_paths, 1775 spec->main_out_badness); 1776 1777 if (!spec->no_multi_io && fill_mio_first && 1778 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 1779 /* try to fill multi-io first */ 1780 err = fill_multi_ios(codec, cfg->line_out_pins[0], false); 1781 if (err < 0) 1782 return err; 1783 /* we don't count badness at this stage yet */ 1784 } 1785 1786 if (cfg->line_out_type != AUTO_PIN_HP_OUT) { 1787 err = try_assign_dacs(codec, cfg->hp_outs, cfg->hp_pins, 1788 spec->multiout.hp_out_nid, 1789 spec->hp_paths, 1790 spec->extra_out_badness); 1791 if (err < 0) 1792 return err; 1793 badness += err; 1794 } 1795 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 1796 err = try_assign_dacs(codec, cfg->speaker_outs, 1797 cfg->speaker_pins, 1798 spec->multiout.extra_out_nid, 1799 spec->speaker_paths, 1800 spec->extra_out_badness); 1801 if (err < 0) 1802 return err; 1803 badness += err; 1804 } 1805 if (!spec->no_multi_io && 1806 cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 1807 err = fill_multi_ios(codec, cfg->line_out_pins[0], false); 1808 if (err < 0) 1809 return err; 1810 badness += err; 1811 } 1812 1813 if (spec->mixer_nid) { 1814 spec->aamix_out_paths[0] = 1815 check_aamix_out_path(codec, spec->out_paths[0]); 1816 if (cfg->line_out_type != AUTO_PIN_HP_OUT) 1817 spec->aamix_out_paths[1] = 1818 check_aamix_out_path(codec, spec->hp_paths[0]); 1819 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) 1820 spec->aamix_out_paths[2] = 1821 check_aamix_out_path(codec, spec->speaker_paths[0]); 1822 } 1823 1824 if (!spec->no_multi_io && 1825 cfg->hp_outs && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) 1826 if (count_multiio_pins(codec, cfg->hp_pins[0]) >= 2) 1827 spec->multi_ios = 1; /* give badness */ 1828 1829 /* re-count num_dacs and squash invalid entries */ 1830 spec->multiout.num_dacs = 0; 1831 for (i = 0; i < cfg->line_outs; i++) { 1832 if (spec->private_dac_nids[i]) 1833 spec->multiout.num_dacs++; 1834 else { 1835 memmove(spec->private_dac_nids + i, 1836 spec->private_dac_nids + i + 1, 1837 sizeof(hda_nid_t) * (cfg->line_outs - i - 1)); 1838 spec->private_dac_nids[cfg->line_outs - 1] = 0; 1839 } 1840 } 1841 1842 spec->ext_channel_count = spec->min_channel_count = 1843 spec->multiout.num_dacs * 2; 1844 1845 if (spec->multi_ios == 2) { 1846 for (i = 0; i < 2; i++) 1847 spec->private_dac_nids[spec->multiout.num_dacs++] = 1848 spec->multi_io[i].dac; 1849 } else if (spec->multi_ios) { 1850 spec->multi_ios = 0; 1851 badness += BAD_MULTI_IO; 1852 } 1853 1854 if (spec->indep_hp && !indep_hp_possible(codec)) 1855 badness += BAD_NO_INDEP_HP; 1856 1857 /* re-fill the shared DAC for speaker / headphone */ 1858 if (cfg->line_out_type != AUTO_PIN_HP_OUT) 1859 refill_shared_dacs(codec, cfg->hp_outs, 1860 spec->multiout.hp_out_nid, 1861 spec->hp_paths); 1862 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) 1863 refill_shared_dacs(codec, cfg->speaker_outs, 1864 spec->multiout.extra_out_nid, 1865 spec->speaker_paths); 1866 1867 return badness; 1868 } 1869 1870 #define DEBUG_BADNESS 1871 1872 #ifdef DEBUG_BADNESS 1873 #define debug_badness(fmt, ...) \ 1874 codec_dbg(codec, fmt, ##__VA_ARGS__) 1875 #else 1876 #define debug_badness(fmt, ...) \ 1877 do { if (0) codec_dbg(codec, fmt, ##__VA_ARGS__); } while (0) 1878 #endif 1879 1880 #ifdef DEBUG_BADNESS 1881 static inline void print_nid_path_idx(struct hda_codec *codec, 1882 const char *pfx, int idx) 1883 { 1884 struct nid_path *path; 1885 1886 path = snd_hda_get_path_from_idx(codec, idx); 1887 if (path) 1888 print_nid_path(codec, pfx, path); 1889 } 1890 1891 static void debug_show_configs(struct hda_codec *codec, 1892 struct auto_pin_cfg *cfg) 1893 { 1894 struct hda_gen_spec *spec = codec->spec; 1895 static const char * const lo_type[3] = { "LO", "SP", "HP" }; 1896 int i; 1897 1898 debug_badness("multi_outs = %x/%x/%x/%x : %x/%x/%x/%x (type %s)\n", 1899 cfg->line_out_pins[0], cfg->line_out_pins[1], 1900 cfg->line_out_pins[2], cfg->line_out_pins[3], 1901 spec->multiout.dac_nids[0], 1902 spec->multiout.dac_nids[1], 1903 spec->multiout.dac_nids[2], 1904 spec->multiout.dac_nids[3], 1905 lo_type[cfg->line_out_type]); 1906 for (i = 0; i < cfg->line_outs; i++) 1907 print_nid_path_idx(codec, " out", spec->out_paths[i]); 1908 if (spec->multi_ios > 0) 1909 debug_badness("multi_ios(%d) = %x/%x : %x/%x\n", 1910 spec->multi_ios, 1911 spec->multi_io[0].pin, spec->multi_io[1].pin, 1912 spec->multi_io[0].dac, spec->multi_io[1].dac); 1913 for (i = 0; i < spec->multi_ios; i++) 1914 print_nid_path_idx(codec, " mio", 1915 spec->out_paths[cfg->line_outs + i]); 1916 if (cfg->hp_outs) 1917 debug_badness("hp_outs = %x/%x/%x/%x : %x/%x/%x/%x\n", 1918 cfg->hp_pins[0], cfg->hp_pins[1], 1919 cfg->hp_pins[2], cfg->hp_pins[3], 1920 spec->multiout.hp_out_nid[0], 1921 spec->multiout.hp_out_nid[1], 1922 spec->multiout.hp_out_nid[2], 1923 spec->multiout.hp_out_nid[3]); 1924 for (i = 0; i < cfg->hp_outs; i++) 1925 print_nid_path_idx(codec, " hp ", spec->hp_paths[i]); 1926 if (cfg->speaker_outs) 1927 debug_badness("spk_outs = %x/%x/%x/%x : %x/%x/%x/%x\n", 1928 cfg->speaker_pins[0], cfg->speaker_pins[1], 1929 cfg->speaker_pins[2], cfg->speaker_pins[3], 1930 spec->multiout.extra_out_nid[0], 1931 spec->multiout.extra_out_nid[1], 1932 spec->multiout.extra_out_nid[2], 1933 spec->multiout.extra_out_nid[3]); 1934 for (i = 0; i < cfg->speaker_outs; i++) 1935 print_nid_path_idx(codec, " spk", spec->speaker_paths[i]); 1936 for (i = 0; i < 3; i++) 1937 print_nid_path_idx(codec, " mix", spec->aamix_out_paths[i]); 1938 } 1939 #else 1940 #define debug_show_configs(codec, cfg) /* NOP */ 1941 #endif 1942 1943 /* find all available DACs of the codec */ 1944 static void fill_all_dac_nids(struct hda_codec *codec) 1945 { 1946 struct hda_gen_spec *spec = codec->spec; 1947 hda_nid_t nid; 1948 1949 spec->num_all_dacs = 0; 1950 memset(spec->all_dacs, 0, sizeof(spec->all_dacs)); 1951 for_each_hda_codec_node(nid, codec) { 1952 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_OUT) 1953 continue; 1954 if (spec->num_all_dacs >= ARRAY_SIZE(spec->all_dacs)) { 1955 codec_err(codec, "Too many DACs!\n"); 1956 break; 1957 } 1958 spec->all_dacs[spec->num_all_dacs++] = nid; 1959 } 1960 } 1961 1962 static int parse_output_paths(struct hda_codec *codec) 1963 { 1964 struct hda_gen_spec *spec = codec->spec; 1965 struct auto_pin_cfg *cfg = &spec->autocfg; 1966 struct auto_pin_cfg *best_cfg; 1967 unsigned int val; 1968 int best_badness = INT_MAX; 1969 int badness; 1970 bool fill_hardwired = true, fill_mio_first = true; 1971 bool best_wired = true, best_mio = true; 1972 bool hp_spk_swapped = false; 1973 1974 best_cfg = kmalloc(sizeof(*best_cfg), GFP_KERNEL); 1975 if (!best_cfg) 1976 return -ENOMEM; 1977 *best_cfg = *cfg; 1978 1979 for (;;) { 1980 badness = fill_and_eval_dacs(codec, fill_hardwired, 1981 fill_mio_first); 1982 if (badness < 0) { 1983 kfree(best_cfg); 1984 return badness; 1985 } 1986 debug_badness("==> lo_type=%d, wired=%d, mio=%d, badness=0x%x\n", 1987 cfg->line_out_type, fill_hardwired, fill_mio_first, 1988 badness); 1989 debug_show_configs(codec, cfg); 1990 if (badness < best_badness) { 1991 best_badness = badness; 1992 *best_cfg = *cfg; 1993 best_wired = fill_hardwired; 1994 best_mio = fill_mio_first; 1995 } 1996 if (!badness) 1997 break; 1998 fill_mio_first = !fill_mio_first; 1999 if (!fill_mio_first) 2000 continue; 2001 fill_hardwired = !fill_hardwired; 2002 if (!fill_hardwired) 2003 continue; 2004 if (hp_spk_swapped) 2005 break; 2006 hp_spk_swapped = true; 2007 if (cfg->speaker_outs > 0 && 2008 cfg->line_out_type == AUTO_PIN_HP_OUT) { 2009 cfg->hp_outs = cfg->line_outs; 2010 memcpy(cfg->hp_pins, cfg->line_out_pins, 2011 sizeof(cfg->hp_pins)); 2012 cfg->line_outs = cfg->speaker_outs; 2013 memcpy(cfg->line_out_pins, cfg->speaker_pins, 2014 sizeof(cfg->speaker_pins)); 2015 cfg->speaker_outs = 0; 2016 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins)); 2017 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT; 2018 fill_hardwired = true; 2019 continue; 2020 } 2021 if (cfg->hp_outs > 0 && 2022 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) { 2023 cfg->speaker_outs = cfg->line_outs; 2024 memcpy(cfg->speaker_pins, cfg->line_out_pins, 2025 sizeof(cfg->speaker_pins)); 2026 cfg->line_outs = cfg->hp_outs; 2027 memcpy(cfg->line_out_pins, cfg->hp_pins, 2028 sizeof(cfg->hp_pins)); 2029 cfg->hp_outs = 0; 2030 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins)); 2031 cfg->line_out_type = AUTO_PIN_HP_OUT; 2032 fill_hardwired = true; 2033 continue; 2034 } 2035 break; 2036 } 2037 2038 if (badness) { 2039 debug_badness("==> restoring best_cfg\n"); 2040 *cfg = *best_cfg; 2041 fill_and_eval_dacs(codec, best_wired, best_mio); 2042 } 2043 debug_badness("==> Best config: lo_type=%d, wired=%d, mio=%d\n", 2044 cfg->line_out_type, best_wired, best_mio); 2045 debug_show_configs(codec, cfg); 2046 2047 if (cfg->line_out_pins[0]) { 2048 struct nid_path *path; 2049 path = snd_hda_get_path_from_idx(codec, spec->out_paths[0]); 2050 if (path) 2051 spec->vmaster_nid = look_for_out_vol_nid(codec, path); 2052 if (spec->vmaster_nid) { 2053 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 2054 HDA_OUTPUT, spec->vmaster_tlv); 2055 if (spec->dac_min_mute) 2056 spec->vmaster_tlv[SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP] |= TLV_DB_SCALE_MUTE; 2057 } 2058 } 2059 2060 /* set initial pinctl targets */ 2061 if (spec->prefer_hp_amp || cfg->line_out_type == AUTO_PIN_HP_OUT) 2062 val = PIN_HP; 2063 else 2064 val = PIN_OUT; 2065 set_pin_targets(codec, cfg->line_outs, cfg->line_out_pins, val); 2066 if (cfg->line_out_type != AUTO_PIN_HP_OUT) 2067 set_pin_targets(codec, cfg->hp_outs, cfg->hp_pins, PIN_HP); 2068 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 2069 val = spec->prefer_hp_amp ? PIN_HP : PIN_OUT; 2070 set_pin_targets(codec, cfg->speaker_outs, 2071 cfg->speaker_pins, val); 2072 } 2073 2074 /* clear indep_hp flag if not available */ 2075 if (spec->indep_hp && !indep_hp_possible(codec)) 2076 spec->indep_hp = 0; 2077 2078 kfree(best_cfg); 2079 return 0; 2080 } 2081 2082 /* add playback controls from the parsed DAC table */ 2083 static int create_multi_out_ctls(struct hda_codec *codec, 2084 const struct auto_pin_cfg *cfg) 2085 { 2086 struct hda_gen_spec *spec = codec->spec; 2087 int i, err, noutputs; 2088 2089 noutputs = cfg->line_outs; 2090 if (spec->multi_ios > 0 && cfg->line_outs < 3) 2091 noutputs += spec->multi_ios; 2092 2093 for (i = 0; i < noutputs; i++) { 2094 const char *name; 2095 int index; 2096 struct nid_path *path; 2097 2098 path = snd_hda_get_path_from_idx(codec, spec->out_paths[i]); 2099 if (!path) 2100 continue; 2101 2102 name = get_line_out_pfx(codec, i, &index, NID_PATH_VOL_CTL); 2103 if (!name || !strcmp(name, "CLFE")) { 2104 /* Center/LFE */ 2105 err = add_vol_ctl(codec, "Center", 0, 1, path); 2106 if (err < 0) 2107 return err; 2108 err = add_vol_ctl(codec, "LFE", 0, 2, path); 2109 if (err < 0) 2110 return err; 2111 } else { 2112 err = add_stereo_vol(codec, name, index, path); 2113 if (err < 0) 2114 return err; 2115 } 2116 2117 name = get_line_out_pfx(codec, i, &index, NID_PATH_MUTE_CTL); 2118 if (!name || !strcmp(name, "CLFE")) { 2119 err = add_sw_ctl(codec, "Center", 0, 1, path); 2120 if (err < 0) 2121 return err; 2122 err = add_sw_ctl(codec, "LFE", 0, 2, path); 2123 if (err < 0) 2124 return err; 2125 } else { 2126 err = add_stereo_sw(codec, name, index, path); 2127 if (err < 0) 2128 return err; 2129 } 2130 } 2131 return 0; 2132 } 2133 2134 static int create_extra_out(struct hda_codec *codec, int path_idx, 2135 const char *pfx, int cidx) 2136 { 2137 struct nid_path *path; 2138 int err; 2139 2140 path = snd_hda_get_path_from_idx(codec, path_idx); 2141 if (!path) 2142 return 0; 2143 err = add_stereo_vol(codec, pfx, cidx, path); 2144 if (err < 0) 2145 return err; 2146 err = add_stereo_sw(codec, pfx, cidx, path); 2147 if (err < 0) 2148 return err; 2149 return 0; 2150 } 2151 2152 /* add playback controls for speaker and HP outputs */ 2153 static int create_extra_outs(struct hda_codec *codec, int num_pins, 2154 const int *paths, const char *pfx) 2155 { 2156 int i; 2157 2158 for (i = 0; i < num_pins; i++) { 2159 const char *name; 2160 char tmp[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 2161 int err, idx = 0; 2162 2163 if (num_pins == 2 && i == 1 && !strcmp(pfx, "Speaker")) 2164 name = "Bass Speaker"; 2165 else if (num_pins >= 3) { 2166 snprintf(tmp, sizeof(tmp), "%s %s", 2167 pfx, channel_name[i]); 2168 name = tmp; 2169 } else { 2170 name = pfx; 2171 idx = i; 2172 } 2173 err = create_extra_out(codec, paths[i], name, idx); 2174 if (err < 0) 2175 return err; 2176 } 2177 return 0; 2178 } 2179 2180 static int create_hp_out_ctls(struct hda_codec *codec) 2181 { 2182 struct hda_gen_spec *spec = codec->spec; 2183 return create_extra_outs(codec, spec->autocfg.hp_outs, 2184 spec->hp_paths, 2185 "Headphone"); 2186 } 2187 2188 static int create_speaker_out_ctls(struct hda_codec *codec) 2189 { 2190 struct hda_gen_spec *spec = codec->spec; 2191 return create_extra_outs(codec, spec->autocfg.speaker_outs, 2192 spec->speaker_paths, 2193 "Speaker"); 2194 } 2195 2196 /* 2197 * independent HP controls 2198 */ 2199 2200 static void call_hp_automute(struct hda_codec *codec, 2201 struct hda_jack_callback *jack); 2202 static int indep_hp_info(struct snd_kcontrol *kcontrol, 2203 struct snd_ctl_elem_info *uinfo) 2204 { 2205 return snd_hda_enum_bool_helper_info(kcontrol, uinfo); 2206 } 2207 2208 static int indep_hp_get(struct snd_kcontrol *kcontrol, 2209 struct snd_ctl_elem_value *ucontrol) 2210 { 2211 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2212 struct hda_gen_spec *spec = codec->spec; 2213 ucontrol->value.enumerated.item[0] = spec->indep_hp_enabled; 2214 return 0; 2215 } 2216 2217 static void update_aamix_paths(struct hda_codec *codec, bool do_mix, 2218 int nomix_path_idx, int mix_path_idx, 2219 int out_type); 2220 2221 static int indep_hp_put(struct snd_kcontrol *kcontrol, 2222 struct snd_ctl_elem_value *ucontrol) 2223 { 2224 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2225 struct hda_gen_spec *spec = codec->spec; 2226 unsigned int select = ucontrol->value.enumerated.item[0]; 2227 int ret = 0; 2228 2229 mutex_lock(&spec->pcm_mutex); 2230 if (spec->active_streams) { 2231 ret = -EBUSY; 2232 goto unlock; 2233 } 2234 2235 if (spec->indep_hp_enabled != select) { 2236 hda_nid_t *dacp; 2237 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT) 2238 dacp = &spec->private_dac_nids[0]; 2239 else 2240 dacp = &spec->multiout.hp_out_nid[0]; 2241 2242 /* update HP aamix paths in case it conflicts with indep HP */ 2243 if (spec->have_aamix_ctl) { 2244 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT) 2245 update_aamix_paths(codec, spec->aamix_mode, 2246 spec->out_paths[0], 2247 spec->aamix_out_paths[0], 2248 spec->autocfg.line_out_type); 2249 else 2250 update_aamix_paths(codec, spec->aamix_mode, 2251 spec->hp_paths[0], 2252 spec->aamix_out_paths[1], 2253 AUTO_PIN_HP_OUT); 2254 } 2255 2256 spec->indep_hp_enabled = select; 2257 if (spec->indep_hp_enabled) 2258 *dacp = 0; 2259 else 2260 *dacp = spec->alt_dac_nid; 2261 2262 call_hp_automute(codec, NULL); 2263 ret = 1; 2264 } 2265 unlock: 2266 mutex_unlock(&spec->pcm_mutex); 2267 return ret; 2268 } 2269 2270 static const struct snd_kcontrol_new indep_hp_ctl = { 2271 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2272 .name = "Independent HP", 2273 .info = indep_hp_info, 2274 .get = indep_hp_get, 2275 .put = indep_hp_put, 2276 }; 2277 2278 2279 static int create_indep_hp_ctls(struct hda_codec *codec) 2280 { 2281 struct hda_gen_spec *spec = codec->spec; 2282 hda_nid_t dac; 2283 2284 if (!spec->indep_hp) 2285 return 0; 2286 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT) 2287 dac = spec->multiout.dac_nids[0]; 2288 else 2289 dac = spec->multiout.hp_out_nid[0]; 2290 if (!dac) { 2291 spec->indep_hp = 0; 2292 return 0; 2293 } 2294 2295 spec->indep_hp_enabled = false; 2296 spec->alt_dac_nid = dac; 2297 if (!snd_hda_gen_add_kctl(spec, NULL, &indep_hp_ctl)) 2298 return -ENOMEM; 2299 return 0; 2300 } 2301 2302 /* 2303 * channel mode enum control 2304 */ 2305 2306 static int ch_mode_info(struct snd_kcontrol *kcontrol, 2307 struct snd_ctl_elem_info *uinfo) 2308 { 2309 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2310 struct hda_gen_spec *spec = codec->spec; 2311 int chs; 2312 2313 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2314 uinfo->count = 1; 2315 uinfo->value.enumerated.items = spec->multi_ios + 1; 2316 if (uinfo->value.enumerated.item > spec->multi_ios) 2317 uinfo->value.enumerated.item = spec->multi_ios; 2318 chs = uinfo->value.enumerated.item * 2 + spec->min_channel_count; 2319 sprintf(uinfo->value.enumerated.name, "%dch", chs); 2320 return 0; 2321 } 2322 2323 static int ch_mode_get(struct snd_kcontrol *kcontrol, 2324 struct snd_ctl_elem_value *ucontrol) 2325 { 2326 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2327 struct hda_gen_spec *spec = codec->spec; 2328 ucontrol->value.enumerated.item[0] = 2329 (spec->ext_channel_count - spec->min_channel_count) / 2; 2330 return 0; 2331 } 2332 2333 static inline struct nid_path * 2334 get_multiio_path(struct hda_codec *codec, int idx) 2335 { 2336 struct hda_gen_spec *spec = codec->spec; 2337 return snd_hda_get_path_from_idx(codec, 2338 spec->out_paths[spec->autocfg.line_outs + idx]); 2339 } 2340 2341 static void update_automute_all(struct hda_codec *codec); 2342 2343 /* Default value to be passed as aamix argument for snd_hda_activate_path(); 2344 * used for output paths 2345 */ 2346 static bool aamix_default(struct hda_gen_spec *spec) 2347 { 2348 return !spec->have_aamix_ctl || spec->aamix_mode; 2349 } 2350 2351 static int set_multi_io(struct hda_codec *codec, int idx, bool output) 2352 { 2353 struct hda_gen_spec *spec = codec->spec; 2354 hda_nid_t nid = spec->multi_io[idx].pin; 2355 struct nid_path *path; 2356 2357 path = get_multiio_path(codec, idx); 2358 if (!path) 2359 return -EINVAL; 2360 2361 if (path->active == output) 2362 return 0; 2363 2364 if (output) { 2365 set_pin_target(codec, nid, PIN_OUT, true); 2366 snd_hda_activate_path(codec, path, true, aamix_default(spec)); 2367 set_pin_eapd(codec, nid, true); 2368 } else { 2369 set_pin_eapd(codec, nid, false); 2370 snd_hda_activate_path(codec, path, false, aamix_default(spec)); 2371 set_pin_target(codec, nid, spec->multi_io[idx].ctl_in, true); 2372 path_power_down_sync(codec, path); 2373 } 2374 2375 /* update jack retasking in case it modifies any of them */ 2376 update_automute_all(codec); 2377 2378 return 0; 2379 } 2380 2381 static int ch_mode_put(struct snd_kcontrol *kcontrol, 2382 struct snd_ctl_elem_value *ucontrol) 2383 { 2384 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2385 struct hda_gen_spec *spec = codec->spec; 2386 int i, ch; 2387 2388 ch = ucontrol->value.enumerated.item[0]; 2389 if (ch < 0 || ch > spec->multi_ios) 2390 return -EINVAL; 2391 if (ch == (spec->ext_channel_count - spec->min_channel_count) / 2) 2392 return 0; 2393 spec->ext_channel_count = ch * 2 + spec->min_channel_count; 2394 for (i = 0; i < spec->multi_ios; i++) 2395 set_multi_io(codec, i, i < ch); 2396 spec->multiout.max_channels = max(spec->ext_channel_count, 2397 spec->const_channel_count); 2398 if (spec->need_dac_fix) 2399 spec->multiout.num_dacs = spec->multiout.max_channels / 2; 2400 return 1; 2401 } 2402 2403 static const struct snd_kcontrol_new channel_mode_enum = { 2404 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2405 .name = "Channel Mode", 2406 .info = ch_mode_info, 2407 .get = ch_mode_get, 2408 .put = ch_mode_put, 2409 }; 2410 2411 static int create_multi_channel_mode(struct hda_codec *codec) 2412 { 2413 struct hda_gen_spec *spec = codec->spec; 2414 2415 if (spec->multi_ios > 0) { 2416 if (!snd_hda_gen_add_kctl(spec, NULL, &channel_mode_enum)) 2417 return -ENOMEM; 2418 } 2419 return 0; 2420 } 2421 2422 /* 2423 * aamix loopback enable/disable switch 2424 */ 2425 2426 #define loopback_mixing_info indep_hp_info 2427 2428 static int loopback_mixing_get(struct snd_kcontrol *kcontrol, 2429 struct snd_ctl_elem_value *ucontrol) 2430 { 2431 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2432 struct hda_gen_spec *spec = codec->spec; 2433 ucontrol->value.enumerated.item[0] = spec->aamix_mode; 2434 return 0; 2435 } 2436 2437 static void update_aamix_paths(struct hda_codec *codec, bool do_mix, 2438 int nomix_path_idx, int mix_path_idx, 2439 int out_type) 2440 { 2441 struct hda_gen_spec *spec = codec->spec; 2442 struct nid_path *nomix_path, *mix_path; 2443 2444 nomix_path = snd_hda_get_path_from_idx(codec, nomix_path_idx); 2445 mix_path = snd_hda_get_path_from_idx(codec, mix_path_idx); 2446 if (!nomix_path || !mix_path) 2447 return; 2448 2449 /* if HP aamix path is driven from a different DAC and the 2450 * independent HP mode is ON, can't turn on aamix path 2451 */ 2452 if (out_type == AUTO_PIN_HP_OUT && spec->indep_hp_enabled && 2453 mix_path->path[0] != spec->alt_dac_nid) 2454 do_mix = false; 2455 2456 if (do_mix) { 2457 snd_hda_activate_path(codec, nomix_path, false, true); 2458 snd_hda_activate_path(codec, mix_path, true, true); 2459 path_power_down_sync(codec, nomix_path); 2460 } else { 2461 snd_hda_activate_path(codec, mix_path, false, false); 2462 snd_hda_activate_path(codec, nomix_path, true, false); 2463 path_power_down_sync(codec, mix_path); 2464 } 2465 } 2466 2467 /* re-initialize the output paths; only called from loopback_mixing_put() */ 2468 static void update_output_paths(struct hda_codec *codec, int num_outs, 2469 const int *paths) 2470 { 2471 struct hda_gen_spec *spec = codec->spec; 2472 struct nid_path *path; 2473 int i; 2474 2475 for (i = 0; i < num_outs; i++) { 2476 path = snd_hda_get_path_from_idx(codec, paths[i]); 2477 if (path) 2478 snd_hda_activate_path(codec, path, path->active, 2479 spec->aamix_mode); 2480 } 2481 } 2482 2483 static int loopback_mixing_put(struct snd_kcontrol *kcontrol, 2484 struct snd_ctl_elem_value *ucontrol) 2485 { 2486 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2487 struct hda_gen_spec *spec = codec->spec; 2488 const struct auto_pin_cfg *cfg = &spec->autocfg; 2489 unsigned int val = ucontrol->value.enumerated.item[0]; 2490 2491 if (val == spec->aamix_mode) 2492 return 0; 2493 spec->aamix_mode = val; 2494 if (has_aamix_out_paths(spec)) { 2495 update_aamix_paths(codec, val, spec->out_paths[0], 2496 spec->aamix_out_paths[0], 2497 cfg->line_out_type); 2498 update_aamix_paths(codec, val, spec->hp_paths[0], 2499 spec->aamix_out_paths[1], 2500 AUTO_PIN_HP_OUT); 2501 update_aamix_paths(codec, val, spec->speaker_paths[0], 2502 spec->aamix_out_paths[2], 2503 AUTO_PIN_SPEAKER_OUT); 2504 } else { 2505 update_output_paths(codec, cfg->line_outs, spec->out_paths); 2506 if (cfg->line_out_type != AUTO_PIN_HP_OUT) 2507 update_output_paths(codec, cfg->hp_outs, spec->hp_paths); 2508 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) 2509 update_output_paths(codec, cfg->speaker_outs, 2510 spec->speaker_paths); 2511 } 2512 return 1; 2513 } 2514 2515 static const struct snd_kcontrol_new loopback_mixing_enum = { 2516 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2517 .name = "Loopback Mixing", 2518 .info = loopback_mixing_info, 2519 .get = loopback_mixing_get, 2520 .put = loopback_mixing_put, 2521 }; 2522 2523 static int create_loopback_mixing_ctl(struct hda_codec *codec) 2524 { 2525 struct hda_gen_spec *spec = codec->spec; 2526 2527 if (!spec->mixer_nid) 2528 return 0; 2529 if (!snd_hda_gen_add_kctl(spec, NULL, &loopback_mixing_enum)) 2530 return -ENOMEM; 2531 spec->have_aamix_ctl = 1; 2532 return 0; 2533 } 2534 2535 /* 2536 * shared headphone/mic handling 2537 */ 2538 2539 static void call_update_outputs(struct hda_codec *codec); 2540 2541 /* for shared I/O, change the pin-control accordingly */ 2542 static void update_hp_mic(struct hda_codec *codec, int adc_mux, bool force) 2543 { 2544 struct hda_gen_spec *spec = codec->spec; 2545 bool as_mic; 2546 unsigned int val; 2547 hda_nid_t pin; 2548 2549 pin = spec->hp_mic_pin; 2550 as_mic = spec->cur_mux[adc_mux] == spec->hp_mic_mux_idx; 2551 2552 if (!force) { 2553 val = snd_hda_codec_get_pin_target(codec, pin); 2554 if (as_mic) { 2555 if (val & PIN_IN) 2556 return; 2557 } else { 2558 if (val & PIN_OUT) 2559 return; 2560 } 2561 } 2562 2563 val = snd_hda_get_default_vref(codec, pin); 2564 /* if the HP pin doesn't support VREF and the codec driver gives an 2565 * alternative pin, set up the VREF on that pin instead 2566 */ 2567 if (val == AC_PINCTL_VREF_HIZ && spec->shared_mic_vref_pin) { 2568 const hda_nid_t vref_pin = spec->shared_mic_vref_pin; 2569 unsigned int vref_val = snd_hda_get_default_vref(codec, vref_pin); 2570 if (vref_val != AC_PINCTL_VREF_HIZ) 2571 snd_hda_set_pin_ctl_cache(codec, vref_pin, 2572 PIN_IN | (as_mic ? vref_val : 0)); 2573 } 2574 2575 if (!spec->hp_mic_jack_modes) { 2576 if (as_mic) 2577 val |= PIN_IN; 2578 else 2579 val = PIN_HP; 2580 set_pin_target(codec, pin, val, true); 2581 call_hp_automute(codec, NULL); 2582 } 2583 } 2584 2585 /* create a shared input with the headphone out */ 2586 static int create_hp_mic(struct hda_codec *codec) 2587 { 2588 struct hda_gen_spec *spec = codec->spec; 2589 struct auto_pin_cfg *cfg = &spec->autocfg; 2590 unsigned int defcfg; 2591 hda_nid_t nid; 2592 2593 if (!spec->hp_mic) { 2594 if (spec->suppress_hp_mic_detect) 2595 return 0; 2596 /* automatic detection: only if no input or a single internal 2597 * input pin is found, try to detect the shared hp/mic 2598 */ 2599 if (cfg->num_inputs > 1) 2600 return 0; 2601 else if (cfg->num_inputs == 1) { 2602 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin); 2603 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT) 2604 return 0; 2605 } 2606 } 2607 2608 spec->hp_mic = 0; /* clear once */ 2609 if (cfg->num_inputs >= AUTO_CFG_MAX_INS) 2610 return 0; 2611 2612 nid = 0; 2613 if (cfg->line_out_type == AUTO_PIN_HP_OUT && cfg->line_outs > 0) 2614 nid = cfg->line_out_pins[0]; 2615 else if (cfg->hp_outs > 0) 2616 nid = cfg->hp_pins[0]; 2617 if (!nid) 2618 return 0; 2619 2620 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN)) 2621 return 0; /* no input */ 2622 2623 cfg->inputs[cfg->num_inputs].pin = nid; 2624 cfg->inputs[cfg->num_inputs].type = AUTO_PIN_MIC; 2625 cfg->inputs[cfg->num_inputs].is_headphone_mic = 1; 2626 cfg->num_inputs++; 2627 spec->hp_mic = 1; 2628 spec->hp_mic_pin = nid; 2629 /* we can't handle auto-mic together with HP-mic */ 2630 spec->suppress_auto_mic = 1; 2631 codec_dbg(codec, "Enable shared I/O jack on NID 0x%x\n", nid); 2632 return 0; 2633 } 2634 2635 /* 2636 * output jack mode 2637 */ 2638 2639 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin); 2640 2641 static const char * const out_jack_texts[] = { 2642 "Line Out", "Headphone Out", 2643 }; 2644 2645 static int out_jack_mode_info(struct snd_kcontrol *kcontrol, 2646 struct snd_ctl_elem_info *uinfo) 2647 { 2648 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, out_jack_texts); 2649 } 2650 2651 static int out_jack_mode_get(struct snd_kcontrol *kcontrol, 2652 struct snd_ctl_elem_value *ucontrol) 2653 { 2654 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2655 hda_nid_t nid = kcontrol->private_value; 2656 if (snd_hda_codec_get_pin_target(codec, nid) == PIN_HP) 2657 ucontrol->value.enumerated.item[0] = 1; 2658 else 2659 ucontrol->value.enumerated.item[0] = 0; 2660 return 0; 2661 } 2662 2663 static int out_jack_mode_put(struct snd_kcontrol *kcontrol, 2664 struct snd_ctl_elem_value *ucontrol) 2665 { 2666 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2667 hda_nid_t nid = kcontrol->private_value; 2668 unsigned int val; 2669 2670 val = ucontrol->value.enumerated.item[0] ? PIN_HP : PIN_OUT; 2671 if (snd_hda_codec_get_pin_target(codec, nid) == val) 2672 return 0; 2673 snd_hda_set_pin_ctl_cache(codec, nid, val); 2674 return 1; 2675 } 2676 2677 static const struct snd_kcontrol_new out_jack_mode_enum = { 2678 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2679 .info = out_jack_mode_info, 2680 .get = out_jack_mode_get, 2681 .put = out_jack_mode_put, 2682 }; 2683 2684 static bool find_kctl_name(struct hda_codec *codec, const char *name, int idx) 2685 { 2686 struct hda_gen_spec *spec = codec->spec; 2687 const struct snd_kcontrol_new *kctl; 2688 int i; 2689 2690 snd_array_for_each(&spec->kctls, i, kctl) { 2691 if (!strcmp(kctl->name, name) && kctl->index == idx) 2692 return true; 2693 } 2694 return false; 2695 } 2696 2697 static void get_jack_mode_name(struct hda_codec *codec, hda_nid_t pin, 2698 char *name, size_t name_len) 2699 { 2700 struct hda_gen_spec *spec = codec->spec; 2701 int idx = 0; 2702 2703 snd_hda_get_pin_label(codec, pin, &spec->autocfg, name, name_len, &idx); 2704 strlcat(name, " Jack Mode", name_len); 2705 2706 for (; find_kctl_name(codec, name, idx); idx++) 2707 ; 2708 } 2709 2710 static int get_out_jack_num_items(struct hda_codec *codec, hda_nid_t pin) 2711 { 2712 struct hda_gen_spec *spec = codec->spec; 2713 if (spec->add_jack_modes) { 2714 unsigned int pincap = snd_hda_query_pin_caps(codec, pin); 2715 if ((pincap & AC_PINCAP_OUT) && (pincap & AC_PINCAP_HP_DRV)) 2716 return 2; 2717 } 2718 return 1; 2719 } 2720 2721 static int create_out_jack_modes(struct hda_codec *codec, int num_pins, 2722 hda_nid_t *pins) 2723 { 2724 struct hda_gen_spec *spec = codec->spec; 2725 int i; 2726 2727 for (i = 0; i < num_pins; i++) { 2728 hda_nid_t pin = pins[i]; 2729 if (pin == spec->hp_mic_pin) 2730 continue; 2731 if (get_out_jack_num_items(codec, pin) > 1) { 2732 struct snd_kcontrol_new *knew; 2733 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 2734 get_jack_mode_name(codec, pin, name, sizeof(name)); 2735 knew = snd_hda_gen_add_kctl(spec, name, 2736 &out_jack_mode_enum); 2737 if (!knew) 2738 return -ENOMEM; 2739 knew->private_value = pin; 2740 } 2741 } 2742 2743 return 0; 2744 } 2745 2746 /* 2747 * input jack mode 2748 */ 2749 2750 /* from AC_PINCTL_VREF_HIZ to AC_PINCTL_VREF_100 */ 2751 #define NUM_VREFS 6 2752 2753 static const char * const vref_texts[NUM_VREFS] = { 2754 "Line In", "Mic 50pc Bias", "Mic 0V Bias", 2755 "", "Mic 80pc Bias", "Mic 100pc Bias" 2756 }; 2757 2758 static unsigned int get_vref_caps(struct hda_codec *codec, hda_nid_t pin) 2759 { 2760 unsigned int pincap; 2761 2762 pincap = snd_hda_query_pin_caps(codec, pin); 2763 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT; 2764 /* filter out unusual vrefs */ 2765 pincap &= ~(AC_PINCAP_VREF_GRD | AC_PINCAP_VREF_100); 2766 return pincap; 2767 } 2768 2769 /* convert from the enum item index to the vref ctl index (0=HIZ, 1=50%...) */ 2770 static int get_vref_idx(unsigned int vref_caps, unsigned int item_idx) 2771 { 2772 unsigned int i, n = 0; 2773 2774 for (i = 0; i < NUM_VREFS; i++) { 2775 if (vref_caps & (1 << i)) { 2776 if (n == item_idx) 2777 return i; 2778 n++; 2779 } 2780 } 2781 return 0; 2782 } 2783 2784 /* convert back from the vref ctl index to the enum item index */ 2785 static int cvt_from_vref_idx(unsigned int vref_caps, unsigned int idx) 2786 { 2787 unsigned int i, n = 0; 2788 2789 for (i = 0; i < NUM_VREFS; i++) { 2790 if (i == idx) 2791 return n; 2792 if (vref_caps & (1 << i)) 2793 n++; 2794 } 2795 return 0; 2796 } 2797 2798 static int in_jack_mode_info(struct snd_kcontrol *kcontrol, 2799 struct snd_ctl_elem_info *uinfo) 2800 { 2801 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2802 hda_nid_t nid = kcontrol->private_value; 2803 unsigned int vref_caps = get_vref_caps(codec, nid); 2804 2805 snd_hda_enum_helper_info(kcontrol, uinfo, hweight32(vref_caps), 2806 vref_texts); 2807 /* set the right text */ 2808 strcpy(uinfo->value.enumerated.name, 2809 vref_texts[get_vref_idx(vref_caps, uinfo->value.enumerated.item)]); 2810 return 0; 2811 } 2812 2813 static int in_jack_mode_get(struct snd_kcontrol *kcontrol, 2814 struct snd_ctl_elem_value *ucontrol) 2815 { 2816 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2817 hda_nid_t nid = kcontrol->private_value; 2818 unsigned int vref_caps = get_vref_caps(codec, nid); 2819 unsigned int idx; 2820 2821 idx = snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_VREFEN; 2822 ucontrol->value.enumerated.item[0] = cvt_from_vref_idx(vref_caps, idx); 2823 return 0; 2824 } 2825 2826 static int in_jack_mode_put(struct snd_kcontrol *kcontrol, 2827 struct snd_ctl_elem_value *ucontrol) 2828 { 2829 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2830 hda_nid_t nid = kcontrol->private_value; 2831 unsigned int vref_caps = get_vref_caps(codec, nid); 2832 unsigned int val, idx; 2833 2834 val = snd_hda_codec_get_pin_target(codec, nid); 2835 idx = cvt_from_vref_idx(vref_caps, val & AC_PINCTL_VREFEN); 2836 if (idx == ucontrol->value.enumerated.item[0]) 2837 return 0; 2838 2839 val &= ~AC_PINCTL_VREFEN; 2840 val |= get_vref_idx(vref_caps, ucontrol->value.enumerated.item[0]); 2841 snd_hda_set_pin_ctl_cache(codec, nid, val); 2842 return 1; 2843 } 2844 2845 static const struct snd_kcontrol_new in_jack_mode_enum = { 2846 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2847 .info = in_jack_mode_info, 2848 .get = in_jack_mode_get, 2849 .put = in_jack_mode_put, 2850 }; 2851 2852 static int get_in_jack_num_items(struct hda_codec *codec, hda_nid_t pin) 2853 { 2854 struct hda_gen_spec *spec = codec->spec; 2855 int nitems = 0; 2856 if (spec->add_jack_modes) 2857 nitems = hweight32(get_vref_caps(codec, pin)); 2858 return nitems ? nitems : 1; 2859 } 2860 2861 static int create_in_jack_mode(struct hda_codec *codec, hda_nid_t pin) 2862 { 2863 struct hda_gen_spec *spec = codec->spec; 2864 struct snd_kcontrol_new *knew; 2865 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 2866 unsigned int defcfg; 2867 2868 if (pin == spec->hp_mic_pin) 2869 return 0; /* already done in create_out_jack_mode() */ 2870 2871 /* no jack mode for fixed pins */ 2872 defcfg = snd_hda_codec_get_pincfg(codec, pin); 2873 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT) 2874 return 0; 2875 2876 /* no multiple vref caps? */ 2877 if (get_in_jack_num_items(codec, pin) <= 1) 2878 return 0; 2879 2880 get_jack_mode_name(codec, pin, name, sizeof(name)); 2881 knew = snd_hda_gen_add_kctl(spec, name, &in_jack_mode_enum); 2882 if (!knew) 2883 return -ENOMEM; 2884 knew->private_value = pin; 2885 return 0; 2886 } 2887 2888 /* 2889 * HP/mic shared jack mode 2890 */ 2891 static int hp_mic_jack_mode_info(struct snd_kcontrol *kcontrol, 2892 struct snd_ctl_elem_info *uinfo) 2893 { 2894 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2895 hda_nid_t nid = kcontrol->private_value; 2896 int out_jacks = get_out_jack_num_items(codec, nid); 2897 int in_jacks = get_in_jack_num_items(codec, nid); 2898 const char *text = NULL; 2899 int idx; 2900 2901 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2902 uinfo->count = 1; 2903 uinfo->value.enumerated.items = out_jacks + in_jacks; 2904 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) 2905 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; 2906 idx = uinfo->value.enumerated.item; 2907 if (idx < out_jacks) { 2908 if (out_jacks > 1) 2909 text = out_jack_texts[idx]; 2910 else 2911 text = "Headphone Out"; 2912 } else { 2913 idx -= out_jacks; 2914 if (in_jacks > 1) { 2915 unsigned int vref_caps = get_vref_caps(codec, nid); 2916 text = vref_texts[get_vref_idx(vref_caps, idx)]; 2917 } else 2918 text = "Mic In"; 2919 } 2920 2921 strcpy(uinfo->value.enumerated.name, text); 2922 return 0; 2923 } 2924 2925 static int get_cur_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t nid) 2926 { 2927 int out_jacks = get_out_jack_num_items(codec, nid); 2928 int in_jacks = get_in_jack_num_items(codec, nid); 2929 unsigned int val = snd_hda_codec_get_pin_target(codec, nid); 2930 int idx = 0; 2931 2932 if (val & PIN_OUT) { 2933 if (out_jacks > 1 && val == PIN_HP) 2934 idx = 1; 2935 } else if (val & PIN_IN) { 2936 idx = out_jacks; 2937 if (in_jacks > 1) { 2938 unsigned int vref_caps = get_vref_caps(codec, nid); 2939 val &= AC_PINCTL_VREFEN; 2940 idx += cvt_from_vref_idx(vref_caps, val); 2941 } 2942 } 2943 return idx; 2944 } 2945 2946 static int hp_mic_jack_mode_get(struct snd_kcontrol *kcontrol, 2947 struct snd_ctl_elem_value *ucontrol) 2948 { 2949 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2950 hda_nid_t nid = kcontrol->private_value; 2951 ucontrol->value.enumerated.item[0] = 2952 get_cur_hp_mic_jack_mode(codec, nid); 2953 return 0; 2954 } 2955 2956 static int hp_mic_jack_mode_put(struct snd_kcontrol *kcontrol, 2957 struct snd_ctl_elem_value *ucontrol) 2958 { 2959 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2960 hda_nid_t nid = kcontrol->private_value; 2961 int out_jacks = get_out_jack_num_items(codec, nid); 2962 int in_jacks = get_in_jack_num_items(codec, nid); 2963 unsigned int val, oldval, idx; 2964 2965 oldval = get_cur_hp_mic_jack_mode(codec, nid); 2966 idx = ucontrol->value.enumerated.item[0]; 2967 if (oldval == idx) 2968 return 0; 2969 2970 if (idx < out_jacks) { 2971 if (out_jacks > 1) 2972 val = idx ? PIN_HP : PIN_OUT; 2973 else 2974 val = PIN_HP; 2975 } else { 2976 idx -= out_jacks; 2977 if (in_jacks > 1) { 2978 unsigned int vref_caps = get_vref_caps(codec, nid); 2979 val = snd_hda_codec_get_pin_target(codec, nid); 2980 val &= ~(AC_PINCTL_VREFEN | PIN_HP); 2981 val |= get_vref_idx(vref_caps, idx) | PIN_IN; 2982 } else 2983 val = snd_hda_get_default_vref(codec, nid) | PIN_IN; 2984 } 2985 snd_hda_set_pin_ctl_cache(codec, nid, val); 2986 call_hp_automute(codec, NULL); 2987 2988 return 1; 2989 } 2990 2991 static const struct snd_kcontrol_new hp_mic_jack_mode_enum = { 2992 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2993 .info = hp_mic_jack_mode_info, 2994 .get = hp_mic_jack_mode_get, 2995 .put = hp_mic_jack_mode_put, 2996 }; 2997 2998 static int create_hp_mic_jack_mode(struct hda_codec *codec, hda_nid_t pin) 2999 { 3000 struct hda_gen_spec *spec = codec->spec; 3001 struct snd_kcontrol_new *knew; 3002 3003 knew = snd_hda_gen_add_kctl(spec, "Headphone Mic Jack Mode", 3004 &hp_mic_jack_mode_enum); 3005 if (!knew) 3006 return -ENOMEM; 3007 knew->private_value = pin; 3008 spec->hp_mic_jack_modes = 1; 3009 return 0; 3010 } 3011 3012 /* 3013 * Parse input paths 3014 */ 3015 3016 /* add the powersave loopback-list entry */ 3017 static int add_loopback_list(struct hda_gen_spec *spec, hda_nid_t mix, int idx) 3018 { 3019 struct hda_amp_list *list; 3020 3021 list = snd_array_new(&spec->loopback_list); 3022 if (!list) 3023 return -ENOMEM; 3024 list->nid = mix; 3025 list->dir = HDA_INPUT; 3026 list->idx = idx; 3027 spec->loopback.amplist = spec->loopback_list.list; 3028 return 0; 3029 } 3030 3031 /* return true if either a volume or a mute amp is found for the given 3032 * aamix path; the amp has to be either in the mixer node or its direct leaf 3033 */ 3034 static bool look_for_mix_leaf_ctls(struct hda_codec *codec, hda_nid_t mix_nid, 3035 hda_nid_t pin, unsigned int *mix_val, 3036 unsigned int *mute_val) 3037 { 3038 int idx, num_conns; 3039 const hda_nid_t *list; 3040 hda_nid_t nid; 3041 3042 idx = snd_hda_get_conn_index(codec, mix_nid, pin, true); 3043 if (idx < 0) 3044 return false; 3045 3046 *mix_val = *mute_val = 0; 3047 if (nid_has_volume(codec, mix_nid, HDA_INPUT)) 3048 *mix_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT); 3049 if (nid_has_mute(codec, mix_nid, HDA_INPUT)) 3050 *mute_val = HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT); 3051 if (*mix_val && *mute_val) 3052 return true; 3053 3054 /* check leaf node */ 3055 num_conns = snd_hda_get_conn_list(codec, mix_nid, &list); 3056 if (num_conns < idx) 3057 return false; 3058 nid = list[idx]; 3059 if (!*mix_val && nid_has_volume(codec, nid, HDA_OUTPUT) && 3060 !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_VOL_CTL)) 3061 *mix_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 3062 if (!*mute_val && nid_has_mute(codec, nid, HDA_OUTPUT) && 3063 !is_ctl_associated(codec, nid, HDA_OUTPUT, 0, NID_PATH_MUTE_CTL)) 3064 *mute_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 3065 3066 return *mix_val || *mute_val; 3067 } 3068 3069 /* create input playback/capture controls for the given pin */ 3070 static int new_analog_input(struct hda_codec *codec, int input_idx, 3071 hda_nid_t pin, const char *ctlname, int ctlidx, 3072 hda_nid_t mix_nid) 3073 { 3074 struct hda_gen_spec *spec = codec->spec; 3075 struct nid_path *path; 3076 unsigned int mix_val, mute_val; 3077 int err, idx; 3078 3079 if (!look_for_mix_leaf_ctls(codec, mix_nid, pin, &mix_val, &mute_val)) 3080 return 0; 3081 3082 path = snd_hda_add_new_path(codec, pin, mix_nid, 0); 3083 if (!path) 3084 return -EINVAL; 3085 print_nid_path(codec, "loopback", path); 3086 spec->loopback_paths[input_idx] = snd_hda_get_path_idx(codec, path); 3087 3088 idx = path->idx[path->depth - 1]; 3089 if (mix_val) { 3090 err = __add_pb_vol_ctrl(spec, HDA_CTL_WIDGET_VOL, ctlname, ctlidx, mix_val); 3091 if (err < 0) 3092 return err; 3093 path->ctls[NID_PATH_VOL_CTL] = mix_val; 3094 } 3095 3096 if (mute_val) { 3097 err = __add_pb_sw_ctrl(spec, HDA_CTL_WIDGET_MUTE, ctlname, ctlidx, mute_val); 3098 if (err < 0) 3099 return err; 3100 path->ctls[NID_PATH_MUTE_CTL] = mute_val; 3101 } 3102 3103 path->active = true; 3104 path->stream_enabled = true; /* no DAC/ADC involved */ 3105 err = add_loopback_list(spec, mix_nid, idx); 3106 if (err < 0) 3107 return err; 3108 3109 if (spec->mixer_nid != spec->mixer_merge_nid && 3110 !spec->loopback_merge_path) { 3111 path = snd_hda_add_new_path(codec, spec->mixer_nid, 3112 spec->mixer_merge_nid, 0); 3113 if (path) { 3114 print_nid_path(codec, "loopback-merge", path); 3115 path->active = true; 3116 path->pin_fixed = true; /* static route */ 3117 path->stream_enabled = true; /* no DAC/ADC involved */ 3118 spec->loopback_merge_path = 3119 snd_hda_get_path_idx(codec, path); 3120 } 3121 } 3122 3123 return 0; 3124 } 3125 3126 static int is_input_pin(struct hda_codec *codec, hda_nid_t nid) 3127 { 3128 unsigned int pincap = snd_hda_query_pin_caps(codec, nid); 3129 return (pincap & AC_PINCAP_IN) != 0; 3130 } 3131 3132 /* Parse the codec tree and retrieve ADCs */ 3133 static int fill_adc_nids(struct hda_codec *codec) 3134 { 3135 struct hda_gen_spec *spec = codec->spec; 3136 hda_nid_t nid; 3137 hda_nid_t *adc_nids = spec->adc_nids; 3138 int max_nums = ARRAY_SIZE(spec->adc_nids); 3139 int nums = 0; 3140 3141 for_each_hda_codec_node(nid, codec) { 3142 unsigned int caps = get_wcaps(codec, nid); 3143 int type = get_wcaps_type(caps); 3144 3145 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL)) 3146 continue; 3147 adc_nids[nums] = nid; 3148 if (++nums >= max_nums) 3149 break; 3150 } 3151 spec->num_adc_nids = nums; 3152 3153 /* copy the detected ADCs to all_adcs[] */ 3154 spec->num_all_adcs = nums; 3155 memcpy(spec->all_adcs, spec->adc_nids, nums * sizeof(hda_nid_t)); 3156 3157 return nums; 3158 } 3159 3160 /* filter out invalid adc_nids that don't give all active input pins; 3161 * if needed, check whether dynamic ADC-switching is available 3162 */ 3163 static int check_dyn_adc_switch(struct hda_codec *codec) 3164 { 3165 struct hda_gen_spec *spec = codec->spec; 3166 struct hda_input_mux *imux = &spec->input_mux; 3167 unsigned int ok_bits; 3168 int i, n, nums; 3169 3170 nums = 0; 3171 ok_bits = 0; 3172 for (n = 0; n < spec->num_adc_nids; n++) { 3173 for (i = 0; i < imux->num_items; i++) { 3174 if (!spec->input_paths[i][n]) 3175 break; 3176 } 3177 if (i >= imux->num_items) { 3178 ok_bits |= (1 << n); 3179 nums++; 3180 } 3181 } 3182 3183 if (!ok_bits) { 3184 /* check whether ADC-switch is possible */ 3185 for (i = 0; i < imux->num_items; i++) { 3186 for (n = 0; n < spec->num_adc_nids; n++) { 3187 if (spec->input_paths[i][n]) { 3188 spec->dyn_adc_idx[i] = n; 3189 break; 3190 } 3191 } 3192 } 3193 3194 codec_dbg(codec, "enabling ADC switching\n"); 3195 spec->dyn_adc_switch = 1; 3196 } else if (nums != spec->num_adc_nids) { 3197 /* shrink the invalid adcs and input paths */ 3198 nums = 0; 3199 for (n = 0; n < spec->num_adc_nids; n++) { 3200 if (!(ok_bits & (1 << n))) 3201 continue; 3202 if (n != nums) { 3203 spec->adc_nids[nums] = spec->adc_nids[n]; 3204 for (i = 0; i < imux->num_items; i++) { 3205 invalidate_nid_path(codec, 3206 spec->input_paths[i][nums]); 3207 spec->input_paths[i][nums] = 3208 spec->input_paths[i][n]; 3209 spec->input_paths[i][n] = 0; 3210 } 3211 } 3212 nums++; 3213 } 3214 spec->num_adc_nids = nums; 3215 } 3216 3217 if (imux->num_items == 1 || 3218 (imux->num_items == 2 && spec->hp_mic)) { 3219 codec_dbg(codec, "reducing to a single ADC\n"); 3220 spec->num_adc_nids = 1; /* reduce to a single ADC */ 3221 } 3222 3223 /* single index for individual volumes ctls */ 3224 if (!spec->dyn_adc_switch && spec->multi_cap_vol) 3225 spec->num_adc_nids = 1; 3226 3227 return 0; 3228 } 3229 3230 /* parse capture source paths from the given pin and create imux items */ 3231 static int parse_capture_source(struct hda_codec *codec, hda_nid_t pin, 3232 int cfg_idx, int num_adcs, 3233 const char *label, int anchor) 3234 { 3235 struct hda_gen_spec *spec = codec->spec; 3236 struct hda_input_mux *imux = &spec->input_mux; 3237 int imux_idx = imux->num_items; 3238 bool imux_added = false; 3239 int c; 3240 3241 for (c = 0; c < num_adcs; c++) { 3242 struct nid_path *path; 3243 hda_nid_t adc = spec->adc_nids[c]; 3244 3245 if (!is_reachable_path(codec, pin, adc)) 3246 continue; 3247 path = snd_hda_add_new_path(codec, pin, adc, anchor); 3248 if (!path) 3249 continue; 3250 print_nid_path(codec, "input", path); 3251 spec->input_paths[imux_idx][c] = 3252 snd_hda_get_path_idx(codec, path); 3253 3254 if (!imux_added) { 3255 if (spec->hp_mic_pin == pin) 3256 spec->hp_mic_mux_idx = imux->num_items; 3257 spec->imux_pins[imux->num_items] = pin; 3258 snd_hda_add_imux_item(codec, imux, label, cfg_idx, NULL); 3259 imux_added = true; 3260 if (spec->dyn_adc_switch) 3261 spec->dyn_adc_idx[imux_idx] = c; 3262 } 3263 } 3264 3265 return 0; 3266 } 3267 3268 /* 3269 * create playback/capture controls for input pins 3270 */ 3271 3272 /* fill the label for each input at first */ 3273 static int fill_input_pin_labels(struct hda_codec *codec) 3274 { 3275 struct hda_gen_spec *spec = codec->spec; 3276 const struct auto_pin_cfg *cfg = &spec->autocfg; 3277 int i; 3278 3279 for (i = 0; i < cfg->num_inputs; i++) { 3280 hda_nid_t pin = cfg->inputs[i].pin; 3281 const char *label; 3282 int j, idx; 3283 3284 if (!is_input_pin(codec, pin)) 3285 continue; 3286 3287 label = hda_get_autocfg_input_label(codec, cfg, i); 3288 idx = 0; 3289 for (j = i - 1; j >= 0; j--) { 3290 if (spec->input_labels[j] && 3291 !strcmp(spec->input_labels[j], label)) { 3292 idx = spec->input_label_idxs[j] + 1; 3293 break; 3294 } 3295 } 3296 3297 spec->input_labels[i] = label; 3298 spec->input_label_idxs[i] = idx; 3299 } 3300 3301 return 0; 3302 } 3303 3304 #define CFG_IDX_MIX 99 /* a dummy cfg->input idx for stereo mix */ 3305 3306 static int create_input_ctls(struct hda_codec *codec) 3307 { 3308 struct hda_gen_spec *spec = codec->spec; 3309 const struct auto_pin_cfg *cfg = &spec->autocfg; 3310 hda_nid_t mixer = spec->mixer_nid; 3311 int num_adcs; 3312 int i, err; 3313 unsigned int val; 3314 3315 num_adcs = fill_adc_nids(codec); 3316 if (num_adcs < 0) 3317 return 0; 3318 3319 err = fill_input_pin_labels(codec); 3320 if (err < 0) 3321 return err; 3322 3323 for (i = 0; i < cfg->num_inputs; i++) { 3324 hda_nid_t pin; 3325 3326 pin = cfg->inputs[i].pin; 3327 if (!is_input_pin(codec, pin)) 3328 continue; 3329 3330 val = PIN_IN; 3331 if (cfg->inputs[i].type == AUTO_PIN_MIC) 3332 val |= snd_hda_get_default_vref(codec, pin); 3333 if (pin != spec->hp_mic_pin && 3334 !snd_hda_codec_get_pin_target(codec, pin)) 3335 set_pin_target(codec, pin, val, false); 3336 3337 if (mixer) { 3338 if (is_reachable_path(codec, pin, mixer)) { 3339 err = new_analog_input(codec, i, pin, 3340 spec->input_labels[i], 3341 spec->input_label_idxs[i], 3342 mixer); 3343 if (err < 0) 3344 return err; 3345 } 3346 } 3347 3348 err = parse_capture_source(codec, pin, i, num_adcs, 3349 spec->input_labels[i], -mixer); 3350 if (err < 0) 3351 return err; 3352 3353 if (spec->add_jack_modes) { 3354 err = create_in_jack_mode(codec, pin); 3355 if (err < 0) 3356 return err; 3357 } 3358 } 3359 3360 /* add stereo mix when explicitly enabled via hint */ 3361 if (mixer && spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_ENABLE) { 3362 err = parse_capture_source(codec, mixer, CFG_IDX_MIX, num_adcs, 3363 "Stereo Mix", 0); 3364 if (err < 0) 3365 return err; 3366 else 3367 spec->suppress_auto_mic = 1; 3368 } 3369 3370 return 0; 3371 } 3372 3373 3374 /* 3375 * input source mux 3376 */ 3377 3378 /* get the input path specified by the given adc and imux indices */ 3379 static struct nid_path *get_input_path(struct hda_codec *codec, int adc_idx, int imux_idx) 3380 { 3381 struct hda_gen_spec *spec = codec->spec; 3382 if (imux_idx < 0 || imux_idx >= HDA_MAX_NUM_INPUTS) { 3383 snd_BUG(); 3384 return NULL; 3385 } 3386 if (spec->dyn_adc_switch) 3387 adc_idx = spec->dyn_adc_idx[imux_idx]; 3388 if (adc_idx < 0 || adc_idx >= AUTO_CFG_MAX_INS) { 3389 snd_BUG(); 3390 return NULL; 3391 } 3392 return snd_hda_get_path_from_idx(codec, spec->input_paths[imux_idx][adc_idx]); 3393 } 3394 3395 static int mux_select(struct hda_codec *codec, unsigned int adc_idx, 3396 unsigned int idx); 3397 3398 static int mux_enum_info(struct snd_kcontrol *kcontrol, 3399 struct snd_ctl_elem_info *uinfo) 3400 { 3401 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3402 struct hda_gen_spec *spec = codec->spec; 3403 return snd_hda_input_mux_info(&spec->input_mux, uinfo); 3404 } 3405 3406 static int mux_enum_get(struct snd_kcontrol *kcontrol, 3407 struct snd_ctl_elem_value *ucontrol) 3408 { 3409 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3410 struct hda_gen_spec *spec = codec->spec; 3411 /* the ctls are created at once with multiple counts */ 3412 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 3413 3414 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 3415 return 0; 3416 } 3417 3418 static int mux_enum_put(struct snd_kcontrol *kcontrol, 3419 struct snd_ctl_elem_value *ucontrol) 3420 { 3421 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3422 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 3423 return mux_select(codec, adc_idx, 3424 ucontrol->value.enumerated.item[0]); 3425 } 3426 3427 static const struct snd_kcontrol_new cap_src_temp = { 3428 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3429 .name = "Input Source", 3430 .info = mux_enum_info, 3431 .get = mux_enum_get, 3432 .put = mux_enum_put, 3433 }; 3434 3435 /* 3436 * capture volume and capture switch ctls 3437 */ 3438 3439 typedef int (*put_call_t)(struct snd_kcontrol *kcontrol, 3440 struct snd_ctl_elem_value *ucontrol); 3441 3442 /* call the given amp update function for all amps in the imux list at once */ 3443 static int cap_put_caller(struct snd_kcontrol *kcontrol, 3444 struct snd_ctl_elem_value *ucontrol, 3445 put_call_t func, int type) 3446 { 3447 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3448 struct hda_gen_spec *spec = codec->spec; 3449 const struct hda_input_mux *imux; 3450 struct nid_path *path; 3451 int i, adc_idx, err = 0; 3452 3453 imux = &spec->input_mux; 3454 adc_idx = kcontrol->id.index; 3455 mutex_lock(&codec->control_mutex); 3456 for (i = 0; i < imux->num_items; i++) { 3457 path = get_input_path(codec, adc_idx, i); 3458 if (!path || !path->ctls[type]) 3459 continue; 3460 kcontrol->private_value = path->ctls[type]; 3461 err = func(kcontrol, ucontrol); 3462 if (err < 0) 3463 break; 3464 } 3465 mutex_unlock(&codec->control_mutex); 3466 if (err >= 0 && spec->cap_sync_hook) 3467 spec->cap_sync_hook(codec, kcontrol, ucontrol); 3468 return err; 3469 } 3470 3471 /* capture volume ctl callbacks */ 3472 #define cap_vol_info snd_hda_mixer_amp_volume_info 3473 #define cap_vol_get snd_hda_mixer_amp_volume_get 3474 #define cap_vol_tlv snd_hda_mixer_amp_tlv 3475 3476 static int cap_vol_put(struct snd_kcontrol *kcontrol, 3477 struct snd_ctl_elem_value *ucontrol) 3478 { 3479 return cap_put_caller(kcontrol, ucontrol, 3480 snd_hda_mixer_amp_volume_put, 3481 NID_PATH_VOL_CTL); 3482 } 3483 3484 static const struct snd_kcontrol_new cap_vol_temp = { 3485 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3486 .name = "Capture Volume", 3487 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 3488 SNDRV_CTL_ELEM_ACCESS_TLV_READ | 3489 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), 3490 .info = cap_vol_info, 3491 .get = cap_vol_get, 3492 .put = cap_vol_put, 3493 .tlv = { .c = cap_vol_tlv }, 3494 }; 3495 3496 /* capture switch ctl callbacks */ 3497 #define cap_sw_info snd_ctl_boolean_stereo_info 3498 #define cap_sw_get snd_hda_mixer_amp_switch_get 3499 3500 static int cap_sw_put(struct snd_kcontrol *kcontrol, 3501 struct snd_ctl_elem_value *ucontrol) 3502 { 3503 return cap_put_caller(kcontrol, ucontrol, 3504 snd_hda_mixer_amp_switch_put, 3505 NID_PATH_MUTE_CTL); 3506 } 3507 3508 static const struct snd_kcontrol_new cap_sw_temp = { 3509 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3510 .name = "Capture Switch", 3511 .info = cap_sw_info, 3512 .get = cap_sw_get, 3513 .put = cap_sw_put, 3514 }; 3515 3516 static int parse_capvol_in_path(struct hda_codec *codec, struct nid_path *path) 3517 { 3518 hda_nid_t nid; 3519 int i, depth; 3520 3521 path->ctls[NID_PATH_VOL_CTL] = path->ctls[NID_PATH_MUTE_CTL] = 0; 3522 for (depth = 0; depth < 3; depth++) { 3523 if (depth >= path->depth) 3524 return -EINVAL; 3525 i = path->depth - depth - 1; 3526 nid = path->path[i]; 3527 if (!path->ctls[NID_PATH_VOL_CTL]) { 3528 if (nid_has_volume(codec, nid, HDA_OUTPUT)) 3529 path->ctls[NID_PATH_VOL_CTL] = 3530 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 3531 else if (nid_has_volume(codec, nid, HDA_INPUT)) { 3532 int idx = path->idx[i]; 3533 if (!depth && codec->single_adc_amp) 3534 idx = 0; 3535 path->ctls[NID_PATH_VOL_CTL] = 3536 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT); 3537 } 3538 } 3539 if (!path->ctls[NID_PATH_MUTE_CTL]) { 3540 if (nid_has_mute(codec, nid, HDA_OUTPUT)) 3541 path->ctls[NID_PATH_MUTE_CTL] = 3542 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 3543 else if (nid_has_mute(codec, nid, HDA_INPUT)) { 3544 int idx = path->idx[i]; 3545 if (!depth && codec->single_adc_amp) 3546 idx = 0; 3547 path->ctls[NID_PATH_MUTE_CTL] = 3548 HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_INPUT); 3549 } 3550 } 3551 } 3552 return 0; 3553 } 3554 3555 static bool is_inv_dmic_pin(struct hda_codec *codec, hda_nid_t nid) 3556 { 3557 struct hda_gen_spec *spec = codec->spec; 3558 struct auto_pin_cfg *cfg = &spec->autocfg; 3559 unsigned int val; 3560 int i; 3561 3562 if (!spec->inv_dmic_split) 3563 return false; 3564 for (i = 0; i < cfg->num_inputs; i++) { 3565 if (cfg->inputs[i].pin != nid) 3566 continue; 3567 if (cfg->inputs[i].type != AUTO_PIN_MIC) 3568 return false; 3569 val = snd_hda_codec_get_pincfg(codec, nid); 3570 return snd_hda_get_input_pin_attr(val) == INPUT_PIN_ATTR_INT; 3571 } 3572 return false; 3573 } 3574 3575 /* capture switch put callback for a single control with hook call */ 3576 static int cap_single_sw_put(struct snd_kcontrol *kcontrol, 3577 struct snd_ctl_elem_value *ucontrol) 3578 { 3579 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3580 struct hda_gen_spec *spec = codec->spec; 3581 int ret; 3582 3583 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 3584 if (ret < 0) 3585 return ret; 3586 3587 if (spec->cap_sync_hook) 3588 spec->cap_sync_hook(codec, kcontrol, ucontrol); 3589 3590 return ret; 3591 } 3592 3593 static int add_single_cap_ctl(struct hda_codec *codec, const char *label, 3594 int idx, bool is_switch, unsigned int ctl, 3595 bool inv_dmic) 3596 { 3597 struct hda_gen_spec *spec = codec->spec; 3598 char tmpname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 3599 int type = is_switch ? HDA_CTL_WIDGET_MUTE : HDA_CTL_WIDGET_VOL; 3600 const char *sfx = is_switch ? "Switch" : "Volume"; 3601 unsigned int chs = inv_dmic ? 1 : 3; 3602 struct snd_kcontrol_new *knew; 3603 3604 if (!ctl) 3605 return 0; 3606 3607 if (label) 3608 snprintf(tmpname, sizeof(tmpname), 3609 "%s Capture %s", label, sfx); 3610 else 3611 snprintf(tmpname, sizeof(tmpname), 3612 "Capture %s", sfx); 3613 knew = add_control(spec, type, tmpname, idx, 3614 amp_val_replace_channels(ctl, chs)); 3615 if (!knew) 3616 return -ENOMEM; 3617 if (is_switch) 3618 knew->put = cap_single_sw_put; 3619 if (!inv_dmic) 3620 return 0; 3621 3622 /* Make independent right kcontrol */ 3623 if (label) 3624 snprintf(tmpname, sizeof(tmpname), 3625 "Inverted %s Capture %s", label, sfx); 3626 else 3627 snprintf(tmpname, sizeof(tmpname), 3628 "Inverted Capture %s", sfx); 3629 knew = add_control(spec, type, tmpname, idx, 3630 amp_val_replace_channels(ctl, 2)); 3631 if (!knew) 3632 return -ENOMEM; 3633 if (is_switch) 3634 knew->put = cap_single_sw_put; 3635 return 0; 3636 } 3637 3638 /* create single (and simple) capture volume and switch controls */ 3639 static int create_single_cap_vol_ctl(struct hda_codec *codec, int idx, 3640 unsigned int vol_ctl, unsigned int sw_ctl, 3641 bool inv_dmic) 3642 { 3643 int err; 3644 err = add_single_cap_ctl(codec, NULL, idx, false, vol_ctl, inv_dmic); 3645 if (err < 0) 3646 return err; 3647 err = add_single_cap_ctl(codec, NULL, idx, true, sw_ctl, inv_dmic); 3648 if (err < 0) 3649 return err; 3650 return 0; 3651 } 3652 3653 /* create bound capture volume and switch controls */ 3654 static int create_bind_cap_vol_ctl(struct hda_codec *codec, int idx, 3655 unsigned int vol_ctl, unsigned int sw_ctl) 3656 { 3657 struct hda_gen_spec *spec = codec->spec; 3658 struct snd_kcontrol_new *knew; 3659 3660 if (vol_ctl) { 3661 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_vol_temp); 3662 if (!knew) 3663 return -ENOMEM; 3664 knew->index = idx; 3665 knew->private_value = vol_ctl; 3666 knew->subdevice = HDA_SUBDEV_AMP_FLAG; 3667 } 3668 if (sw_ctl) { 3669 knew = snd_hda_gen_add_kctl(spec, NULL, &cap_sw_temp); 3670 if (!knew) 3671 return -ENOMEM; 3672 knew->index = idx; 3673 knew->private_value = sw_ctl; 3674 knew->subdevice = HDA_SUBDEV_AMP_FLAG; 3675 } 3676 return 0; 3677 } 3678 3679 /* return the vol ctl when used first in the imux list */ 3680 static unsigned int get_first_cap_ctl(struct hda_codec *codec, int idx, int type) 3681 { 3682 struct nid_path *path; 3683 unsigned int ctl; 3684 int i; 3685 3686 path = get_input_path(codec, 0, idx); 3687 if (!path) 3688 return 0; 3689 ctl = path->ctls[type]; 3690 if (!ctl) 3691 return 0; 3692 for (i = 0; i < idx - 1; i++) { 3693 path = get_input_path(codec, 0, i); 3694 if (path && path->ctls[type] == ctl) 3695 return 0; 3696 } 3697 return ctl; 3698 } 3699 3700 /* create individual capture volume and switch controls per input */ 3701 static int create_multi_cap_vol_ctl(struct hda_codec *codec) 3702 { 3703 struct hda_gen_spec *spec = codec->spec; 3704 struct hda_input_mux *imux = &spec->input_mux; 3705 int i, err, type; 3706 3707 for (i = 0; i < imux->num_items; i++) { 3708 bool inv_dmic; 3709 int idx; 3710 3711 idx = imux->items[i].index; 3712 if (idx >= spec->autocfg.num_inputs) 3713 continue; 3714 inv_dmic = is_inv_dmic_pin(codec, spec->imux_pins[i]); 3715 3716 for (type = 0; type < 2; type++) { 3717 err = add_single_cap_ctl(codec, 3718 spec->input_labels[idx], 3719 spec->input_label_idxs[idx], 3720 type, 3721 get_first_cap_ctl(codec, i, type), 3722 inv_dmic); 3723 if (err < 0) 3724 return err; 3725 } 3726 } 3727 return 0; 3728 } 3729 3730 static int create_capture_mixers(struct hda_codec *codec) 3731 { 3732 struct hda_gen_spec *spec = codec->spec; 3733 struct hda_input_mux *imux = &spec->input_mux; 3734 int i, n, nums, err; 3735 3736 if (spec->dyn_adc_switch) 3737 nums = 1; 3738 else 3739 nums = spec->num_adc_nids; 3740 3741 if (!spec->auto_mic && imux->num_items > 1) { 3742 struct snd_kcontrol_new *knew; 3743 const char *name; 3744 name = nums > 1 ? "Input Source" : "Capture Source"; 3745 knew = snd_hda_gen_add_kctl(spec, name, &cap_src_temp); 3746 if (!knew) 3747 return -ENOMEM; 3748 knew->count = nums; 3749 } 3750 3751 for (n = 0; n < nums; n++) { 3752 bool multi = false; 3753 bool multi_cap_vol = spec->multi_cap_vol; 3754 bool inv_dmic = false; 3755 int vol, sw; 3756 3757 vol = sw = 0; 3758 for (i = 0; i < imux->num_items; i++) { 3759 struct nid_path *path; 3760 path = get_input_path(codec, n, i); 3761 if (!path) 3762 continue; 3763 parse_capvol_in_path(codec, path); 3764 if (!vol) 3765 vol = path->ctls[NID_PATH_VOL_CTL]; 3766 else if (vol != path->ctls[NID_PATH_VOL_CTL]) { 3767 multi = true; 3768 if (!same_amp_caps(codec, vol, 3769 path->ctls[NID_PATH_VOL_CTL], HDA_INPUT)) 3770 multi_cap_vol = true; 3771 } 3772 if (!sw) 3773 sw = path->ctls[NID_PATH_MUTE_CTL]; 3774 else if (sw != path->ctls[NID_PATH_MUTE_CTL]) { 3775 multi = true; 3776 if (!same_amp_caps(codec, sw, 3777 path->ctls[NID_PATH_MUTE_CTL], HDA_INPUT)) 3778 multi_cap_vol = true; 3779 } 3780 if (is_inv_dmic_pin(codec, spec->imux_pins[i])) 3781 inv_dmic = true; 3782 } 3783 3784 if (!multi) 3785 err = create_single_cap_vol_ctl(codec, n, vol, sw, 3786 inv_dmic); 3787 else if (!multi_cap_vol && !inv_dmic) 3788 err = create_bind_cap_vol_ctl(codec, n, vol, sw); 3789 else 3790 err = create_multi_cap_vol_ctl(codec); 3791 if (err < 0) 3792 return err; 3793 } 3794 3795 return 0; 3796 } 3797 3798 /* 3799 * add mic boosts if needed 3800 */ 3801 3802 /* check whether the given amp is feasible as a boost volume */ 3803 static bool check_boost_vol(struct hda_codec *codec, hda_nid_t nid, 3804 int dir, int idx) 3805 { 3806 unsigned int step; 3807 3808 if (!nid_has_volume(codec, nid, dir) || 3809 is_ctl_associated(codec, nid, dir, idx, NID_PATH_VOL_CTL) || 3810 is_ctl_associated(codec, nid, dir, idx, NID_PATH_BOOST_CTL)) 3811 return false; 3812 3813 step = (query_amp_caps(codec, nid, dir) & AC_AMPCAP_STEP_SIZE) 3814 >> AC_AMPCAP_STEP_SIZE_SHIFT; 3815 if (step < 0x20) 3816 return false; 3817 return true; 3818 } 3819 3820 /* look for a boost amp in a widget close to the pin */ 3821 static unsigned int look_for_boost_amp(struct hda_codec *codec, 3822 struct nid_path *path) 3823 { 3824 unsigned int val = 0; 3825 hda_nid_t nid; 3826 int depth; 3827 3828 for (depth = 0; depth < 3; depth++) { 3829 if (depth >= path->depth - 1) 3830 break; 3831 nid = path->path[depth]; 3832 if (depth && check_boost_vol(codec, nid, HDA_OUTPUT, 0)) { 3833 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 3834 break; 3835 } else if (check_boost_vol(codec, nid, HDA_INPUT, 3836 path->idx[depth])) { 3837 val = HDA_COMPOSE_AMP_VAL(nid, 3, path->idx[depth], 3838 HDA_INPUT); 3839 break; 3840 } 3841 } 3842 3843 return val; 3844 } 3845 3846 static int parse_mic_boost(struct hda_codec *codec) 3847 { 3848 struct hda_gen_spec *spec = codec->spec; 3849 struct auto_pin_cfg *cfg = &spec->autocfg; 3850 struct hda_input_mux *imux = &spec->input_mux; 3851 int i; 3852 3853 if (!spec->num_adc_nids) 3854 return 0; 3855 3856 for (i = 0; i < imux->num_items; i++) { 3857 struct nid_path *path; 3858 unsigned int val; 3859 int idx; 3860 char boost_label[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 3861 3862 idx = imux->items[i].index; 3863 if (idx >= imux->num_items) 3864 continue; 3865 3866 /* check only line-in and mic pins */ 3867 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN) 3868 continue; 3869 3870 path = get_input_path(codec, 0, i); 3871 if (!path) 3872 continue; 3873 3874 val = look_for_boost_amp(codec, path); 3875 if (!val) 3876 continue; 3877 3878 /* create a boost control */ 3879 snprintf(boost_label, sizeof(boost_label), 3880 "%s Boost Volume", spec->input_labels[idx]); 3881 if (!add_control(spec, HDA_CTL_WIDGET_VOL, boost_label, 3882 spec->input_label_idxs[idx], val)) 3883 return -ENOMEM; 3884 3885 path->ctls[NID_PATH_BOOST_CTL] = val; 3886 } 3887 return 0; 3888 } 3889 3890 #ifdef CONFIG_SND_HDA_GENERIC_LEDS 3891 /* 3892 * mic mute LED hook helpers 3893 */ 3894 enum { 3895 MICMUTE_LED_ON, 3896 MICMUTE_LED_OFF, 3897 MICMUTE_LED_FOLLOW_CAPTURE, 3898 MICMUTE_LED_FOLLOW_MUTE, 3899 }; 3900 3901 static void call_micmute_led_update(struct hda_codec *codec) 3902 { 3903 struct hda_gen_spec *spec = codec->spec; 3904 unsigned int val; 3905 3906 switch (spec->micmute_led.led_mode) { 3907 case MICMUTE_LED_ON: 3908 val = 1; 3909 break; 3910 case MICMUTE_LED_OFF: 3911 val = 0; 3912 break; 3913 case MICMUTE_LED_FOLLOW_CAPTURE: 3914 val = !!spec->micmute_led.capture; 3915 break; 3916 case MICMUTE_LED_FOLLOW_MUTE: 3917 default: 3918 val = !spec->micmute_led.capture; 3919 break; 3920 } 3921 3922 if (val == spec->micmute_led.led_value) 3923 return; 3924 spec->micmute_led.led_value = val; 3925 if (spec->micmute_led.update) 3926 spec->micmute_led.update(codec); 3927 ledtrig_audio_set(LED_AUDIO_MICMUTE, 3928 spec->micmute_led.led_value ? LED_ON : LED_OFF); 3929 } 3930 3931 static void update_micmute_led(struct hda_codec *codec, 3932 struct snd_kcontrol *kcontrol, 3933 struct snd_ctl_elem_value *ucontrol) 3934 { 3935 struct hda_gen_spec *spec = codec->spec; 3936 unsigned int mask; 3937 3938 if (spec->micmute_led.old_hook) 3939 spec->micmute_led.old_hook(codec, kcontrol, ucontrol); 3940 3941 if (!ucontrol) 3942 return; 3943 mask = 1U << snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 3944 if (!strcmp("Capture Switch", ucontrol->id.name)) { 3945 /* TODO: How do I verify if it's a mono or stereo here? */ 3946 if (ucontrol->value.integer.value[0] || 3947 ucontrol->value.integer.value[1]) 3948 spec->micmute_led.capture |= mask; 3949 else 3950 spec->micmute_led.capture &= ~mask; 3951 call_micmute_led_update(codec); 3952 } 3953 } 3954 3955 static int micmute_led_mode_info(struct snd_kcontrol *kcontrol, 3956 struct snd_ctl_elem_info *uinfo) 3957 { 3958 static const char * const texts[] = { 3959 "On", "Off", "Follow Capture", "Follow Mute", 3960 }; 3961 3962 return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); 3963 } 3964 3965 static int micmute_led_mode_get(struct snd_kcontrol *kcontrol, 3966 struct snd_ctl_elem_value *ucontrol) 3967 { 3968 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3969 struct hda_gen_spec *spec = codec->spec; 3970 3971 ucontrol->value.enumerated.item[0] = spec->micmute_led.led_mode; 3972 return 0; 3973 } 3974 3975 static int micmute_led_mode_put(struct snd_kcontrol *kcontrol, 3976 struct snd_ctl_elem_value *ucontrol) 3977 { 3978 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3979 struct hda_gen_spec *spec = codec->spec; 3980 unsigned int mode; 3981 3982 mode = ucontrol->value.enumerated.item[0]; 3983 if (mode > MICMUTE_LED_FOLLOW_MUTE) 3984 mode = MICMUTE_LED_FOLLOW_MUTE; 3985 if (mode == spec->micmute_led.led_mode) 3986 return 0; 3987 spec->micmute_led.led_mode = mode; 3988 call_micmute_led_update(codec); 3989 return 1; 3990 } 3991 3992 static const struct snd_kcontrol_new micmute_led_mode_ctl = { 3993 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3994 .name = "Mic Mute-LED Mode", 3995 .info = micmute_led_mode_info, 3996 .get = micmute_led_mode_get, 3997 .put = micmute_led_mode_put, 3998 }; 3999 4000 /** 4001 * snd_hda_gen_add_micmute_led - helper for setting up mic mute LED hook 4002 * @codec: the HDA codec 4003 * @hook: the callback for updating LED 4004 * 4005 * Called from the codec drivers for offering the mic mute LED controls. 4006 * When established, it sets up cap_sync_hook and triggers the callback at 4007 * each time when the capture mixer switch changes. The callback is supposed 4008 * to update the LED accordingly. 4009 * 4010 * Returns 0 if the hook is established or a negative error code. 4011 */ 4012 int snd_hda_gen_add_micmute_led(struct hda_codec *codec, 4013 void (*hook)(struct hda_codec *)) 4014 { 4015 struct hda_gen_spec *spec = codec->spec; 4016 4017 spec->micmute_led.led_mode = MICMUTE_LED_FOLLOW_MUTE; 4018 spec->micmute_led.capture = 0; 4019 spec->micmute_led.led_value = 0; 4020 spec->micmute_led.old_hook = spec->cap_sync_hook; 4021 spec->micmute_led.update = hook; 4022 spec->cap_sync_hook = update_micmute_led; 4023 if (!snd_hda_gen_add_kctl(spec, NULL, &micmute_led_mode_ctl)) 4024 return -ENOMEM; 4025 return 0; 4026 } 4027 EXPORT_SYMBOL_GPL(snd_hda_gen_add_micmute_led); 4028 4029 /** 4030 * snd_hda_gen_fixup_micmute_led - A fixup for mic-mute LED trigger 4031 * 4032 * Pass this function to the quirk entry if another driver supports the 4033 * audio mic-mute LED trigger. Then this will bind the mixer capture switch 4034 * change with the LED. 4035 * 4036 * Note that this fixup has to be called after other fixup that sets 4037 * cap_sync_hook. Otherwise the chaining wouldn't work. 4038 * 4039 * @codec: the HDA codec 4040 * @fix: fixup pointer 4041 * @action: only supports HDA_FIXUP_ACT_PROBE value 4042 * 4043 */ 4044 void snd_hda_gen_fixup_micmute_led(struct hda_codec *codec, 4045 const struct hda_fixup *fix, int action) 4046 { 4047 if (action == HDA_FIXUP_ACT_PROBE) 4048 snd_hda_gen_add_micmute_led(codec, NULL); 4049 } 4050 EXPORT_SYMBOL_GPL(snd_hda_gen_fixup_micmute_led); 4051 4052 /** 4053 * snd_dha_gen_add_micmute_led_cdev - Create a LED classdev and enable as mic-mute LED 4054 * @codec: the HDA codec 4055 * @callback: the callback for LED classdev brightness_set_blocking 4056 * 4057 * Called from the codec drivers for offering the mic mute LED controls. 4058 * This creates a LED classdev and sets up the cap_sync_hook that is called at 4059 * each time when the capture mixer switch changes. 4060 * 4061 * When NULL is passed to @callback, no classdev is created but only the 4062 * LED-trigger is set up. 4063 * 4064 * Returns 0 or a negative error. 4065 */ 4066 int snd_hda_gen_add_micmute_led_cdev(struct hda_codec *codec, 4067 int (*callback)(struct led_classdev *, 4068 enum led_brightness)) 4069 { 4070 int err; 4071 struct led_classdev *cdev; 4072 4073 if (callback) { 4074 cdev = devm_kzalloc(&codec->core.dev, sizeof(*cdev), GFP_KERNEL); 4075 if (!cdev) 4076 return -ENOMEM; 4077 4078 cdev->name = "hda::micmute"; 4079 cdev->max_brightness = 1; 4080 cdev->default_trigger = "audio-micmute"; 4081 cdev->brightness_set_blocking = callback; 4082 cdev->brightness = ledtrig_audio_get(LED_AUDIO_MICMUTE); 4083 4084 err = devm_led_classdev_register(&codec->core.dev, cdev); 4085 if (err) { 4086 codec_warn(codec, "failed to create a mic-mute LED cdev\n"); 4087 return err; 4088 } 4089 } 4090 4091 return snd_hda_gen_add_micmute_led(codec, NULL); 4092 } 4093 EXPORT_SYMBOL_GPL(snd_hda_gen_add_micmute_led_cdev); 4094 #endif /* CONFIG_SND_HDA_GENERIC_LEDS */ 4095 4096 /* 4097 * parse digital I/Os and set up NIDs in BIOS auto-parse mode 4098 */ 4099 static void parse_digital(struct hda_codec *codec) 4100 { 4101 struct hda_gen_spec *spec = codec->spec; 4102 struct nid_path *path; 4103 int i, nums; 4104 hda_nid_t dig_nid, pin; 4105 4106 /* support multiple SPDIFs; the secondary is set up as a slave */ 4107 nums = 0; 4108 for (i = 0; i < spec->autocfg.dig_outs; i++) { 4109 pin = spec->autocfg.dig_out_pins[i]; 4110 dig_nid = look_for_dac(codec, pin, true); 4111 if (!dig_nid) 4112 continue; 4113 path = snd_hda_add_new_path(codec, dig_nid, pin, 0); 4114 if (!path) 4115 continue; 4116 print_nid_path(codec, "digout", path); 4117 path->active = true; 4118 path->pin_fixed = true; /* no jack detection */ 4119 spec->digout_paths[i] = snd_hda_get_path_idx(codec, path); 4120 set_pin_target(codec, pin, PIN_OUT, false); 4121 if (!nums) { 4122 spec->multiout.dig_out_nid = dig_nid; 4123 spec->dig_out_type = spec->autocfg.dig_out_type[0]; 4124 } else { 4125 spec->multiout.slave_dig_outs = spec->slave_dig_outs; 4126 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1) 4127 break; 4128 spec->slave_dig_outs[nums - 1] = dig_nid; 4129 } 4130 nums++; 4131 } 4132 4133 if (spec->autocfg.dig_in_pin) { 4134 pin = spec->autocfg.dig_in_pin; 4135 for_each_hda_codec_node(dig_nid, codec) { 4136 unsigned int wcaps = get_wcaps(codec, dig_nid); 4137 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) 4138 continue; 4139 if (!(wcaps & AC_WCAP_DIGITAL)) 4140 continue; 4141 path = snd_hda_add_new_path(codec, pin, dig_nid, 0); 4142 if (path) { 4143 print_nid_path(codec, "digin", path); 4144 path->active = true; 4145 path->pin_fixed = true; /* no jack */ 4146 spec->dig_in_nid = dig_nid; 4147 spec->digin_path = snd_hda_get_path_idx(codec, path); 4148 set_pin_target(codec, pin, PIN_IN, false); 4149 break; 4150 } 4151 } 4152 } 4153 } 4154 4155 4156 /* 4157 * input MUX handling 4158 */ 4159 4160 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur); 4161 4162 /* select the given imux item; either unmute exclusively or select the route */ 4163 static int mux_select(struct hda_codec *codec, unsigned int adc_idx, 4164 unsigned int idx) 4165 { 4166 struct hda_gen_spec *spec = codec->spec; 4167 const struct hda_input_mux *imux; 4168 struct nid_path *old_path, *path; 4169 4170 imux = &spec->input_mux; 4171 if (!imux->num_items) 4172 return 0; 4173 4174 if (idx >= imux->num_items) 4175 idx = imux->num_items - 1; 4176 if (spec->cur_mux[adc_idx] == idx) 4177 return 0; 4178 4179 old_path = get_input_path(codec, adc_idx, spec->cur_mux[adc_idx]); 4180 if (!old_path) 4181 return 0; 4182 if (old_path->active) 4183 snd_hda_activate_path(codec, old_path, false, false); 4184 4185 spec->cur_mux[adc_idx] = idx; 4186 4187 if (spec->hp_mic) 4188 update_hp_mic(codec, adc_idx, false); 4189 4190 if (spec->dyn_adc_switch) 4191 dyn_adc_pcm_resetup(codec, idx); 4192 4193 path = get_input_path(codec, adc_idx, idx); 4194 if (!path) 4195 return 0; 4196 if (path->active) 4197 return 0; 4198 snd_hda_activate_path(codec, path, true, false); 4199 if (spec->cap_sync_hook) 4200 spec->cap_sync_hook(codec, NULL, NULL); 4201 path_power_down_sync(codec, old_path); 4202 return 1; 4203 } 4204 4205 /* power up/down widgets in the all paths that match with the given NID 4206 * as terminals (either start- or endpoint) 4207 * 4208 * returns the last changed NID, or zero if unchanged. 4209 */ 4210 static hda_nid_t set_path_power(struct hda_codec *codec, hda_nid_t nid, 4211 int pin_state, int stream_state) 4212 { 4213 struct hda_gen_spec *spec = codec->spec; 4214 hda_nid_t last, changed = 0; 4215 struct nid_path *path; 4216 int n; 4217 4218 snd_array_for_each(&spec->paths, n, path) { 4219 if (!path->depth) 4220 continue; 4221 if (path->path[0] == nid || 4222 path->path[path->depth - 1] == nid) { 4223 bool pin_old = path->pin_enabled; 4224 bool stream_old = path->stream_enabled; 4225 4226 if (pin_state >= 0) 4227 path->pin_enabled = pin_state; 4228 if (stream_state >= 0) 4229 path->stream_enabled = stream_state; 4230 if ((!path->pin_fixed && path->pin_enabled != pin_old) 4231 || path->stream_enabled != stream_old) { 4232 last = path_power_update(codec, path, true); 4233 if (last) 4234 changed = last; 4235 } 4236 } 4237 } 4238 return changed; 4239 } 4240 4241 /* check the jack status for power control */ 4242 static bool detect_pin_state(struct hda_codec *codec, hda_nid_t pin) 4243 { 4244 if (!is_jack_detectable(codec, pin)) 4245 return true; 4246 return snd_hda_jack_detect_state(codec, pin) != HDA_JACK_NOT_PRESENT; 4247 } 4248 4249 /* power up/down the paths of the given pin according to the jack state; 4250 * power = 0/1 : only power up/down if it matches with the jack state, 4251 * < 0 : force power up/down to follow the jack sate 4252 * 4253 * returns the last changed NID, or zero if unchanged. 4254 */ 4255 static hda_nid_t set_pin_power_jack(struct hda_codec *codec, hda_nid_t pin, 4256 int power) 4257 { 4258 bool on; 4259 4260 if (!codec->power_save_node) 4261 return 0; 4262 4263 on = detect_pin_state(codec, pin); 4264 4265 if (power >= 0 && on != power) 4266 return 0; 4267 return set_path_power(codec, pin, on, -1); 4268 } 4269 4270 static void pin_power_callback(struct hda_codec *codec, 4271 struct hda_jack_callback *jack, 4272 bool on) 4273 { 4274 if (jack && jack->nid) 4275 sync_power_state_change(codec, 4276 set_pin_power_jack(codec, jack->nid, on)); 4277 } 4278 4279 /* callback only doing power up -- called at first */ 4280 static void pin_power_up_callback(struct hda_codec *codec, 4281 struct hda_jack_callback *jack) 4282 { 4283 pin_power_callback(codec, jack, true); 4284 } 4285 4286 /* callback only doing power down -- called at last */ 4287 static void pin_power_down_callback(struct hda_codec *codec, 4288 struct hda_jack_callback *jack) 4289 { 4290 pin_power_callback(codec, jack, false); 4291 } 4292 4293 /* set up the power up/down callbacks */ 4294 static void add_pin_power_ctls(struct hda_codec *codec, int num_pins, 4295 const hda_nid_t *pins, bool on) 4296 { 4297 int i; 4298 hda_jack_callback_fn cb = 4299 on ? pin_power_up_callback : pin_power_down_callback; 4300 4301 for (i = 0; i < num_pins && pins[i]; i++) { 4302 if (is_jack_detectable(codec, pins[i])) 4303 snd_hda_jack_detect_enable_callback(codec, pins[i], cb); 4304 else 4305 set_path_power(codec, pins[i], true, -1); 4306 } 4307 } 4308 4309 /* enabled power callback to each available I/O pin with jack detections; 4310 * the digital I/O pins are excluded because of the unreliable detectsion 4311 */ 4312 static void add_all_pin_power_ctls(struct hda_codec *codec, bool on) 4313 { 4314 struct hda_gen_spec *spec = codec->spec; 4315 struct auto_pin_cfg *cfg = &spec->autocfg; 4316 int i; 4317 4318 if (!codec->power_save_node) 4319 return; 4320 add_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins, on); 4321 if (cfg->line_out_type != AUTO_PIN_HP_OUT) 4322 add_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins, on); 4323 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) 4324 add_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, on); 4325 for (i = 0; i < cfg->num_inputs; i++) 4326 add_pin_power_ctls(codec, 1, &cfg->inputs[i].pin, on); 4327 } 4328 4329 /* sync path power up/down with the jack states of given pins */ 4330 static void sync_pin_power_ctls(struct hda_codec *codec, int num_pins, 4331 const hda_nid_t *pins) 4332 { 4333 int i; 4334 4335 for (i = 0; i < num_pins && pins[i]; i++) 4336 if (is_jack_detectable(codec, pins[i])) 4337 set_pin_power_jack(codec, pins[i], -1); 4338 } 4339 4340 /* sync path power up/down with pins; called at init and resume */ 4341 static void sync_all_pin_power_ctls(struct hda_codec *codec) 4342 { 4343 struct hda_gen_spec *spec = codec->spec; 4344 struct auto_pin_cfg *cfg = &spec->autocfg; 4345 int i; 4346 4347 if (!codec->power_save_node) 4348 return; 4349 sync_pin_power_ctls(codec, cfg->line_outs, cfg->line_out_pins); 4350 if (cfg->line_out_type != AUTO_PIN_HP_OUT) 4351 sync_pin_power_ctls(codec, cfg->hp_outs, cfg->hp_pins); 4352 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) 4353 sync_pin_power_ctls(codec, cfg->speaker_outs, cfg->speaker_pins); 4354 for (i = 0; i < cfg->num_inputs; i++) 4355 sync_pin_power_ctls(codec, 1, &cfg->inputs[i].pin); 4356 } 4357 4358 /* add fake paths if not present yet */ 4359 static int add_fake_paths(struct hda_codec *codec, hda_nid_t nid, 4360 int num_pins, const hda_nid_t *pins) 4361 { 4362 struct hda_gen_spec *spec = codec->spec; 4363 struct nid_path *path; 4364 int i; 4365 4366 for (i = 0; i < num_pins; i++) { 4367 if (!pins[i]) 4368 break; 4369 if (get_nid_path(codec, nid, pins[i], 0)) 4370 continue; 4371 path = snd_array_new(&spec->paths); 4372 if (!path) 4373 return -ENOMEM; 4374 memset(path, 0, sizeof(*path)); 4375 path->depth = 2; 4376 path->path[0] = nid; 4377 path->path[1] = pins[i]; 4378 path->active = true; 4379 } 4380 return 0; 4381 } 4382 4383 /* create fake paths to all outputs from beep */ 4384 static int add_fake_beep_paths(struct hda_codec *codec) 4385 { 4386 struct hda_gen_spec *spec = codec->spec; 4387 struct auto_pin_cfg *cfg = &spec->autocfg; 4388 hda_nid_t nid = spec->beep_nid; 4389 int err; 4390 4391 if (!codec->power_save_node || !nid) 4392 return 0; 4393 err = add_fake_paths(codec, nid, cfg->line_outs, cfg->line_out_pins); 4394 if (err < 0) 4395 return err; 4396 if (cfg->line_out_type != AUTO_PIN_HP_OUT) { 4397 err = add_fake_paths(codec, nid, cfg->hp_outs, cfg->hp_pins); 4398 if (err < 0) 4399 return err; 4400 } 4401 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 4402 err = add_fake_paths(codec, nid, cfg->speaker_outs, 4403 cfg->speaker_pins); 4404 if (err < 0) 4405 return err; 4406 } 4407 return 0; 4408 } 4409 4410 /* power up/down beep widget and its output paths */ 4411 static void beep_power_hook(struct hda_beep *beep, bool on) 4412 { 4413 set_path_power(beep->codec, beep->nid, -1, on); 4414 } 4415 4416 /** 4417 * snd_hda_gen_fix_pin_power - Fix the power of the given pin widget to D0 4418 * @codec: the HDA codec 4419 * @pin: NID of pin to fix 4420 */ 4421 int snd_hda_gen_fix_pin_power(struct hda_codec *codec, hda_nid_t pin) 4422 { 4423 struct hda_gen_spec *spec = codec->spec; 4424 struct nid_path *path; 4425 4426 path = snd_array_new(&spec->paths); 4427 if (!path) 4428 return -ENOMEM; 4429 memset(path, 0, sizeof(*path)); 4430 path->depth = 1; 4431 path->path[0] = pin; 4432 path->active = true; 4433 path->pin_fixed = true; 4434 path->stream_enabled = true; 4435 return 0; 4436 } 4437 EXPORT_SYMBOL_GPL(snd_hda_gen_fix_pin_power); 4438 4439 /* 4440 * Jack detections for HP auto-mute and mic-switch 4441 */ 4442 4443 /* check each pin in the given array; returns true if any of them is plugged */ 4444 static bool detect_jacks(struct hda_codec *codec, int num_pins, const hda_nid_t *pins) 4445 { 4446 int i; 4447 bool present = false; 4448 4449 for (i = 0; i < num_pins; i++) { 4450 hda_nid_t nid = pins[i]; 4451 if (!nid) 4452 break; 4453 /* don't detect pins retasked as inputs */ 4454 if (snd_hda_codec_get_pin_target(codec, nid) & AC_PINCTL_IN_EN) 4455 continue; 4456 if (snd_hda_jack_detect_state(codec, nid) == HDA_JACK_PRESENT) 4457 present = true; 4458 } 4459 return present; 4460 } 4461 4462 /* standard HP/line-out auto-mute helper */ 4463 static void do_automute(struct hda_codec *codec, int num_pins, const hda_nid_t *pins, 4464 int *paths, bool mute) 4465 { 4466 struct hda_gen_spec *spec = codec->spec; 4467 int i; 4468 4469 for (i = 0; i < num_pins; i++) { 4470 hda_nid_t nid = pins[i]; 4471 unsigned int val, oldval; 4472 if (!nid) 4473 break; 4474 4475 oldval = snd_hda_codec_get_pin_target(codec, nid); 4476 if (oldval & PIN_IN) 4477 continue; /* no mute for inputs */ 4478 4479 if (spec->auto_mute_via_amp) { 4480 struct nid_path *path; 4481 hda_nid_t mute_nid; 4482 4483 path = snd_hda_get_path_from_idx(codec, paths[i]); 4484 if (!path) 4485 continue; 4486 mute_nid = get_amp_nid_(path->ctls[NID_PATH_MUTE_CTL]); 4487 if (!mute_nid) 4488 continue; 4489 if (mute) 4490 spec->mute_bits |= (1ULL << mute_nid); 4491 else 4492 spec->mute_bits &= ~(1ULL << mute_nid); 4493 continue; 4494 } else { 4495 /* don't reset VREF value in case it's controlling 4496 * the amp (see alc861_fixup_asus_amp_vref_0f()) 4497 */ 4498 if (spec->keep_vref_in_automute) 4499 val = oldval & ~PIN_HP; 4500 else 4501 val = 0; 4502 if (!mute) 4503 val |= oldval; 4504 /* here we call update_pin_ctl() so that the pinctl is 4505 * changed without changing the pinctl target value; 4506 * the original target value will be still referred at 4507 * the init / resume again 4508 */ 4509 update_pin_ctl(codec, nid, val); 4510 } 4511 4512 set_pin_eapd(codec, nid, !mute); 4513 if (codec->power_save_node) { 4514 bool on = !mute; 4515 if (on) 4516 on = detect_pin_state(codec, nid); 4517 set_path_power(codec, nid, on, -1); 4518 } 4519 } 4520 } 4521 4522 /** 4523 * snd_hda_gen_update_outputs - Toggle outputs muting 4524 * @codec: the HDA codec 4525 * 4526 * Update the mute status of all outputs based on the current jack states. 4527 */ 4528 void snd_hda_gen_update_outputs(struct hda_codec *codec) 4529 { 4530 struct hda_gen_spec *spec = codec->spec; 4531 int *paths; 4532 int on; 4533 4534 /* Control HP pins/amps depending on master_mute state; 4535 * in general, HP pins/amps control should be enabled in all cases, 4536 * but currently set only for master_mute, just to be safe 4537 */ 4538 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT) 4539 paths = spec->out_paths; 4540 else 4541 paths = spec->hp_paths; 4542 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins), 4543 spec->autocfg.hp_pins, paths, spec->master_mute); 4544 4545 if (!spec->automute_speaker) 4546 on = 0; 4547 else 4548 on = spec->hp_jack_present | spec->line_jack_present; 4549 on |= spec->master_mute; 4550 spec->speaker_muted = on; 4551 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) 4552 paths = spec->out_paths; 4553 else 4554 paths = spec->speaker_paths; 4555 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins), 4556 spec->autocfg.speaker_pins, paths, on); 4557 4558 /* toggle line-out mutes if needed, too */ 4559 /* if LO is a copy of either HP or Speaker, don't need to handle it */ 4560 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] || 4561 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0]) 4562 return; 4563 if (!spec->automute_lo) 4564 on = 0; 4565 else 4566 on = spec->hp_jack_present; 4567 on |= spec->master_mute; 4568 spec->line_out_muted = on; 4569 paths = spec->out_paths; 4570 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins), 4571 spec->autocfg.line_out_pins, paths, on); 4572 } 4573 EXPORT_SYMBOL_GPL(snd_hda_gen_update_outputs); 4574 4575 static void call_update_outputs(struct hda_codec *codec) 4576 { 4577 struct hda_gen_spec *spec = codec->spec; 4578 if (spec->automute_hook) 4579 spec->automute_hook(codec); 4580 else 4581 snd_hda_gen_update_outputs(codec); 4582 4583 /* sync the whole vmaster slaves to reflect the new auto-mute status */ 4584 if (spec->auto_mute_via_amp && !codec->bus->shutdown) 4585 snd_ctl_sync_vmaster(spec->vmaster_mute.sw_kctl, false); 4586 } 4587 4588 /** 4589 * snd_hda_gen_hp_automute - standard HP-automute helper 4590 * @codec: the HDA codec 4591 * @jack: jack object, NULL for the whole 4592 */ 4593 void snd_hda_gen_hp_automute(struct hda_codec *codec, 4594 struct hda_jack_callback *jack) 4595 { 4596 struct hda_gen_spec *spec = codec->spec; 4597 hda_nid_t *pins = spec->autocfg.hp_pins; 4598 int num_pins = ARRAY_SIZE(spec->autocfg.hp_pins); 4599 4600 /* No detection for the first HP jack during indep-HP mode */ 4601 if (spec->indep_hp_enabled) { 4602 pins++; 4603 num_pins--; 4604 } 4605 4606 spec->hp_jack_present = detect_jacks(codec, num_pins, pins); 4607 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo)) 4608 return; 4609 call_update_outputs(codec); 4610 } 4611 EXPORT_SYMBOL_GPL(snd_hda_gen_hp_automute); 4612 4613 /** 4614 * snd_hda_gen_line_automute - standard line-out-automute helper 4615 * @codec: the HDA codec 4616 * @jack: jack object, NULL for the whole 4617 */ 4618 void snd_hda_gen_line_automute(struct hda_codec *codec, 4619 struct hda_jack_callback *jack) 4620 { 4621 struct hda_gen_spec *spec = codec->spec; 4622 4623 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) 4624 return; 4625 /* check LO jack only when it's different from HP */ 4626 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0]) 4627 return; 4628 4629 spec->line_jack_present = 4630 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins), 4631 spec->autocfg.line_out_pins); 4632 if (!spec->automute_speaker || !spec->detect_lo) 4633 return; 4634 call_update_outputs(codec); 4635 } 4636 EXPORT_SYMBOL_GPL(snd_hda_gen_line_automute); 4637 4638 /** 4639 * snd_hda_gen_mic_autoswitch - standard mic auto-switch helper 4640 * @codec: the HDA codec 4641 * @jack: jack object, NULL for the whole 4642 */ 4643 void snd_hda_gen_mic_autoswitch(struct hda_codec *codec, 4644 struct hda_jack_callback *jack) 4645 { 4646 struct hda_gen_spec *spec = codec->spec; 4647 int i; 4648 4649 if (!spec->auto_mic) 4650 return; 4651 4652 for (i = spec->am_num_entries - 1; i > 0; i--) { 4653 hda_nid_t pin = spec->am_entry[i].pin; 4654 /* don't detect pins retasked as outputs */ 4655 if (snd_hda_codec_get_pin_target(codec, pin) & AC_PINCTL_OUT_EN) 4656 continue; 4657 if (snd_hda_jack_detect_state(codec, pin) == HDA_JACK_PRESENT) { 4658 mux_select(codec, 0, spec->am_entry[i].idx); 4659 return; 4660 } 4661 } 4662 mux_select(codec, 0, spec->am_entry[0].idx); 4663 } 4664 EXPORT_SYMBOL_GPL(snd_hda_gen_mic_autoswitch); 4665 4666 /* call appropriate hooks */ 4667 static void call_hp_automute(struct hda_codec *codec, 4668 struct hda_jack_callback *jack) 4669 { 4670 struct hda_gen_spec *spec = codec->spec; 4671 if (spec->hp_automute_hook) 4672 spec->hp_automute_hook(codec, jack); 4673 else 4674 snd_hda_gen_hp_automute(codec, jack); 4675 } 4676 4677 static void call_line_automute(struct hda_codec *codec, 4678 struct hda_jack_callback *jack) 4679 { 4680 struct hda_gen_spec *spec = codec->spec; 4681 if (spec->line_automute_hook) 4682 spec->line_automute_hook(codec, jack); 4683 else 4684 snd_hda_gen_line_automute(codec, jack); 4685 } 4686 4687 static void call_mic_autoswitch(struct hda_codec *codec, 4688 struct hda_jack_callback *jack) 4689 { 4690 struct hda_gen_spec *spec = codec->spec; 4691 if (spec->mic_autoswitch_hook) 4692 spec->mic_autoswitch_hook(codec, jack); 4693 else 4694 snd_hda_gen_mic_autoswitch(codec, jack); 4695 } 4696 4697 /* update jack retasking */ 4698 static void update_automute_all(struct hda_codec *codec) 4699 { 4700 call_hp_automute(codec, NULL); 4701 call_line_automute(codec, NULL); 4702 call_mic_autoswitch(codec, NULL); 4703 } 4704 4705 /* 4706 * Auto-Mute mode mixer enum support 4707 */ 4708 static int automute_mode_info(struct snd_kcontrol *kcontrol, 4709 struct snd_ctl_elem_info *uinfo) 4710 { 4711 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4712 struct hda_gen_spec *spec = codec->spec; 4713 static const char * const texts3[] = { 4714 "Disabled", "Speaker Only", "Line Out+Speaker" 4715 }; 4716 4717 if (spec->automute_speaker_possible && spec->automute_lo_possible) 4718 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3); 4719 return snd_hda_enum_bool_helper_info(kcontrol, uinfo); 4720 } 4721 4722 static int automute_mode_get(struct snd_kcontrol *kcontrol, 4723 struct snd_ctl_elem_value *ucontrol) 4724 { 4725 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4726 struct hda_gen_spec *spec = codec->spec; 4727 unsigned int val = 0; 4728 if (spec->automute_speaker) 4729 val++; 4730 if (spec->automute_lo) 4731 val++; 4732 4733 ucontrol->value.enumerated.item[0] = val; 4734 return 0; 4735 } 4736 4737 static int automute_mode_put(struct snd_kcontrol *kcontrol, 4738 struct snd_ctl_elem_value *ucontrol) 4739 { 4740 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 4741 struct hda_gen_spec *spec = codec->spec; 4742 4743 switch (ucontrol->value.enumerated.item[0]) { 4744 case 0: 4745 if (!spec->automute_speaker && !spec->automute_lo) 4746 return 0; 4747 spec->automute_speaker = 0; 4748 spec->automute_lo = 0; 4749 break; 4750 case 1: 4751 if (spec->automute_speaker_possible) { 4752 if (!spec->automute_lo && spec->automute_speaker) 4753 return 0; 4754 spec->automute_speaker = 1; 4755 spec->automute_lo = 0; 4756 } else if (spec->automute_lo_possible) { 4757 if (spec->automute_lo) 4758 return 0; 4759 spec->automute_lo = 1; 4760 } else 4761 return -EINVAL; 4762 break; 4763 case 2: 4764 if (!spec->automute_lo_possible || !spec->automute_speaker_possible) 4765 return -EINVAL; 4766 if (spec->automute_speaker && spec->automute_lo) 4767 return 0; 4768 spec->automute_speaker = 1; 4769 spec->automute_lo = 1; 4770 break; 4771 default: 4772 return -EINVAL; 4773 } 4774 call_update_outputs(codec); 4775 return 1; 4776 } 4777 4778 static const struct snd_kcontrol_new automute_mode_enum = { 4779 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4780 .name = "Auto-Mute Mode", 4781 .info = automute_mode_info, 4782 .get = automute_mode_get, 4783 .put = automute_mode_put, 4784 }; 4785 4786 static int add_automute_mode_enum(struct hda_codec *codec) 4787 { 4788 struct hda_gen_spec *spec = codec->spec; 4789 4790 if (!snd_hda_gen_add_kctl(spec, NULL, &automute_mode_enum)) 4791 return -ENOMEM; 4792 return 0; 4793 } 4794 4795 /* 4796 * Check the availability of HP/line-out auto-mute; 4797 * Set up appropriately if really supported 4798 */ 4799 static int check_auto_mute_availability(struct hda_codec *codec) 4800 { 4801 struct hda_gen_spec *spec = codec->spec; 4802 struct auto_pin_cfg *cfg = &spec->autocfg; 4803 int present = 0; 4804 int i, err; 4805 4806 if (spec->suppress_auto_mute) 4807 return 0; 4808 4809 if (cfg->hp_pins[0]) 4810 present++; 4811 if (cfg->line_out_pins[0]) 4812 present++; 4813 if (cfg->speaker_pins[0]) 4814 present++; 4815 if (present < 2) /* need two different output types */ 4816 return 0; 4817 4818 if (!cfg->speaker_pins[0] && 4819 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) { 4820 memcpy(cfg->speaker_pins, cfg->line_out_pins, 4821 sizeof(cfg->speaker_pins)); 4822 cfg->speaker_outs = cfg->line_outs; 4823 } 4824 4825 if (!cfg->hp_pins[0] && 4826 cfg->line_out_type == AUTO_PIN_HP_OUT) { 4827 memcpy(cfg->hp_pins, cfg->line_out_pins, 4828 sizeof(cfg->hp_pins)); 4829 cfg->hp_outs = cfg->line_outs; 4830 } 4831 4832 for (i = 0; i < cfg->hp_outs; i++) { 4833 hda_nid_t nid = cfg->hp_pins[i]; 4834 if (!is_jack_detectable(codec, nid)) 4835 continue; 4836 codec_dbg(codec, "Enable HP auto-muting on NID 0x%x\n", nid); 4837 snd_hda_jack_detect_enable_callback(codec, nid, 4838 call_hp_automute); 4839 spec->detect_hp = 1; 4840 } 4841 4842 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) { 4843 if (cfg->speaker_outs) 4844 for (i = 0; i < cfg->line_outs; i++) { 4845 hda_nid_t nid = cfg->line_out_pins[i]; 4846 if (!is_jack_detectable(codec, nid)) 4847 continue; 4848 codec_dbg(codec, "Enable Line-Out auto-muting on NID 0x%x\n", nid); 4849 snd_hda_jack_detect_enable_callback(codec, nid, 4850 call_line_automute); 4851 spec->detect_lo = 1; 4852 } 4853 spec->automute_lo_possible = spec->detect_hp; 4854 } 4855 4856 spec->automute_speaker_possible = cfg->speaker_outs && 4857 (spec->detect_hp || spec->detect_lo); 4858 4859 spec->automute_lo = spec->automute_lo_possible; 4860 spec->automute_speaker = spec->automute_speaker_possible; 4861 4862 if (spec->automute_speaker_possible || spec->automute_lo_possible) { 4863 /* create a control for automute mode */ 4864 err = add_automute_mode_enum(codec); 4865 if (err < 0) 4866 return err; 4867 } 4868 return 0; 4869 } 4870 4871 /* check whether all auto-mic pins are valid; setup indices if OK */ 4872 static bool auto_mic_check_imux(struct hda_codec *codec) 4873 { 4874 struct hda_gen_spec *spec = codec->spec; 4875 const struct hda_input_mux *imux; 4876 int i; 4877 4878 imux = &spec->input_mux; 4879 for (i = 0; i < spec->am_num_entries; i++) { 4880 spec->am_entry[i].idx = 4881 find_idx_in_nid_list(spec->am_entry[i].pin, 4882 spec->imux_pins, imux->num_items); 4883 if (spec->am_entry[i].idx < 0) 4884 return false; /* no corresponding imux */ 4885 } 4886 4887 /* we don't need the jack detection for the first pin */ 4888 for (i = 1; i < spec->am_num_entries; i++) 4889 snd_hda_jack_detect_enable_callback(codec, 4890 spec->am_entry[i].pin, 4891 call_mic_autoswitch); 4892 return true; 4893 } 4894 4895 static int compare_attr(const void *ap, const void *bp) 4896 { 4897 const struct automic_entry *a = ap; 4898 const struct automic_entry *b = bp; 4899 return (int)(a->attr - b->attr); 4900 } 4901 4902 /* 4903 * Check the availability of auto-mic switch; 4904 * Set up if really supported 4905 */ 4906 static int check_auto_mic_availability(struct hda_codec *codec) 4907 { 4908 struct hda_gen_spec *spec = codec->spec; 4909 struct auto_pin_cfg *cfg = &spec->autocfg; 4910 unsigned int types; 4911 int i, num_pins; 4912 4913 if (spec->suppress_auto_mic) 4914 return 0; 4915 4916 types = 0; 4917 num_pins = 0; 4918 for (i = 0; i < cfg->num_inputs; i++) { 4919 hda_nid_t nid = cfg->inputs[i].pin; 4920 unsigned int attr; 4921 attr = snd_hda_codec_get_pincfg(codec, nid); 4922 attr = snd_hda_get_input_pin_attr(attr); 4923 if (types & (1 << attr)) 4924 return 0; /* already occupied */ 4925 switch (attr) { 4926 case INPUT_PIN_ATTR_INT: 4927 if (cfg->inputs[i].type != AUTO_PIN_MIC) 4928 return 0; /* invalid type */ 4929 break; 4930 case INPUT_PIN_ATTR_UNUSED: 4931 return 0; /* invalid entry */ 4932 default: 4933 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN) 4934 return 0; /* invalid type */ 4935 if (!spec->line_in_auto_switch && 4936 cfg->inputs[i].type != AUTO_PIN_MIC) 4937 return 0; /* only mic is allowed */ 4938 if (!is_jack_detectable(codec, nid)) 4939 return 0; /* no unsol support */ 4940 break; 4941 } 4942 if (num_pins >= MAX_AUTO_MIC_PINS) 4943 return 0; 4944 types |= (1 << attr); 4945 spec->am_entry[num_pins].pin = nid; 4946 spec->am_entry[num_pins].attr = attr; 4947 num_pins++; 4948 } 4949 4950 if (num_pins < 2) 4951 return 0; 4952 4953 spec->am_num_entries = num_pins; 4954 /* sort the am_entry in the order of attr so that the pin with a 4955 * higher attr will be selected when the jack is plugged. 4956 */ 4957 sort(spec->am_entry, num_pins, sizeof(spec->am_entry[0]), 4958 compare_attr, NULL); 4959 4960 if (!auto_mic_check_imux(codec)) 4961 return 0; 4962 4963 spec->auto_mic = 1; 4964 spec->num_adc_nids = 1; 4965 spec->cur_mux[0] = spec->am_entry[0].idx; 4966 codec_dbg(codec, "Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n", 4967 spec->am_entry[0].pin, 4968 spec->am_entry[1].pin, 4969 spec->am_entry[2].pin); 4970 4971 return 0; 4972 } 4973 4974 /** 4975 * snd_hda_gen_path_power_filter - power_filter hook to make inactive widgets 4976 * into power down 4977 * @codec: the HDA codec 4978 * @nid: NID to evalute 4979 * @power_state: target power state 4980 */ 4981 unsigned int snd_hda_gen_path_power_filter(struct hda_codec *codec, 4982 hda_nid_t nid, 4983 unsigned int power_state) 4984 { 4985 struct hda_gen_spec *spec = codec->spec; 4986 4987 if (!spec->power_down_unused && !codec->power_save_node) 4988 return power_state; 4989 if (power_state != AC_PWRST_D0 || nid == codec->core.afg) 4990 return power_state; 4991 if (get_wcaps_type(get_wcaps(codec, nid)) >= AC_WID_POWER) 4992 return power_state; 4993 if (is_active_nid_for_any(codec, nid)) 4994 return power_state; 4995 return AC_PWRST_D3; 4996 } 4997 EXPORT_SYMBOL_GPL(snd_hda_gen_path_power_filter); 4998 4999 /* mute all aamix inputs initially; parse up to the first leaves */ 5000 static void mute_all_mixer_nid(struct hda_codec *codec, hda_nid_t mix) 5001 { 5002 int i, nums; 5003 const hda_nid_t *conn; 5004 bool has_amp; 5005 5006 nums = snd_hda_get_conn_list(codec, mix, &conn); 5007 has_amp = nid_has_mute(codec, mix, HDA_INPUT); 5008 for (i = 0; i < nums; i++) { 5009 if (has_amp) 5010 update_amp(codec, mix, HDA_INPUT, i, 5011 0xff, HDA_AMP_MUTE); 5012 else if (nid_has_volume(codec, conn[i], HDA_OUTPUT)) 5013 update_amp(codec, conn[i], HDA_OUTPUT, 0, 5014 0xff, HDA_AMP_MUTE); 5015 } 5016 } 5017 5018 /** 5019 * snd_hda_gen_stream_pm - Stream power management callback 5020 * @codec: the HDA codec 5021 * @nid: audio widget 5022 * @on: power on/off flag 5023 * 5024 * Set this in patch_ops.stream_pm. Only valid with power_save_node flag. 5025 */ 5026 void snd_hda_gen_stream_pm(struct hda_codec *codec, hda_nid_t nid, bool on) 5027 { 5028 if (codec->power_save_node) 5029 set_path_power(codec, nid, -1, on); 5030 } 5031 EXPORT_SYMBOL_GPL(snd_hda_gen_stream_pm); 5032 5033 /** 5034 * snd_hda_gen_parse_auto_config - Parse the given BIOS configuration and 5035 * set up the hda_gen_spec 5036 * @codec: the HDA codec 5037 * @cfg: Parsed pin configuration 5038 * 5039 * return 1 if successful, 0 if the proper config is not found, 5040 * or a negative error code 5041 */ 5042 int snd_hda_gen_parse_auto_config(struct hda_codec *codec, 5043 struct auto_pin_cfg *cfg) 5044 { 5045 struct hda_gen_spec *spec = codec->spec; 5046 int err; 5047 5048 parse_user_hints(codec); 5049 5050 if (spec->mixer_nid && !spec->mixer_merge_nid) 5051 spec->mixer_merge_nid = spec->mixer_nid; 5052 5053 if (cfg != &spec->autocfg) { 5054 spec->autocfg = *cfg; 5055 cfg = &spec->autocfg; 5056 } 5057 5058 if (!spec->main_out_badness) 5059 spec->main_out_badness = &hda_main_out_badness; 5060 if (!spec->extra_out_badness) 5061 spec->extra_out_badness = &hda_extra_out_badness; 5062 5063 fill_all_dac_nids(codec); 5064 5065 if (!cfg->line_outs) { 5066 if (cfg->dig_outs || cfg->dig_in_pin) { 5067 spec->multiout.max_channels = 2; 5068 spec->no_analog = 1; 5069 goto dig_only; 5070 } 5071 if (!cfg->num_inputs && !cfg->dig_in_pin) 5072 return 0; /* can't find valid BIOS pin config */ 5073 } 5074 5075 if (!spec->no_primary_hp && 5076 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && 5077 cfg->line_outs <= cfg->hp_outs) { 5078 /* use HP as primary out */ 5079 cfg->speaker_outs = cfg->line_outs; 5080 memcpy(cfg->speaker_pins, cfg->line_out_pins, 5081 sizeof(cfg->speaker_pins)); 5082 cfg->line_outs = cfg->hp_outs; 5083 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins)); 5084 cfg->hp_outs = 0; 5085 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins)); 5086 cfg->line_out_type = AUTO_PIN_HP_OUT; 5087 } 5088 5089 err = parse_output_paths(codec); 5090 if (err < 0) 5091 return err; 5092 err = create_multi_channel_mode(codec); 5093 if (err < 0) 5094 return err; 5095 err = create_multi_out_ctls(codec, cfg); 5096 if (err < 0) 5097 return err; 5098 err = create_hp_out_ctls(codec); 5099 if (err < 0) 5100 return err; 5101 err = create_speaker_out_ctls(codec); 5102 if (err < 0) 5103 return err; 5104 err = create_indep_hp_ctls(codec); 5105 if (err < 0) 5106 return err; 5107 err = create_loopback_mixing_ctl(codec); 5108 if (err < 0) 5109 return err; 5110 err = create_hp_mic(codec); 5111 if (err < 0) 5112 return err; 5113 err = create_input_ctls(codec); 5114 if (err < 0) 5115 return err; 5116 5117 /* add power-down pin callbacks at first */ 5118 add_all_pin_power_ctls(codec, false); 5119 5120 spec->const_channel_count = spec->ext_channel_count; 5121 /* check the multiple speaker and headphone pins */ 5122 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) 5123 spec->const_channel_count = max(spec->const_channel_count, 5124 cfg->speaker_outs * 2); 5125 if (cfg->line_out_type != AUTO_PIN_HP_OUT) 5126 spec->const_channel_count = max(spec->const_channel_count, 5127 cfg->hp_outs * 2); 5128 spec->multiout.max_channels = max(spec->ext_channel_count, 5129 spec->const_channel_count); 5130 5131 err = check_auto_mute_availability(codec); 5132 if (err < 0) 5133 return err; 5134 5135 err = check_dyn_adc_switch(codec); 5136 if (err < 0) 5137 return err; 5138 5139 err = check_auto_mic_availability(codec); 5140 if (err < 0) 5141 return err; 5142 5143 /* add stereo mix if available and not enabled yet */ 5144 if (!spec->auto_mic && spec->mixer_nid && 5145 spec->add_stereo_mix_input == HDA_HINT_STEREO_MIX_AUTO && 5146 spec->input_mux.num_items > 1) { 5147 err = parse_capture_source(codec, spec->mixer_nid, 5148 CFG_IDX_MIX, spec->num_all_adcs, 5149 "Stereo Mix", 0); 5150 if (err < 0) 5151 return err; 5152 } 5153 5154 5155 err = create_capture_mixers(codec); 5156 if (err < 0) 5157 return err; 5158 5159 err = parse_mic_boost(codec); 5160 if (err < 0) 5161 return err; 5162 5163 /* create "Headphone Mic Jack Mode" if no input selection is 5164 * available (or user specifies add_jack_modes hint) 5165 */ 5166 if (spec->hp_mic_pin && 5167 (spec->auto_mic || spec->input_mux.num_items == 1 || 5168 spec->add_jack_modes)) { 5169 err = create_hp_mic_jack_mode(codec, spec->hp_mic_pin); 5170 if (err < 0) 5171 return err; 5172 } 5173 5174 if (spec->add_jack_modes) { 5175 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { 5176 err = create_out_jack_modes(codec, cfg->line_outs, 5177 cfg->line_out_pins); 5178 if (err < 0) 5179 return err; 5180 } 5181 if (cfg->line_out_type != AUTO_PIN_HP_OUT) { 5182 err = create_out_jack_modes(codec, cfg->hp_outs, 5183 cfg->hp_pins); 5184 if (err < 0) 5185 return err; 5186 } 5187 } 5188 5189 /* add power-up pin callbacks at last */ 5190 add_all_pin_power_ctls(codec, true); 5191 5192 /* mute all aamix input initially */ 5193 if (spec->mixer_nid) 5194 mute_all_mixer_nid(codec, spec->mixer_nid); 5195 5196 dig_only: 5197 parse_digital(codec); 5198 5199 if (spec->power_down_unused || codec->power_save_node) { 5200 if (!codec->power_filter) 5201 codec->power_filter = snd_hda_gen_path_power_filter; 5202 if (!codec->patch_ops.stream_pm) 5203 codec->patch_ops.stream_pm = snd_hda_gen_stream_pm; 5204 } 5205 5206 if (!spec->no_analog && spec->beep_nid) { 5207 err = snd_hda_attach_beep_device(codec, spec->beep_nid); 5208 if (err < 0) 5209 return err; 5210 if (codec->beep && codec->power_save_node) { 5211 err = add_fake_beep_paths(codec); 5212 if (err < 0) 5213 return err; 5214 codec->beep->power_hook = beep_power_hook; 5215 } 5216 } 5217 5218 return 1; 5219 } 5220 EXPORT_SYMBOL_GPL(snd_hda_gen_parse_auto_config); 5221 5222 5223 /* 5224 * Build control elements 5225 */ 5226 5227 /* slave controls for virtual master */ 5228 static const char * const slave_pfxs[] = { 5229 "Front", "Surround", "Center", "LFE", "Side", 5230 "Headphone", "Speaker", "Mono", "Line Out", 5231 "CLFE", "Bass Speaker", "PCM", 5232 "Speaker Front", "Speaker Surround", "Speaker CLFE", "Speaker Side", 5233 "Headphone Front", "Headphone Surround", "Headphone CLFE", 5234 "Headphone Side", "Headphone+LO", "Speaker+LO", 5235 NULL, 5236 }; 5237 5238 /** 5239 * snd_hda_gen_build_controls - Build controls from the parsed results 5240 * @codec: the HDA codec 5241 * 5242 * Pass this to build_controls patch_ops. 5243 */ 5244 int snd_hda_gen_build_controls(struct hda_codec *codec) 5245 { 5246 struct hda_gen_spec *spec = codec->spec; 5247 int err; 5248 5249 if (spec->kctls.used) { 5250 err = snd_hda_add_new_ctls(codec, spec->kctls.list); 5251 if (err < 0) 5252 return err; 5253 } 5254 5255 if (spec->multiout.dig_out_nid) { 5256 err = snd_hda_create_dig_out_ctls(codec, 5257 spec->multiout.dig_out_nid, 5258 spec->multiout.dig_out_nid, 5259 spec->pcm_rec[1]->pcm_type); 5260 if (err < 0) 5261 return err; 5262 if (!spec->no_analog) { 5263 err = snd_hda_create_spdif_share_sw(codec, 5264 &spec->multiout); 5265 if (err < 0) 5266 return err; 5267 spec->multiout.share_spdif = 1; 5268 } 5269 } 5270 if (spec->dig_in_nid) { 5271 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 5272 if (err < 0) 5273 return err; 5274 } 5275 5276 /* if we have no master control, let's create it */ 5277 if (!spec->no_analog && !spec->suppress_vmaster && 5278 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 5279 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 5280 spec->vmaster_tlv, slave_pfxs, 5281 "Playback Volume"); 5282 if (err < 0) 5283 return err; 5284 } 5285 if (!spec->no_analog && !spec->suppress_vmaster && 5286 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 5287 err = __snd_hda_add_vmaster(codec, "Master Playback Switch", 5288 NULL, slave_pfxs, 5289 "Playback Switch", 5290 true, &spec->vmaster_mute.sw_kctl); 5291 if (err < 0) 5292 return err; 5293 if (spec->vmaster_mute.hook) { 5294 snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute, 5295 spec->vmaster_mute_enum); 5296 snd_hda_sync_vmaster_hook(&spec->vmaster_mute); 5297 } 5298 } 5299 5300 free_kctls(spec); /* no longer needed */ 5301 5302 err = snd_hda_jack_add_kctls(codec, &spec->autocfg); 5303 if (err < 0) 5304 return err; 5305 5306 return 0; 5307 } 5308 EXPORT_SYMBOL_GPL(snd_hda_gen_build_controls); 5309 5310 5311 /* 5312 * PCM definitions 5313 */ 5314 5315 static void call_pcm_playback_hook(struct hda_pcm_stream *hinfo, 5316 struct hda_codec *codec, 5317 struct snd_pcm_substream *substream, 5318 int action) 5319 { 5320 struct hda_gen_spec *spec = codec->spec; 5321 if (spec->pcm_playback_hook) 5322 spec->pcm_playback_hook(hinfo, codec, substream, action); 5323 } 5324 5325 static void call_pcm_capture_hook(struct hda_pcm_stream *hinfo, 5326 struct hda_codec *codec, 5327 struct snd_pcm_substream *substream, 5328 int action) 5329 { 5330 struct hda_gen_spec *spec = codec->spec; 5331 if (spec->pcm_capture_hook) 5332 spec->pcm_capture_hook(hinfo, codec, substream, action); 5333 } 5334 5335 /* 5336 * Analog playback callbacks 5337 */ 5338 static int playback_pcm_open(struct hda_pcm_stream *hinfo, 5339 struct hda_codec *codec, 5340 struct snd_pcm_substream *substream) 5341 { 5342 struct hda_gen_spec *spec = codec->spec; 5343 int err; 5344 5345 mutex_lock(&spec->pcm_mutex); 5346 err = snd_hda_multi_out_analog_open(codec, 5347 &spec->multiout, substream, 5348 hinfo); 5349 if (!err) { 5350 spec->active_streams |= 1 << STREAM_MULTI_OUT; 5351 call_pcm_playback_hook(hinfo, codec, substream, 5352 HDA_GEN_PCM_ACT_OPEN); 5353 } 5354 mutex_unlock(&spec->pcm_mutex); 5355 return err; 5356 } 5357 5358 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo, 5359 struct hda_codec *codec, 5360 unsigned int stream_tag, 5361 unsigned int format, 5362 struct snd_pcm_substream *substream) 5363 { 5364 struct hda_gen_spec *spec = codec->spec; 5365 int err; 5366 5367 err = snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 5368 stream_tag, format, substream); 5369 if (!err) 5370 call_pcm_playback_hook(hinfo, codec, substream, 5371 HDA_GEN_PCM_ACT_PREPARE); 5372 return err; 5373 } 5374 5375 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 5376 struct hda_codec *codec, 5377 struct snd_pcm_substream *substream) 5378 { 5379 struct hda_gen_spec *spec = codec->spec; 5380 int err; 5381 5382 err = snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 5383 if (!err) 5384 call_pcm_playback_hook(hinfo, codec, substream, 5385 HDA_GEN_PCM_ACT_CLEANUP); 5386 return err; 5387 } 5388 5389 static int playback_pcm_close(struct hda_pcm_stream *hinfo, 5390 struct hda_codec *codec, 5391 struct snd_pcm_substream *substream) 5392 { 5393 struct hda_gen_spec *spec = codec->spec; 5394 mutex_lock(&spec->pcm_mutex); 5395 spec->active_streams &= ~(1 << STREAM_MULTI_OUT); 5396 call_pcm_playback_hook(hinfo, codec, substream, 5397 HDA_GEN_PCM_ACT_CLOSE); 5398 mutex_unlock(&spec->pcm_mutex); 5399 return 0; 5400 } 5401 5402 static int capture_pcm_open(struct hda_pcm_stream *hinfo, 5403 struct hda_codec *codec, 5404 struct snd_pcm_substream *substream) 5405 { 5406 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_OPEN); 5407 return 0; 5408 } 5409 5410 static int capture_pcm_prepare(struct hda_pcm_stream *hinfo, 5411 struct hda_codec *codec, 5412 unsigned int stream_tag, 5413 unsigned int format, 5414 struct snd_pcm_substream *substream) 5415 { 5416 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format); 5417 call_pcm_capture_hook(hinfo, codec, substream, 5418 HDA_GEN_PCM_ACT_PREPARE); 5419 return 0; 5420 } 5421 5422 static int capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 5423 struct hda_codec *codec, 5424 struct snd_pcm_substream *substream) 5425 { 5426 snd_hda_codec_cleanup_stream(codec, hinfo->nid); 5427 call_pcm_capture_hook(hinfo, codec, substream, 5428 HDA_GEN_PCM_ACT_CLEANUP); 5429 return 0; 5430 } 5431 5432 static int capture_pcm_close(struct hda_pcm_stream *hinfo, 5433 struct hda_codec *codec, 5434 struct snd_pcm_substream *substream) 5435 { 5436 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLOSE); 5437 return 0; 5438 } 5439 5440 static int alt_playback_pcm_open(struct hda_pcm_stream *hinfo, 5441 struct hda_codec *codec, 5442 struct snd_pcm_substream *substream) 5443 { 5444 struct hda_gen_spec *spec = codec->spec; 5445 int err = 0; 5446 5447 mutex_lock(&spec->pcm_mutex); 5448 if (spec->indep_hp && !spec->indep_hp_enabled) 5449 err = -EBUSY; 5450 else 5451 spec->active_streams |= 1 << STREAM_INDEP_HP; 5452 call_pcm_playback_hook(hinfo, codec, substream, 5453 HDA_GEN_PCM_ACT_OPEN); 5454 mutex_unlock(&spec->pcm_mutex); 5455 return err; 5456 } 5457 5458 static int alt_playback_pcm_close(struct hda_pcm_stream *hinfo, 5459 struct hda_codec *codec, 5460 struct snd_pcm_substream *substream) 5461 { 5462 struct hda_gen_spec *spec = codec->spec; 5463 mutex_lock(&spec->pcm_mutex); 5464 spec->active_streams &= ~(1 << STREAM_INDEP_HP); 5465 call_pcm_playback_hook(hinfo, codec, substream, 5466 HDA_GEN_PCM_ACT_CLOSE); 5467 mutex_unlock(&spec->pcm_mutex); 5468 return 0; 5469 } 5470 5471 static int alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 5472 struct hda_codec *codec, 5473 unsigned int stream_tag, 5474 unsigned int format, 5475 struct snd_pcm_substream *substream) 5476 { 5477 snd_hda_codec_setup_stream(codec, hinfo->nid, stream_tag, 0, format); 5478 call_pcm_playback_hook(hinfo, codec, substream, 5479 HDA_GEN_PCM_ACT_PREPARE); 5480 return 0; 5481 } 5482 5483 static int alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 5484 struct hda_codec *codec, 5485 struct snd_pcm_substream *substream) 5486 { 5487 snd_hda_codec_cleanup_stream(codec, hinfo->nid); 5488 call_pcm_playback_hook(hinfo, codec, substream, 5489 HDA_GEN_PCM_ACT_CLEANUP); 5490 return 0; 5491 } 5492 5493 /* 5494 * Digital out 5495 */ 5496 static int dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 5497 struct hda_codec *codec, 5498 struct snd_pcm_substream *substream) 5499 { 5500 struct hda_gen_spec *spec = codec->spec; 5501 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 5502 } 5503 5504 static int dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 5505 struct hda_codec *codec, 5506 unsigned int stream_tag, 5507 unsigned int format, 5508 struct snd_pcm_substream *substream) 5509 { 5510 struct hda_gen_spec *spec = codec->spec; 5511 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 5512 stream_tag, format, substream); 5513 } 5514 5515 static int dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 5516 struct hda_codec *codec, 5517 struct snd_pcm_substream *substream) 5518 { 5519 struct hda_gen_spec *spec = codec->spec; 5520 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 5521 } 5522 5523 static int dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 5524 struct hda_codec *codec, 5525 struct snd_pcm_substream *substream) 5526 { 5527 struct hda_gen_spec *spec = codec->spec; 5528 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 5529 } 5530 5531 /* 5532 * Analog capture 5533 */ 5534 #define alt_capture_pcm_open capture_pcm_open 5535 #define alt_capture_pcm_close capture_pcm_close 5536 5537 static int alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 5538 struct hda_codec *codec, 5539 unsigned int stream_tag, 5540 unsigned int format, 5541 struct snd_pcm_substream *substream) 5542 { 5543 struct hda_gen_spec *spec = codec->spec; 5544 5545 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1], 5546 stream_tag, 0, format); 5547 call_pcm_capture_hook(hinfo, codec, substream, 5548 HDA_GEN_PCM_ACT_PREPARE); 5549 return 0; 5550 } 5551 5552 static int alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 5553 struct hda_codec *codec, 5554 struct snd_pcm_substream *substream) 5555 { 5556 struct hda_gen_spec *spec = codec->spec; 5557 5558 snd_hda_codec_cleanup_stream(codec, 5559 spec->adc_nids[substream->number + 1]); 5560 call_pcm_capture_hook(hinfo, codec, substream, 5561 HDA_GEN_PCM_ACT_CLEANUP); 5562 return 0; 5563 } 5564 5565 /* 5566 */ 5567 static const struct hda_pcm_stream pcm_analog_playback = { 5568 .substreams = 1, 5569 .channels_min = 2, 5570 .channels_max = 8, 5571 /* NID is set in build_pcms */ 5572 .ops = { 5573 .open = playback_pcm_open, 5574 .close = playback_pcm_close, 5575 .prepare = playback_pcm_prepare, 5576 .cleanup = playback_pcm_cleanup 5577 }, 5578 }; 5579 5580 static const struct hda_pcm_stream pcm_analog_capture = { 5581 .substreams = 1, 5582 .channels_min = 2, 5583 .channels_max = 2, 5584 /* NID is set in build_pcms */ 5585 .ops = { 5586 .open = capture_pcm_open, 5587 .close = capture_pcm_close, 5588 .prepare = capture_pcm_prepare, 5589 .cleanup = capture_pcm_cleanup 5590 }, 5591 }; 5592 5593 static const struct hda_pcm_stream pcm_analog_alt_playback = { 5594 .substreams = 1, 5595 .channels_min = 2, 5596 .channels_max = 2, 5597 /* NID is set in build_pcms */ 5598 .ops = { 5599 .open = alt_playback_pcm_open, 5600 .close = alt_playback_pcm_close, 5601 .prepare = alt_playback_pcm_prepare, 5602 .cleanup = alt_playback_pcm_cleanup 5603 }, 5604 }; 5605 5606 static const struct hda_pcm_stream pcm_analog_alt_capture = { 5607 .substreams = 2, /* can be overridden */ 5608 .channels_min = 2, 5609 .channels_max = 2, 5610 /* NID is set in build_pcms */ 5611 .ops = { 5612 .open = alt_capture_pcm_open, 5613 .close = alt_capture_pcm_close, 5614 .prepare = alt_capture_pcm_prepare, 5615 .cleanup = alt_capture_pcm_cleanup 5616 }, 5617 }; 5618 5619 static const struct hda_pcm_stream pcm_digital_playback = { 5620 .substreams = 1, 5621 .channels_min = 2, 5622 .channels_max = 2, 5623 /* NID is set in build_pcms */ 5624 .ops = { 5625 .open = dig_playback_pcm_open, 5626 .close = dig_playback_pcm_close, 5627 .prepare = dig_playback_pcm_prepare, 5628 .cleanup = dig_playback_pcm_cleanup 5629 }, 5630 }; 5631 5632 static const struct hda_pcm_stream pcm_digital_capture = { 5633 .substreams = 1, 5634 .channels_min = 2, 5635 .channels_max = 2, 5636 /* NID is set in build_pcms */ 5637 }; 5638 5639 /* Used by build_pcms to flag that a PCM has no playback stream */ 5640 static const struct hda_pcm_stream pcm_null_stream = { 5641 .substreams = 0, 5642 .channels_min = 0, 5643 .channels_max = 0, 5644 }; 5645 5646 /* 5647 * dynamic changing ADC PCM streams 5648 */ 5649 static bool dyn_adc_pcm_resetup(struct hda_codec *codec, int cur) 5650 { 5651 struct hda_gen_spec *spec = codec->spec; 5652 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]]; 5653 5654 if (spec->cur_adc && spec->cur_adc != new_adc) { 5655 /* stream is running, let's swap the current ADC */ 5656 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1); 5657 spec->cur_adc = new_adc; 5658 snd_hda_codec_setup_stream(codec, new_adc, 5659 spec->cur_adc_stream_tag, 0, 5660 spec->cur_adc_format); 5661 return true; 5662 } 5663 return false; 5664 } 5665 5666 /* analog capture with dynamic dual-adc changes */ 5667 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 5668 struct hda_codec *codec, 5669 unsigned int stream_tag, 5670 unsigned int format, 5671 struct snd_pcm_substream *substream) 5672 { 5673 struct hda_gen_spec *spec = codec->spec; 5674 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]]; 5675 spec->cur_adc_stream_tag = stream_tag; 5676 spec->cur_adc_format = format; 5677 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format); 5678 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE); 5679 return 0; 5680 } 5681 5682 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 5683 struct hda_codec *codec, 5684 struct snd_pcm_substream *substream) 5685 { 5686 struct hda_gen_spec *spec = codec->spec; 5687 snd_hda_codec_cleanup_stream(codec, spec->cur_adc); 5688 spec->cur_adc = 0; 5689 call_pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_CLEANUP); 5690 return 0; 5691 } 5692 5693 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = { 5694 .substreams = 1, 5695 .channels_min = 2, 5696 .channels_max = 2, 5697 .nid = 0, /* fill later */ 5698 .ops = { 5699 .prepare = dyn_adc_capture_pcm_prepare, 5700 .cleanup = dyn_adc_capture_pcm_cleanup 5701 }, 5702 }; 5703 5704 static void fill_pcm_stream_name(char *str, size_t len, const char *sfx, 5705 const char *chip_name) 5706 { 5707 char *p; 5708 5709 if (*str) 5710 return; 5711 strlcpy(str, chip_name, len); 5712 5713 /* drop non-alnum chars after a space */ 5714 for (p = strchr(str, ' '); p; p = strchr(p + 1, ' ')) { 5715 if (!isalnum(p[1])) { 5716 *p = 0; 5717 break; 5718 } 5719 } 5720 strlcat(str, sfx, len); 5721 } 5722 5723 /* copy PCM stream info from @default_str, and override non-NULL entries 5724 * from @spec_str and @nid 5725 */ 5726 static void setup_pcm_stream(struct hda_pcm_stream *str, 5727 const struct hda_pcm_stream *default_str, 5728 const struct hda_pcm_stream *spec_str, 5729 hda_nid_t nid) 5730 { 5731 *str = *default_str; 5732 if (nid) 5733 str->nid = nid; 5734 if (spec_str) { 5735 if (spec_str->substreams) 5736 str->substreams = spec_str->substreams; 5737 if (spec_str->channels_min) 5738 str->channels_min = spec_str->channels_min; 5739 if (spec_str->channels_max) 5740 str->channels_max = spec_str->channels_max; 5741 if (spec_str->rates) 5742 str->rates = spec_str->rates; 5743 if (spec_str->formats) 5744 str->formats = spec_str->formats; 5745 if (spec_str->maxbps) 5746 str->maxbps = spec_str->maxbps; 5747 } 5748 } 5749 5750 /** 5751 * snd_hda_gen_build_pcms - build PCM streams based on the parsed results 5752 * @codec: the HDA codec 5753 * 5754 * Pass this to build_pcms patch_ops. 5755 */ 5756 int snd_hda_gen_build_pcms(struct hda_codec *codec) 5757 { 5758 struct hda_gen_spec *spec = codec->spec; 5759 struct hda_pcm *info; 5760 bool have_multi_adcs; 5761 5762 if (spec->no_analog) 5763 goto skip_analog; 5764 5765 fill_pcm_stream_name(spec->stream_name_analog, 5766 sizeof(spec->stream_name_analog), 5767 " Analog", codec->core.chip_name); 5768 info = snd_hda_codec_pcm_new(codec, "%s", spec->stream_name_analog); 5769 if (!info) 5770 return -ENOMEM; 5771 spec->pcm_rec[0] = info; 5772 5773 if (spec->multiout.num_dacs > 0) { 5774 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK], 5775 &pcm_analog_playback, 5776 spec->stream_analog_playback, 5777 spec->multiout.dac_nids[0]); 5778 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 5779 spec->multiout.max_channels; 5780 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT && 5781 spec->autocfg.line_outs == 2) 5782 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap = 5783 snd_pcm_2_1_chmaps; 5784 } 5785 if (spec->num_adc_nids) { 5786 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE], 5787 (spec->dyn_adc_switch ? 5788 &dyn_adc_pcm_analog_capture : &pcm_analog_capture), 5789 spec->stream_analog_capture, 5790 spec->adc_nids[0]); 5791 } 5792 5793 skip_analog: 5794 /* SPDIF for stream index #1 */ 5795 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 5796 fill_pcm_stream_name(spec->stream_name_digital, 5797 sizeof(spec->stream_name_digital), 5798 " Digital", codec->core.chip_name); 5799 info = snd_hda_codec_pcm_new(codec, "%s", 5800 spec->stream_name_digital); 5801 if (!info) 5802 return -ENOMEM; 5803 codec->slave_dig_outs = spec->multiout.slave_dig_outs; 5804 spec->pcm_rec[1] = info; 5805 if (spec->dig_out_type) 5806 info->pcm_type = spec->dig_out_type; 5807 else 5808 info->pcm_type = HDA_PCM_TYPE_SPDIF; 5809 if (spec->multiout.dig_out_nid) 5810 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK], 5811 &pcm_digital_playback, 5812 spec->stream_digital_playback, 5813 spec->multiout.dig_out_nid); 5814 if (spec->dig_in_nid) 5815 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE], 5816 &pcm_digital_capture, 5817 spec->stream_digital_capture, 5818 spec->dig_in_nid); 5819 } 5820 5821 if (spec->no_analog) 5822 return 0; 5823 5824 /* If the use of more than one ADC is requested for the current 5825 * model, configure a second analog capture-only PCM. 5826 */ 5827 have_multi_adcs = (spec->num_adc_nids > 1) && 5828 !spec->dyn_adc_switch && !spec->auto_mic; 5829 /* Additional Analaog capture for index #2 */ 5830 if (spec->alt_dac_nid || have_multi_adcs) { 5831 fill_pcm_stream_name(spec->stream_name_alt_analog, 5832 sizeof(spec->stream_name_alt_analog), 5833 " Alt Analog", codec->core.chip_name); 5834 info = snd_hda_codec_pcm_new(codec, "%s", 5835 spec->stream_name_alt_analog); 5836 if (!info) 5837 return -ENOMEM; 5838 spec->pcm_rec[2] = info; 5839 if (spec->alt_dac_nid) 5840 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK], 5841 &pcm_analog_alt_playback, 5842 spec->stream_analog_alt_playback, 5843 spec->alt_dac_nid); 5844 else 5845 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_PLAYBACK], 5846 &pcm_null_stream, NULL, 0); 5847 if (have_multi_adcs) { 5848 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE], 5849 &pcm_analog_alt_capture, 5850 spec->stream_analog_alt_capture, 5851 spec->adc_nids[1]); 5852 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 5853 spec->num_adc_nids - 1; 5854 } else { 5855 setup_pcm_stream(&info->stream[SNDRV_PCM_STREAM_CAPTURE], 5856 &pcm_null_stream, NULL, 0); 5857 } 5858 } 5859 5860 return 0; 5861 } 5862 EXPORT_SYMBOL_GPL(snd_hda_gen_build_pcms); 5863 5864 5865 /* 5866 * Standard auto-parser initializations 5867 */ 5868 5869 /* configure the given path as a proper output */ 5870 static void set_output_and_unmute(struct hda_codec *codec, int path_idx) 5871 { 5872 struct nid_path *path; 5873 hda_nid_t pin; 5874 5875 path = snd_hda_get_path_from_idx(codec, path_idx); 5876 if (!path || !path->depth) 5877 return; 5878 pin = path->path[path->depth - 1]; 5879 restore_pin_ctl(codec, pin); 5880 snd_hda_activate_path(codec, path, path->active, 5881 aamix_default(codec->spec)); 5882 set_pin_eapd(codec, pin, path->active); 5883 } 5884 5885 /* initialize primary output paths */ 5886 static void init_multi_out(struct hda_codec *codec) 5887 { 5888 struct hda_gen_spec *spec = codec->spec; 5889 int i; 5890 5891 for (i = 0; i < spec->autocfg.line_outs; i++) 5892 set_output_and_unmute(codec, spec->out_paths[i]); 5893 } 5894 5895 5896 static void __init_extra_out(struct hda_codec *codec, int num_outs, int *paths) 5897 { 5898 int i; 5899 5900 for (i = 0; i < num_outs; i++) 5901 set_output_and_unmute(codec, paths[i]); 5902 } 5903 5904 /* initialize hp and speaker paths */ 5905 static void init_extra_out(struct hda_codec *codec) 5906 { 5907 struct hda_gen_spec *spec = codec->spec; 5908 5909 if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT) 5910 __init_extra_out(codec, spec->autocfg.hp_outs, spec->hp_paths); 5911 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT) 5912 __init_extra_out(codec, spec->autocfg.speaker_outs, 5913 spec->speaker_paths); 5914 } 5915 5916 /* initialize multi-io paths */ 5917 static void init_multi_io(struct hda_codec *codec) 5918 { 5919 struct hda_gen_spec *spec = codec->spec; 5920 int i; 5921 5922 for (i = 0; i < spec->multi_ios; i++) { 5923 hda_nid_t pin = spec->multi_io[i].pin; 5924 struct nid_path *path; 5925 path = get_multiio_path(codec, i); 5926 if (!path) 5927 continue; 5928 if (!spec->multi_io[i].ctl_in) 5929 spec->multi_io[i].ctl_in = 5930 snd_hda_codec_get_pin_target(codec, pin); 5931 snd_hda_activate_path(codec, path, path->active, 5932 aamix_default(spec)); 5933 } 5934 } 5935 5936 static void init_aamix_paths(struct hda_codec *codec) 5937 { 5938 struct hda_gen_spec *spec = codec->spec; 5939 5940 if (!spec->have_aamix_ctl) 5941 return; 5942 if (!has_aamix_out_paths(spec)) 5943 return; 5944 update_aamix_paths(codec, spec->aamix_mode, spec->out_paths[0], 5945 spec->aamix_out_paths[0], 5946 spec->autocfg.line_out_type); 5947 update_aamix_paths(codec, spec->aamix_mode, spec->hp_paths[0], 5948 spec->aamix_out_paths[1], 5949 AUTO_PIN_HP_OUT); 5950 update_aamix_paths(codec, spec->aamix_mode, spec->speaker_paths[0], 5951 spec->aamix_out_paths[2], 5952 AUTO_PIN_SPEAKER_OUT); 5953 } 5954 5955 /* set up input pins and loopback paths */ 5956 static void init_analog_input(struct hda_codec *codec) 5957 { 5958 struct hda_gen_spec *spec = codec->spec; 5959 struct auto_pin_cfg *cfg = &spec->autocfg; 5960 int i; 5961 5962 for (i = 0; i < cfg->num_inputs; i++) { 5963 hda_nid_t nid = cfg->inputs[i].pin; 5964 if (is_input_pin(codec, nid)) 5965 restore_pin_ctl(codec, nid); 5966 5967 /* init loopback inputs */ 5968 if (spec->mixer_nid) { 5969 resume_path_from_idx(codec, spec->loopback_paths[i]); 5970 resume_path_from_idx(codec, spec->loopback_merge_path); 5971 } 5972 } 5973 } 5974 5975 /* initialize ADC paths */ 5976 static void init_input_src(struct hda_codec *codec) 5977 { 5978 struct hda_gen_spec *spec = codec->spec; 5979 struct hda_input_mux *imux = &spec->input_mux; 5980 struct nid_path *path; 5981 int i, c, nums; 5982 5983 if (spec->dyn_adc_switch) 5984 nums = 1; 5985 else 5986 nums = spec->num_adc_nids; 5987 5988 for (c = 0; c < nums; c++) { 5989 for (i = 0; i < imux->num_items; i++) { 5990 path = get_input_path(codec, c, i); 5991 if (path) { 5992 bool active = path->active; 5993 if (i == spec->cur_mux[c]) 5994 active = true; 5995 snd_hda_activate_path(codec, path, active, false); 5996 } 5997 } 5998 if (spec->hp_mic) 5999 update_hp_mic(codec, c, true); 6000 } 6001 6002 if (spec->cap_sync_hook) 6003 spec->cap_sync_hook(codec, NULL, NULL); 6004 } 6005 6006 /* set right pin controls for digital I/O */ 6007 static void init_digital(struct hda_codec *codec) 6008 { 6009 struct hda_gen_spec *spec = codec->spec; 6010 int i; 6011 hda_nid_t pin; 6012 6013 for (i = 0; i < spec->autocfg.dig_outs; i++) 6014 set_output_and_unmute(codec, spec->digout_paths[i]); 6015 pin = spec->autocfg.dig_in_pin; 6016 if (pin) { 6017 restore_pin_ctl(codec, pin); 6018 resume_path_from_idx(codec, spec->digin_path); 6019 } 6020 } 6021 6022 /* clear unsol-event tags on unused pins; Conexant codecs seem to leave 6023 * invalid unsol tags by some reason 6024 */ 6025 static void clear_unsol_on_unused_pins(struct hda_codec *codec) 6026 { 6027 const struct hda_pincfg *pin; 6028 int i; 6029 6030 snd_array_for_each(&codec->init_pins, i, pin) { 6031 hda_nid_t nid = pin->nid; 6032 if (is_jack_detectable(codec, nid) && 6033 !snd_hda_jack_tbl_get(codec, nid)) 6034 snd_hda_codec_write_cache(codec, nid, 0, 6035 AC_VERB_SET_UNSOLICITED_ENABLE, 0); 6036 } 6037 } 6038 6039 /** 6040 * snd_hda_gen_init - initialize the generic spec 6041 * @codec: the HDA codec 6042 * 6043 * This can be put as patch_ops init function. 6044 */ 6045 int snd_hda_gen_init(struct hda_codec *codec) 6046 { 6047 struct hda_gen_spec *spec = codec->spec; 6048 6049 if (spec->init_hook) 6050 spec->init_hook(codec); 6051 6052 if (!spec->skip_verbs) 6053 snd_hda_apply_verbs(codec); 6054 6055 init_multi_out(codec); 6056 init_extra_out(codec); 6057 init_multi_io(codec); 6058 init_aamix_paths(codec); 6059 init_analog_input(codec); 6060 init_input_src(codec); 6061 init_digital(codec); 6062 6063 clear_unsol_on_unused_pins(codec); 6064 6065 sync_all_pin_power_ctls(codec); 6066 6067 /* call init functions of standard auto-mute helpers */ 6068 update_automute_all(codec); 6069 6070 snd_hda_regmap_sync(codec); 6071 6072 if (spec->vmaster_mute.sw_kctl && spec->vmaster_mute.hook) 6073 snd_hda_sync_vmaster_hook(&spec->vmaster_mute); 6074 6075 hda_call_check_power_status(codec, 0x01); 6076 return 0; 6077 } 6078 EXPORT_SYMBOL_GPL(snd_hda_gen_init); 6079 6080 /** 6081 * snd_hda_gen_free - free the generic spec 6082 * @codec: the HDA codec 6083 * 6084 * This can be put as patch_ops free function. 6085 */ 6086 void snd_hda_gen_free(struct hda_codec *codec) 6087 { 6088 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_FREE); 6089 snd_hda_gen_spec_free(codec->spec); 6090 kfree(codec->spec); 6091 codec->spec = NULL; 6092 } 6093 EXPORT_SYMBOL_GPL(snd_hda_gen_free); 6094 6095 /** 6096 * snd_hda_gen_reboot_notify - Make codec enter D3 before rebooting 6097 * @codec: the HDA codec 6098 * 6099 * This can be put as patch_ops reboot_notify function. 6100 */ 6101 void snd_hda_gen_reboot_notify(struct hda_codec *codec) 6102 { 6103 /* Make the codec enter D3 to avoid spurious noises from the internal 6104 * speaker during (and after) reboot 6105 */ 6106 snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3); 6107 snd_hda_codec_write(codec, codec->core.afg, 0, 6108 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 6109 msleep(10); 6110 } 6111 EXPORT_SYMBOL_GPL(snd_hda_gen_reboot_notify); 6112 6113 #ifdef CONFIG_PM 6114 /** 6115 * snd_hda_gen_check_power_status - check the loopback power save state 6116 * @codec: the HDA codec 6117 * @nid: NID to inspect 6118 * 6119 * This can be put as patch_ops check_power_status function. 6120 */ 6121 int snd_hda_gen_check_power_status(struct hda_codec *codec, hda_nid_t nid) 6122 { 6123 struct hda_gen_spec *spec = codec->spec; 6124 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 6125 } 6126 EXPORT_SYMBOL_GPL(snd_hda_gen_check_power_status); 6127 #endif 6128 6129 6130 /* 6131 * the generic codec support 6132 */ 6133 6134 static const struct hda_codec_ops generic_patch_ops = { 6135 .build_controls = snd_hda_gen_build_controls, 6136 .build_pcms = snd_hda_gen_build_pcms, 6137 .init = snd_hda_gen_init, 6138 .free = snd_hda_gen_free, 6139 .unsol_event = snd_hda_jack_unsol_event, 6140 .reboot_notify = snd_hda_gen_reboot_notify, 6141 #ifdef CONFIG_PM 6142 .check_power_status = snd_hda_gen_check_power_status, 6143 #endif 6144 }; 6145 6146 /* 6147 * snd_hda_parse_generic_codec - Generic codec parser 6148 * @codec: the HDA codec 6149 */ 6150 static int snd_hda_parse_generic_codec(struct hda_codec *codec) 6151 { 6152 struct hda_gen_spec *spec; 6153 int err; 6154 6155 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6156 if (!spec) 6157 return -ENOMEM; 6158 snd_hda_gen_spec_init(spec); 6159 codec->spec = spec; 6160 6161 err = snd_hda_parse_pin_defcfg(codec, &spec->autocfg, NULL, 0); 6162 if (err < 0) 6163 goto error; 6164 6165 err = snd_hda_gen_parse_auto_config(codec, &spec->autocfg); 6166 if (err < 0) 6167 goto error; 6168 6169 codec->patch_ops = generic_patch_ops; 6170 return 0; 6171 6172 error: 6173 snd_hda_gen_free(codec); 6174 return err; 6175 } 6176 6177 static const struct hda_device_id snd_hda_id_generic[] = { 6178 HDA_CODEC_ENTRY(HDA_CODEC_ID_GENERIC, "Generic", snd_hda_parse_generic_codec), 6179 {} /* terminator */ 6180 }; 6181 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_generic); 6182 6183 static struct hda_codec_driver generic_driver = { 6184 .id = snd_hda_id_generic, 6185 }; 6186 6187 module_hda_codec_driver(generic_driver); 6188 6189 MODULE_LICENSE("GPL"); 6190 MODULE_DESCRIPTION("Generic HD-audio codec parser"); 6191