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