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