1 /* 2 * BIOS auto-parser helper functions for HD-audio 3 * 4 * Copyright (c) 2012 Takashi Iwai <tiwai@suse.de> 5 * 6 * This driver is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 */ 11 12 #include <linux/slab.h> 13 #include <linux/export.h> 14 #include <linux/sort.h> 15 #include <sound/core.h> 16 #include "hda_codec.h" 17 #include "hda_local.h" 18 #include "hda_auto_parser.h" 19 20 /* 21 * Helper for automatic pin configuration 22 */ 23 24 static int is_in_nid_list(hda_nid_t nid, const hda_nid_t *list) 25 { 26 for (; *list; list++) 27 if (*list == nid) 28 return 1; 29 return 0; 30 } 31 32 /* a pair of input pin and its sequence */ 33 struct auto_out_pin { 34 hda_nid_t pin; 35 short seq; 36 }; 37 38 static int compare_seq(const void *ap, const void *bp) 39 { 40 const struct auto_out_pin *a = ap; 41 const struct auto_out_pin *b = bp; 42 return (int)(a->seq - b->seq); 43 } 44 45 /* 46 * Sort an associated group of pins according to their sequence numbers. 47 * then store it to a pin array. 48 */ 49 static void sort_pins_by_sequence(hda_nid_t *pins, struct auto_out_pin *list, 50 int num_pins) 51 { 52 int i; 53 sort(list, num_pins, sizeof(list[0]), compare_seq, NULL); 54 for (i = 0; i < num_pins; i++) 55 pins[i] = list[i].pin; 56 } 57 58 59 /* add the found input-pin to the cfg->inputs[] table */ 60 static void add_auto_cfg_input_pin(struct hda_codec *codec, struct auto_pin_cfg *cfg, 61 hda_nid_t nid, int type) 62 { 63 if (cfg->num_inputs < AUTO_CFG_MAX_INS) { 64 cfg->inputs[cfg->num_inputs].pin = nid; 65 cfg->inputs[cfg->num_inputs].type = type; 66 cfg->inputs[cfg->num_inputs].has_boost_on_pin = 67 nid_has_volume(codec, nid, HDA_INPUT); 68 cfg->num_inputs++; 69 } 70 } 71 72 static int compare_input_type(const void *ap, const void *bp) 73 { 74 const struct auto_pin_cfg_item *a = ap; 75 const struct auto_pin_cfg_item *b = bp; 76 if (a->type != b->type) 77 return (int)(a->type - b->type); 78 79 /* In case one has boost and the other one has not, 80 pick the one with boost first. */ 81 return (int)(b->has_boost_on_pin - a->has_boost_on_pin); 82 } 83 84 /* Reorder the surround channels 85 * ALSA sequence is front/surr/clfe/side 86 * HDA sequence is: 87 * 4-ch: front/surr => OK as it is 88 * 6-ch: front/clfe/surr 89 * 8-ch: front/clfe/rear/side|fc 90 */ 91 static void reorder_outputs(unsigned int nums, hda_nid_t *pins) 92 { 93 hda_nid_t nid; 94 95 switch (nums) { 96 case 3: 97 case 4: 98 nid = pins[1]; 99 pins[1] = pins[2]; 100 pins[2] = nid; 101 break; 102 } 103 } 104 105 /* check whether the given pin has a proper pin I/O capability bit */ 106 static bool check_pincap_validity(struct hda_codec *codec, hda_nid_t pin, 107 unsigned int dev) 108 { 109 unsigned int pincap = snd_hda_query_pin_caps(codec, pin); 110 111 /* some old hardware don't return the proper pincaps */ 112 if (!pincap) 113 return true; 114 115 switch (dev) { 116 case AC_JACK_LINE_OUT: 117 case AC_JACK_SPEAKER: 118 case AC_JACK_HP_OUT: 119 case AC_JACK_SPDIF_OUT: 120 case AC_JACK_DIG_OTHER_OUT: 121 return !!(pincap & AC_PINCAP_OUT); 122 default: 123 return !!(pincap & AC_PINCAP_IN); 124 } 125 } 126 127 static bool can_be_headset_mic(struct hda_codec *codec, 128 struct auto_pin_cfg_item *item, 129 int seq_number) 130 { 131 int attr; 132 unsigned int def_conf; 133 if (item->type != AUTO_PIN_MIC) 134 return false; 135 136 if (item->is_headset_mic || item->is_headphone_mic) 137 return false; /* Already assigned */ 138 139 def_conf = snd_hda_codec_get_pincfg(codec, item->pin); 140 attr = snd_hda_get_input_pin_attr(def_conf); 141 if (attr <= INPUT_PIN_ATTR_DOCK) 142 return false; 143 144 if (seq_number >= 0) { 145 int seq = get_defcfg_sequence(def_conf); 146 if (seq != seq_number) 147 return false; 148 } 149 150 return true; 151 } 152 153 /* 154 * Parse all pin widgets and store the useful pin nids to cfg 155 * 156 * The number of line-outs or any primary output is stored in line_outs, 157 * and the corresponding output pins are assigned to line_out_pins[], 158 * in the order of front, rear, CLFE, side, ... 159 * 160 * If more extra outputs (speaker and headphone) are found, the pins are 161 * assisnged to hp_pins[] and speaker_pins[], respectively. If no line-out jack 162 * is detected, one of speaker of HP pins is assigned as the primary 163 * output, i.e. to line_out_pins[0]. So, line_outs is always positive 164 * if any analog output exists. 165 * 166 * The analog input pins are assigned to inputs array. 167 * The digital input/output pins are assigned to dig_in_pin and dig_out_pin, 168 * respectively. 169 */ 170 int snd_hda_parse_pin_defcfg(struct hda_codec *codec, 171 struct auto_pin_cfg *cfg, 172 const hda_nid_t *ignore_nids, 173 unsigned int cond_flags) 174 { 175 hda_nid_t nid; 176 short seq, assoc_line_out; 177 struct auto_out_pin line_out[ARRAY_SIZE(cfg->line_out_pins)]; 178 struct auto_out_pin speaker_out[ARRAY_SIZE(cfg->speaker_pins)]; 179 struct auto_out_pin hp_out[ARRAY_SIZE(cfg->hp_pins)]; 180 int i; 181 182 if (!snd_hda_get_int_hint(codec, "parser_flags", &i)) 183 cond_flags = i; 184 185 memset(cfg, 0, sizeof(*cfg)); 186 187 memset(line_out, 0, sizeof(line_out)); 188 memset(speaker_out, 0, sizeof(speaker_out)); 189 memset(hp_out, 0, sizeof(hp_out)); 190 assoc_line_out = 0; 191 192 for_each_hda_codec_node(nid, codec) { 193 unsigned int wid_caps = get_wcaps(codec, nid); 194 unsigned int wid_type = get_wcaps_type(wid_caps); 195 unsigned int def_conf; 196 short assoc, loc, conn, dev; 197 198 /* read all default configuration for pin complex */ 199 if (wid_type != AC_WID_PIN) 200 continue; 201 /* ignore the given nids (e.g. pc-beep returns error) */ 202 if (ignore_nids && is_in_nid_list(nid, ignore_nids)) 203 continue; 204 205 def_conf = snd_hda_codec_get_pincfg(codec, nid); 206 conn = get_defcfg_connect(def_conf); 207 if (conn == AC_JACK_PORT_NONE) 208 continue; 209 loc = get_defcfg_location(def_conf); 210 dev = get_defcfg_device(def_conf); 211 212 /* workaround for buggy BIOS setups */ 213 if (dev == AC_JACK_LINE_OUT) { 214 if (conn == AC_JACK_PORT_FIXED || 215 conn == AC_JACK_PORT_BOTH) 216 dev = AC_JACK_SPEAKER; 217 } 218 219 if (!check_pincap_validity(codec, nid, dev)) 220 continue; 221 222 switch (dev) { 223 case AC_JACK_LINE_OUT: 224 seq = get_defcfg_sequence(def_conf); 225 assoc = get_defcfg_association(def_conf); 226 227 if (!(wid_caps & AC_WCAP_STEREO)) 228 if (!cfg->mono_out_pin) 229 cfg->mono_out_pin = nid; 230 if (!assoc) 231 continue; 232 if (!assoc_line_out) 233 assoc_line_out = assoc; 234 else if (assoc_line_out != assoc) { 235 codec_info(codec, 236 "ignore pin 0x%x with mismatching assoc# 0x%x vs 0x%x\n", 237 nid, assoc, assoc_line_out); 238 continue; 239 } 240 if (cfg->line_outs >= ARRAY_SIZE(cfg->line_out_pins)) { 241 codec_info(codec, 242 "ignore pin 0x%x, too many assigned pins\n", 243 nid); 244 continue; 245 } 246 line_out[cfg->line_outs].pin = nid; 247 line_out[cfg->line_outs].seq = seq; 248 cfg->line_outs++; 249 break; 250 case AC_JACK_SPEAKER: 251 seq = get_defcfg_sequence(def_conf); 252 assoc = get_defcfg_association(def_conf); 253 if (cfg->speaker_outs >= ARRAY_SIZE(cfg->speaker_pins)) { 254 codec_info(codec, 255 "ignore pin 0x%x, too many assigned pins\n", 256 nid); 257 continue; 258 } 259 speaker_out[cfg->speaker_outs].pin = nid; 260 speaker_out[cfg->speaker_outs].seq = (assoc << 4) | seq; 261 cfg->speaker_outs++; 262 break; 263 case AC_JACK_HP_OUT: 264 seq = get_defcfg_sequence(def_conf); 265 assoc = get_defcfg_association(def_conf); 266 if (cfg->hp_outs >= ARRAY_SIZE(cfg->hp_pins)) { 267 codec_info(codec, 268 "ignore pin 0x%x, too many assigned pins\n", 269 nid); 270 continue; 271 } 272 hp_out[cfg->hp_outs].pin = nid; 273 hp_out[cfg->hp_outs].seq = (assoc << 4) | seq; 274 cfg->hp_outs++; 275 break; 276 case AC_JACK_MIC_IN: 277 add_auto_cfg_input_pin(codec, cfg, nid, AUTO_PIN_MIC); 278 break; 279 case AC_JACK_LINE_IN: 280 add_auto_cfg_input_pin(codec, cfg, nid, AUTO_PIN_LINE_IN); 281 break; 282 case AC_JACK_CD: 283 add_auto_cfg_input_pin(codec, cfg, nid, AUTO_PIN_CD); 284 break; 285 case AC_JACK_AUX: 286 add_auto_cfg_input_pin(codec, cfg, nid, AUTO_PIN_AUX); 287 break; 288 case AC_JACK_SPDIF_OUT: 289 case AC_JACK_DIG_OTHER_OUT: 290 if (cfg->dig_outs >= ARRAY_SIZE(cfg->dig_out_pins)) { 291 codec_info(codec, 292 "ignore pin 0x%x, too many assigned pins\n", 293 nid); 294 continue; 295 } 296 cfg->dig_out_pins[cfg->dig_outs] = nid; 297 cfg->dig_out_type[cfg->dig_outs] = 298 (loc == AC_JACK_LOC_HDMI) ? 299 HDA_PCM_TYPE_HDMI : HDA_PCM_TYPE_SPDIF; 300 cfg->dig_outs++; 301 break; 302 case AC_JACK_SPDIF_IN: 303 case AC_JACK_DIG_OTHER_IN: 304 cfg->dig_in_pin = nid; 305 if (loc == AC_JACK_LOC_HDMI) 306 cfg->dig_in_type = HDA_PCM_TYPE_HDMI; 307 else 308 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF; 309 break; 310 } 311 } 312 313 /* Find a pin that could be a headset or headphone mic */ 314 if (cond_flags & HDA_PINCFG_HEADSET_MIC || cond_flags & HDA_PINCFG_HEADPHONE_MIC) { 315 bool hsmic = !!(cond_flags & HDA_PINCFG_HEADSET_MIC); 316 bool hpmic = !!(cond_flags & HDA_PINCFG_HEADPHONE_MIC); 317 for (i = 0; (hsmic || hpmic) && (i < cfg->num_inputs); i++) 318 if (hsmic && can_be_headset_mic(codec, &cfg->inputs[i], 0xc)) { 319 cfg->inputs[i].is_headset_mic = 1; 320 hsmic = false; 321 } else if (hpmic && can_be_headset_mic(codec, &cfg->inputs[i], 0xd)) { 322 cfg->inputs[i].is_headphone_mic = 1; 323 hpmic = false; 324 } 325 326 /* If we didn't find our sequence number mark, fall back to any sequence number */ 327 for (i = 0; (hsmic || hpmic) && (i < cfg->num_inputs); i++) { 328 if (!can_be_headset_mic(codec, &cfg->inputs[i], -1)) 329 continue; 330 if (hsmic) { 331 cfg->inputs[i].is_headset_mic = 1; 332 hsmic = false; 333 } else if (hpmic) { 334 cfg->inputs[i].is_headphone_mic = 1; 335 hpmic = false; 336 } 337 } 338 339 if (hsmic) 340 codec_dbg(codec, "Told to look for a headset mic, but didn't find any.\n"); 341 if (hpmic) 342 codec_dbg(codec, "Told to look for a headphone mic, but didn't find any.\n"); 343 } 344 345 /* FIX-UP: 346 * If no line-out is defined but multiple HPs are found, 347 * some of them might be the real line-outs. 348 */ 349 if (!cfg->line_outs && cfg->hp_outs > 1 && 350 !(cond_flags & HDA_PINCFG_NO_HP_FIXUP)) { 351 int i = 0; 352 while (i < cfg->hp_outs) { 353 /* The real HPs should have the sequence 0x0f */ 354 if ((hp_out[i].seq & 0x0f) == 0x0f) { 355 i++; 356 continue; 357 } 358 /* Move it to the line-out table */ 359 line_out[cfg->line_outs++] = hp_out[i]; 360 cfg->hp_outs--; 361 memmove(hp_out + i, hp_out + i + 1, 362 sizeof(hp_out[0]) * (cfg->hp_outs - i)); 363 } 364 memset(hp_out + cfg->hp_outs, 0, 365 sizeof(hp_out[0]) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs)); 366 if (!cfg->hp_outs) 367 cfg->line_out_type = AUTO_PIN_HP_OUT; 368 369 } 370 371 /* sort by sequence */ 372 sort_pins_by_sequence(cfg->line_out_pins, line_out, cfg->line_outs); 373 sort_pins_by_sequence(cfg->speaker_pins, speaker_out, 374 cfg->speaker_outs); 375 sort_pins_by_sequence(cfg->hp_pins, hp_out, cfg->hp_outs); 376 377 /* 378 * FIX-UP: if no line-outs are detected, try to use speaker or HP pin 379 * as a primary output 380 */ 381 if (!cfg->line_outs && 382 !(cond_flags & HDA_PINCFG_NO_LO_FIXUP)) { 383 if (cfg->speaker_outs) { 384 cfg->line_outs = cfg->speaker_outs; 385 memcpy(cfg->line_out_pins, cfg->speaker_pins, 386 sizeof(cfg->speaker_pins)); 387 cfg->speaker_outs = 0; 388 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins)); 389 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT; 390 } else if (cfg->hp_outs) { 391 cfg->line_outs = cfg->hp_outs; 392 memcpy(cfg->line_out_pins, cfg->hp_pins, 393 sizeof(cfg->hp_pins)); 394 cfg->hp_outs = 0; 395 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins)); 396 cfg->line_out_type = AUTO_PIN_HP_OUT; 397 } 398 } 399 400 reorder_outputs(cfg->line_outs, cfg->line_out_pins); 401 reorder_outputs(cfg->hp_outs, cfg->hp_pins); 402 reorder_outputs(cfg->speaker_outs, cfg->speaker_pins); 403 404 /* sort inputs in the order of AUTO_PIN_* type */ 405 sort(cfg->inputs, cfg->num_inputs, sizeof(cfg->inputs[0]), 406 compare_input_type, NULL); 407 408 /* 409 * debug prints of the parsed results 410 */ 411 codec_info(codec, "autoconfig for %s: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n", 412 codec->core.chip_name, cfg->line_outs, cfg->line_out_pins[0], 413 cfg->line_out_pins[1], cfg->line_out_pins[2], 414 cfg->line_out_pins[3], cfg->line_out_pins[4], 415 cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" : 416 (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ? 417 "speaker" : "line")); 418 codec_info(codec, " speaker_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 419 cfg->speaker_outs, cfg->speaker_pins[0], 420 cfg->speaker_pins[1], cfg->speaker_pins[2], 421 cfg->speaker_pins[3], cfg->speaker_pins[4]); 422 codec_info(codec, " hp_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 423 cfg->hp_outs, cfg->hp_pins[0], 424 cfg->hp_pins[1], cfg->hp_pins[2], 425 cfg->hp_pins[3], cfg->hp_pins[4]); 426 codec_info(codec, " mono: mono_out=0x%x\n", cfg->mono_out_pin); 427 if (cfg->dig_outs) 428 codec_info(codec, " dig-out=0x%x/0x%x\n", 429 cfg->dig_out_pins[0], cfg->dig_out_pins[1]); 430 codec_info(codec, " inputs:\n"); 431 for (i = 0; i < cfg->num_inputs; i++) { 432 codec_info(codec, " %s=0x%x\n", 433 hda_get_autocfg_input_label(codec, cfg, i), 434 cfg->inputs[i].pin); 435 } 436 if (cfg->dig_in_pin) 437 codec_info(codec, " dig-in=0x%x\n", cfg->dig_in_pin); 438 439 return 0; 440 } 441 EXPORT_SYMBOL_GPL(snd_hda_parse_pin_defcfg); 442 443 /** 444 * snd_hda_get_input_pin_attr - Get the input pin attribute from pin config 445 * @def_conf: pin configuration value 446 * 447 * Guess the input pin attribute (INPUT_PIN_ATTR_XXX) from the given 448 * default pin configuration value. 449 */ 450 int snd_hda_get_input_pin_attr(unsigned int def_conf) 451 { 452 unsigned int loc = get_defcfg_location(def_conf); 453 unsigned int conn = get_defcfg_connect(def_conf); 454 if (conn == AC_JACK_PORT_NONE) 455 return INPUT_PIN_ATTR_UNUSED; 456 /* Windows may claim the internal mic to be BOTH, too */ 457 if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH) 458 return INPUT_PIN_ATTR_INT; 459 if ((loc & 0x30) == AC_JACK_LOC_INTERNAL) 460 return INPUT_PIN_ATTR_INT; 461 if ((loc & 0x30) == AC_JACK_LOC_SEPARATE) 462 return INPUT_PIN_ATTR_DOCK; 463 if (loc == AC_JACK_LOC_REAR) 464 return INPUT_PIN_ATTR_REAR; 465 if (loc == AC_JACK_LOC_FRONT) 466 return INPUT_PIN_ATTR_FRONT; 467 return INPUT_PIN_ATTR_NORMAL; 468 } 469 EXPORT_SYMBOL_GPL(snd_hda_get_input_pin_attr); 470 471 /** 472 * hda_get_input_pin_label - Give a label for the given input pin 473 * @codec: the HDA codec 474 * @item: ping config item to refer 475 * @pin: the pin NID 476 * @check_location: flag to add the jack location prefix 477 * 478 * When @check_location is true, the function checks the pin location 479 * for mic and line-in pins, and set an appropriate prefix like "Front", 480 * "Rear", "Internal". 481 */ 482 static const char *hda_get_input_pin_label(struct hda_codec *codec, 483 const struct auto_pin_cfg_item *item, 484 hda_nid_t pin, bool check_location) 485 { 486 unsigned int def_conf; 487 static const char * const mic_names[] = { 488 "Internal Mic", "Dock Mic", "Mic", "Rear Mic", "Front Mic" 489 }; 490 int attr; 491 492 def_conf = snd_hda_codec_get_pincfg(codec, pin); 493 494 switch (get_defcfg_device(def_conf)) { 495 case AC_JACK_MIC_IN: 496 if (item && item->is_headset_mic) 497 return "Headset Mic"; 498 if (item && item->is_headphone_mic) 499 return "Headphone Mic"; 500 if (!check_location) 501 return "Mic"; 502 attr = snd_hda_get_input_pin_attr(def_conf); 503 if (!attr) 504 return "None"; 505 return mic_names[attr - 1]; 506 case AC_JACK_LINE_IN: 507 if (!check_location) 508 return "Line"; 509 attr = snd_hda_get_input_pin_attr(def_conf); 510 if (!attr) 511 return "None"; 512 if (attr == INPUT_PIN_ATTR_DOCK) 513 return "Dock Line"; 514 return "Line"; 515 case AC_JACK_AUX: 516 return "Aux"; 517 case AC_JACK_CD: 518 return "CD"; 519 case AC_JACK_SPDIF_IN: 520 return "SPDIF In"; 521 case AC_JACK_DIG_OTHER_IN: 522 return "Digital In"; 523 case AC_JACK_HP_OUT: 524 return "Headphone Mic"; 525 default: 526 return "Misc"; 527 } 528 } 529 530 /* Check whether the location prefix needs to be added to the label. 531 * If all mic-jacks are in the same location (e.g. rear panel), we don't 532 * have to put "Front" prefix to each label. In such a case, returns false. 533 */ 534 static int check_mic_location_need(struct hda_codec *codec, 535 const struct auto_pin_cfg *cfg, 536 int input) 537 { 538 unsigned int defc; 539 int i, attr, attr2; 540 541 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin); 542 attr = snd_hda_get_input_pin_attr(defc); 543 /* for internal or docking mics, we need locations */ 544 if (attr <= INPUT_PIN_ATTR_NORMAL) 545 return 1; 546 547 attr = 0; 548 for (i = 0; i < cfg->num_inputs; i++) { 549 defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin); 550 attr2 = snd_hda_get_input_pin_attr(defc); 551 if (attr2 >= INPUT_PIN_ATTR_NORMAL) { 552 if (attr && attr != attr2) 553 return 1; /* different locations found */ 554 attr = attr2; 555 } 556 } 557 return 0; 558 } 559 560 /** 561 * hda_get_autocfg_input_label - Get a label for the given input 562 * @codec: the HDA codec 563 * @cfg: the parsed pin configuration 564 * @input: the input index number 565 * 566 * Get a label for the given input pin defined by the autocfg item. 567 * Unlike hda_get_input_pin_label(), this function checks all inputs 568 * defined in autocfg and avoids the redundant mic/line prefix as much as 569 * possible. 570 */ 571 const char *hda_get_autocfg_input_label(struct hda_codec *codec, 572 const struct auto_pin_cfg *cfg, 573 int input) 574 { 575 int type = cfg->inputs[input].type; 576 int has_multiple_pins = 0; 577 578 if ((input > 0 && cfg->inputs[input - 1].type == type) || 579 (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type)) 580 has_multiple_pins = 1; 581 if (has_multiple_pins && type == AUTO_PIN_MIC) 582 has_multiple_pins &= check_mic_location_need(codec, cfg, input); 583 return hda_get_input_pin_label(codec, &cfg->inputs[input], 584 cfg->inputs[input].pin, 585 has_multiple_pins); 586 } 587 EXPORT_SYMBOL_GPL(hda_get_autocfg_input_label); 588 589 /* return the position of NID in the list, or -1 if not found */ 590 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums) 591 { 592 int i; 593 for (i = 0; i < nums; i++) 594 if (list[i] == nid) 595 return i; 596 return -1; 597 } 598 599 /* get a unique suffix or an index number */ 600 static const char *check_output_sfx(hda_nid_t nid, const hda_nid_t *pins, 601 int num_pins, int *indexp) 602 { 603 static const char * const channel_sfx[] = { 604 " Front", " Surround", " CLFE", " Side" 605 }; 606 int i; 607 608 i = find_idx_in_nid_list(nid, pins, num_pins); 609 if (i < 0) 610 return NULL; 611 if (num_pins == 1) 612 return ""; 613 if (num_pins > ARRAY_SIZE(channel_sfx)) { 614 if (indexp) 615 *indexp = i; 616 return ""; 617 } 618 return channel_sfx[i]; 619 } 620 621 static const char *check_output_pfx(struct hda_codec *codec, hda_nid_t nid) 622 { 623 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid); 624 int attr = snd_hda_get_input_pin_attr(def_conf); 625 626 /* check the location */ 627 switch (attr) { 628 case INPUT_PIN_ATTR_DOCK: 629 return "Dock "; 630 case INPUT_PIN_ATTR_FRONT: 631 return "Front "; 632 } 633 return ""; 634 } 635 636 static int get_hp_label_index(struct hda_codec *codec, hda_nid_t nid, 637 const hda_nid_t *pins, int num_pins) 638 { 639 int i, j, idx = 0; 640 641 const char *pfx = check_output_pfx(codec, nid); 642 643 i = find_idx_in_nid_list(nid, pins, num_pins); 644 if (i < 0) 645 return -1; 646 for (j = 0; j < i; j++) 647 if (pfx == check_output_pfx(codec, pins[j])) 648 idx++; 649 650 return idx; 651 } 652 653 static int fill_audio_out_name(struct hda_codec *codec, hda_nid_t nid, 654 const struct auto_pin_cfg *cfg, 655 const char *name, char *label, int maxlen, 656 int *indexp) 657 { 658 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid); 659 int attr = snd_hda_get_input_pin_attr(def_conf); 660 const char *pfx, *sfx = ""; 661 662 /* handle as a speaker if it's a fixed line-out */ 663 if (!strcmp(name, "Line Out") && attr == INPUT_PIN_ATTR_INT) 664 name = "Speaker"; 665 pfx = check_output_pfx(codec, nid); 666 667 if (cfg) { 668 /* try to give a unique suffix if needed */ 669 sfx = check_output_sfx(nid, cfg->line_out_pins, cfg->line_outs, 670 indexp); 671 if (!sfx) 672 sfx = check_output_sfx(nid, cfg->speaker_pins, cfg->speaker_outs, 673 indexp); 674 if (!sfx) { 675 /* don't add channel suffix for Headphone controls */ 676 int idx = get_hp_label_index(codec, nid, cfg->hp_pins, 677 cfg->hp_outs); 678 if (idx >= 0 && indexp) 679 *indexp = idx; 680 sfx = ""; 681 } 682 } 683 snprintf(label, maxlen, "%s%s%s", pfx, name, sfx); 684 return 1; 685 } 686 687 #define is_hdmi_cfg(conf) \ 688 (get_defcfg_location(conf) == AC_JACK_LOC_HDMI) 689 690 /** 691 * snd_hda_get_pin_label - Get a label for the given I/O pin 692 * @codec: the HDA codec 693 * @nid: pin NID 694 * @cfg: the parsed pin configuration 695 * @label: the string buffer to store 696 * @maxlen: the max length of string buffer (including termination) 697 * @indexp: the pointer to return the index number (for multiple ctls) 698 * 699 * Get a label for the given pin. This function works for both input and 700 * output pins. When @cfg is given as non-NULL, the function tries to get 701 * an optimized label using hda_get_autocfg_input_label(). 702 * 703 * This function tries to give a unique label string for the pin as much as 704 * possible. For example, when the multiple line-outs are present, it adds 705 * the channel suffix like "Front", "Surround", etc (only when @cfg is given). 706 * If no unique name with a suffix is available and @indexp is non-NULL, the 707 * index number is stored in the pointer. 708 */ 709 int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid, 710 const struct auto_pin_cfg *cfg, 711 char *label, int maxlen, int *indexp) 712 { 713 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid); 714 const char *name = NULL; 715 int i; 716 bool hdmi; 717 718 if (indexp) 719 *indexp = 0; 720 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) 721 return 0; 722 723 switch (get_defcfg_device(def_conf)) { 724 case AC_JACK_LINE_OUT: 725 return fill_audio_out_name(codec, nid, cfg, "Line Out", 726 label, maxlen, indexp); 727 case AC_JACK_SPEAKER: 728 return fill_audio_out_name(codec, nid, cfg, "Speaker", 729 label, maxlen, indexp); 730 case AC_JACK_HP_OUT: 731 return fill_audio_out_name(codec, nid, cfg, "Headphone", 732 label, maxlen, indexp); 733 case AC_JACK_SPDIF_OUT: 734 case AC_JACK_DIG_OTHER_OUT: 735 hdmi = is_hdmi_cfg(def_conf); 736 name = hdmi ? "HDMI" : "SPDIF"; 737 if (cfg && indexp) 738 for (i = 0; i < cfg->dig_outs; i++) { 739 hda_nid_t pin = cfg->dig_out_pins[i]; 740 unsigned int c; 741 if (pin == nid) 742 break; 743 c = snd_hda_codec_get_pincfg(codec, pin); 744 if (hdmi == is_hdmi_cfg(c)) 745 (*indexp)++; 746 } 747 break; 748 default: 749 if (cfg) { 750 for (i = 0; i < cfg->num_inputs; i++) { 751 if (cfg->inputs[i].pin != nid) 752 continue; 753 name = hda_get_autocfg_input_label(codec, cfg, i); 754 if (name) 755 break; 756 } 757 } 758 if (!name) 759 name = hda_get_input_pin_label(codec, NULL, nid, true); 760 break; 761 } 762 if (!name) 763 return 0; 764 strlcpy(label, name, maxlen); 765 return 1; 766 } 767 EXPORT_SYMBOL_GPL(snd_hda_get_pin_label); 768 769 /** 770 * snd_hda_add_verbs - Add verbs to the init list 771 * @codec: the HDA codec 772 * @list: zero-terminated verb list to add 773 * 774 * Append the given verb list to the execution list. The verbs will be 775 * performed at init and resume time via snd_hda_apply_verbs(). 776 */ 777 int snd_hda_add_verbs(struct hda_codec *codec, 778 const struct hda_verb *list) 779 { 780 const struct hda_verb **v; 781 v = snd_array_new(&codec->verbs); 782 if (!v) 783 return -ENOMEM; 784 *v = list; 785 return 0; 786 } 787 EXPORT_SYMBOL_GPL(snd_hda_add_verbs); 788 789 /** 790 * snd_hda_apply_verbs - Execute the init verb lists 791 * @codec: the HDA codec 792 */ 793 void snd_hda_apply_verbs(struct hda_codec *codec) 794 { 795 int i; 796 for (i = 0; i < codec->verbs.used; i++) { 797 struct hda_verb **v = snd_array_elem(&codec->verbs, i); 798 snd_hda_sequence_write(codec, *v); 799 } 800 } 801 EXPORT_SYMBOL_GPL(snd_hda_apply_verbs); 802 803 /** 804 * snd_hda_apply_pincfgs - Set each pin config in the given list 805 * @codec: the HDA codec 806 * @cfg: NULL-terminated pin config table 807 */ 808 void snd_hda_apply_pincfgs(struct hda_codec *codec, 809 const struct hda_pintbl *cfg) 810 { 811 for (; cfg->nid; cfg++) 812 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val); 813 } 814 EXPORT_SYMBOL_GPL(snd_hda_apply_pincfgs); 815 816 static void set_pin_targets(struct hda_codec *codec, 817 const struct hda_pintbl *cfg) 818 { 819 for (; cfg->nid; cfg++) 820 snd_hda_set_pin_ctl_cache(codec, cfg->nid, cfg->val); 821 } 822 823 static void apply_fixup(struct hda_codec *codec, int id, int action, int depth) 824 { 825 const char *modelname = codec->fixup_name; 826 827 while (id >= 0) { 828 const struct hda_fixup *fix = codec->fixup_list + id; 829 830 if (fix->chained_before) 831 apply_fixup(codec, fix->chain_id, action, depth + 1); 832 833 switch (fix->type) { 834 case HDA_FIXUP_PINS: 835 if (action != HDA_FIXUP_ACT_PRE_PROBE || !fix->v.pins) 836 break; 837 codec_dbg(codec, "%s: Apply pincfg for %s\n", 838 codec->core.chip_name, modelname); 839 snd_hda_apply_pincfgs(codec, fix->v.pins); 840 break; 841 case HDA_FIXUP_VERBS: 842 if (action != HDA_FIXUP_ACT_PROBE || !fix->v.verbs) 843 break; 844 codec_dbg(codec, "%s: Apply fix-verbs for %s\n", 845 codec->core.chip_name, modelname); 846 snd_hda_add_verbs(codec, fix->v.verbs); 847 break; 848 case HDA_FIXUP_FUNC: 849 if (!fix->v.func) 850 break; 851 codec_dbg(codec, "%s: Apply fix-func for %s\n", 852 codec->core.chip_name, modelname); 853 fix->v.func(codec, fix, action); 854 break; 855 case HDA_FIXUP_PINCTLS: 856 if (action != HDA_FIXUP_ACT_PROBE || !fix->v.pins) 857 break; 858 codec_dbg(codec, "%s: Apply pinctl for %s\n", 859 codec->core.chip_name, modelname); 860 set_pin_targets(codec, fix->v.pins); 861 break; 862 default: 863 codec_err(codec, "%s: Invalid fixup type %d\n", 864 codec->core.chip_name, fix->type); 865 break; 866 } 867 if (!fix->chained || fix->chained_before) 868 break; 869 if (++depth > 10) 870 break; 871 id = fix->chain_id; 872 } 873 } 874 875 /** 876 * snd_hda_apply_fixup - Apply the fixup chain with the given action 877 * @codec: the HDA codec 878 * @action: fixup action (HDA_FIXUP_ACT_XXX) 879 */ 880 void snd_hda_apply_fixup(struct hda_codec *codec, int action) 881 { 882 if (codec->fixup_list) 883 apply_fixup(codec, codec->fixup_id, action, 0); 884 } 885 EXPORT_SYMBOL_GPL(snd_hda_apply_fixup); 886 887 static bool pin_config_match(struct hda_codec *codec, 888 const struct hda_pintbl *pins) 889 { 890 int i; 891 892 for (i = 0; i < codec->init_pins.used; i++) { 893 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i); 894 hda_nid_t nid = pin->nid; 895 u32 cfg = pin->cfg; 896 const struct hda_pintbl *t_pins; 897 int found; 898 899 t_pins = pins; 900 found = 0; 901 for (; t_pins->nid; t_pins++) { 902 if (t_pins->nid == nid) { 903 found = 1; 904 if (t_pins->val == cfg) 905 break; 906 else if ((cfg & 0xf0000000) == 0x40000000 && (t_pins->val & 0xf0000000) == 0x40000000) 907 break; 908 else 909 return false; 910 } 911 } 912 if (!found && (cfg & 0xf0000000) != 0x40000000) 913 return false; 914 } 915 916 return true; 917 } 918 919 /** 920 * snd_hda_pick_pin_fixup - Pick up a fixup matching with the pin quirk list 921 * @codec: the HDA codec 922 * @pin_quirk: zero-terminated pin quirk list 923 * @fixlist: the fixup list 924 */ 925 void snd_hda_pick_pin_fixup(struct hda_codec *codec, 926 const struct snd_hda_pin_quirk *pin_quirk, 927 const struct hda_fixup *fixlist) 928 { 929 const struct snd_hda_pin_quirk *pq; 930 931 if (codec->fixup_id != HDA_FIXUP_ID_NOT_SET) 932 return; 933 934 for (pq = pin_quirk; pq->subvendor; pq++) { 935 if ((codec->core.subsystem_id & 0xffff0000) != (pq->subvendor << 16)) 936 continue; 937 if (codec->core.vendor_id != pq->codec) 938 continue; 939 if (pin_config_match(codec, pq->pins)) { 940 codec->fixup_id = pq->value; 941 #ifdef CONFIG_SND_DEBUG_VERBOSE 942 codec->fixup_name = pq->name; 943 codec_dbg(codec, "%s: picked fixup %s (pin match)\n", 944 codec->core.chip_name, codec->fixup_name); 945 #endif 946 codec->fixup_list = fixlist; 947 return; 948 } 949 } 950 } 951 EXPORT_SYMBOL_GPL(snd_hda_pick_pin_fixup); 952 953 /** 954 * snd_hda_pick_fixup - Pick up a fixup matching with PCI/codec SSID or model string 955 * @codec: the HDA codec 956 * @models: NULL-terminated model string list 957 * @quirk: zero-terminated PCI/codec SSID quirk list 958 * @fixlist: the fixup list 959 * 960 * Pick up a fixup entry matching with the given model string or SSID. 961 * If a fixup was already set beforehand, the function doesn't do anything. 962 * When a special model string "nofixup" is given, also no fixup is applied. 963 * 964 * The function tries to find the matching model name at first, if given. 965 * If nothing matched, try to look up the PCI SSID. 966 * If still nothing matched, try to look up the codec SSID. 967 */ 968 void snd_hda_pick_fixup(struct hda_codec *codec, 969 const struct hda_model_fixup *models, 970 const struct snd_pci_quirk *quirk, 971 const struct hda_fixup *fixlist) 972 { 973 const struct snd_pci_quirk *q; 974 int id = HDA_FIXUP_ID_NOT_SET; 975 const char *name = NULL; 976 977 if (codec->fixup_id != HDA_FIXUP_ID_NOT_SET) 978 return; 979 980 /* when model=nofixup is given, don't pick up any fixups */ 981 if (codec->modelname && !strcmp(codec->modelname, "nofixup")) { 982 codec->fixup_list = NULL; 983 codec->fixup_name = NULL; 984 codec->fixup_id = HDA_FIXUP_ID_NO_FIXUP; 985 codec_dbg(codec, "%s: picked no fixup (nofixup specified)\n", 986 codec->core.chip_name); 987 return; 988 } 989 990 if (codec->modelname && models) { 991 while (models->name) { 992 if (!strcmp(codec->modelname, models->name)) { 993 codec->fixup_id = models->id; 994 codec->fixup_name = models->name; 995 codec->fixup_list = fixlist; 996 codec_dbg(codec, "%s: picked fixup %s (model specified)\n", 997 codec->core.chip_name, codec->fixup_name); 998 return; 999 } 1000 models++; 1001 } 1002 } 1003 if (quirk) { 1004 q = snd_pci_quirk_lookup(codec->bus->pci, quirk); 1005 if (q) { 1006 id = q->value; 1007 #ifdef CONFIG_SND_DEBUG_VERBOSE 1008 name = q->name; 1009 codec_dbg(codec, "%s: picked fixup %s (PCI SSID%s)\n", 1010 codec->core.chip_name, name, q->subdevice_mask ? "" : " - vendor generic"); 1011 #endif 1012 } 1013 } 1014 if (id < 0 && quirk) { 1015 for (q = quirk; q->subvendor || q->subdevice; q++) { 1016 unsigned int vendorid = 1017 q->subdevice | (q->subvendor << 16); 1018 unsigned int mask = 0xffff0000 | q->subdevice_mask; 1019 if ((codec->core.subsystem_id & mask) == (vendorid & mask)) { 1020 id = q->value; 1021 #ifdef CONFIG_SND_DEBUG_VERBOSE 1022 name = q->name; 1023 codec_dbg(codec, "%s: picked fixup %s (codec SSID)\n", 1024 codec->core.chip_name, name); 1025 #endif 1026 break; 1027 } 1028 } 1029 } 1030 1031 codec->fixup_id = id; 1032 if (id >= 0) { 1033 codec->fixup_list = fixlist; 1034 codec->fixup_name = name; 1035 } 1036 } 1037 EXPORT_SYMBOL_GPL(snd_hda_pick_fixup); 1038