1 /* 2 * Jack-detection handling for HD-audio 3 * 4 * Copyright (c) 2011 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/init.h> 13 #include <linux/slab.h> 14 #include <linux/export.h> 15 #include <sound/core.h> 16 #include <sound/control.h> 17 #include <sound/jack.h> 18 #include "hda_codec.h" 19 #include "hda_local.h" 20 #include "hda_auto_parser.h" 21 #include "hda_jack.h" 22 23 bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid) 24 { 25 if (codec->no_jack_detect) 26 return false; 27 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_PRES_DETECT)) 28 return false; 29 if (get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) & 30 AC_DEFCFG_MISC_NO_PRESENCE) 31 return false; 32 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) && 33 !codec->jackpoll_interval) 34 return false; 35 return true; 36 } 37 EXPORT_SYMBOL_GPL(is_jack_detectable); 38 39 /* execute pin sense measurement */ 40 static u32 read_pin_sense(struct hda_codec *codec, hda_nid_t nid) 41 { 42 u32 pincap; 43 u32 val; 44 45 if (!codec->no_trigger_sense) { 46 pincap = snd_hda_query_pin_caps(codec, nid); 47 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */ 48 snd_hda_codec_read(codec, nid, 0, 49 AC_VERB_SET_PIN_SENSE, 0); 50 } 51 val = snd_hda_codec_read(codec, nid, 0, 52 AC_VERB_GET_PIN_SENSE, 0); 53 if (codec->inv_jack_detect) 54 val ^= AC_PINSENSE_PRESENCE; 55 return val; 56 } 57 58 /** 59 * snd_hda_jack_tbl_get - query the jack-table entry for the given NID 60 */ 61 struct hda_jack_tbl * 62 snd_hda_jack_tbl_get(struct hda_codec *codec, hda_nid_t nid) 63 { 64 struct hda_jack_tbl *jack = codec->jacktbl.list; 65 int i; 66 67 if (!nid || !jack) 68 return NULL; 69 for (i = 0; i < codec->jacktbl.used; i++, jack++) 70 if (jack->nid == nid) 71 return jack; 72 return NULL; 73 } 74 EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get); 75 76 /** 77 * snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag 78 */ 79 struct hda_jack_tbl * 80 snd_hda_jack_tbl_get_from_tag(struct hda_codec *codec, unsigned char tag) 81 { 82 struct hda_jack_tbl *jack = codec->jacktbl.list; 83 int i; 84 85 if (!tag || !jack) 86 return NULL; 87 for (i = 0; i < codec->jacktbl.used; i++, jack++) 88 if (jack->tag == tag) 89 return jack; 90 return NULL; 91 } 92 EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get_from_tag); 93 94 /** 95 * snd_hda_jack_tbl_new - create a jack-table entry for the given NID 96 */ 97 static struct hda_jack_tbl * 98 snd_hda_jack_tbl_new(struct hda_codec *codec, hda_nid_t nid) 99 { 100 struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid); 101 if (jack) 102 return jack; 103 jack = snd_array_new(&codec->jacktbl); 104 if (!jack) 105 return NULL; 106 jack->nid = nid; 107 jack->jack_dirty = 1; 108 jack->tag = codec->jacktbl.used; 109 return jack; 110 } 111 112 void snd_hda_jack_tbl_clear(struct hda_codec *codec) 113 { 114 struct hda_jack_tbl *jack = codec->jacktbl.list; 115 int i; 116 117 for (i = 0; i < codec->jacktbl.used; i++, jack++) { 118 struct hda_jack_callback *cb, *next; 119 #ifdef CONFIG_SND_HDA_INPUT_JACK 120 /* free jack instances manually when clearing/reconfiguring */ 121 if (!codec->bus->shutdown && jack->jack) 122 snd_device_free(codec->bus->card, jack->jack); 123 #endif 124 for (cb = jack->callback; cb; cb = next) { 125 next = cb->next; 126 kfree(cb); 127 } 128 } 129 snd_array_free(&codec->jacktbl); 130 } 131 132 #define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE) 133 134 /* update the cached value and notification flag if needed */ 135 static void jack_detect_update(struct hda_codec *codec, 136 struct hda_jack_tbl *jack) 137 { 138 if (!jack->jack_dirty) 139 return; 140 141 if (jack->phantom_jack) 142 jack->pin_sense = AC_PINSENSE_PRESENCE; 143 else 144 jack->pin_sense = read_pin_sense(codec, jack->nid); 145 146 /* A gating jack indicates the jack is invalid if gating is unplugged */ 147 if (jack->gating_jack && !snd_hda_jack_detect(codec, jack->gating_jack)) 148 jack->pin_sense &= ~AC_PINSENSE_PRESENCE; 149 150 jack->jack_dirty = 0; 151 152 /* If a jack is gated by this one update it. */ 153 if (jack->gated_jack) { 154 struct hda_jack_tbl *gated = 155 snd_hda_jack_tbl_get(codec, jack->gated_jack); 156 if (gated) { 157 gated->jack_dirty = 1; 158 jack_detect_update(codec, gated); 159 } 160 } 161 } 162 163 /** 164 * snd_hda_set_dirty_all - Mark all the cached as dirty 165 * 166 * This function sets the dirty flag to all entries of jack table. 167 * It's called from the resume path in hda_codec.c. 168 */ 169 void snd_hda_jack_set_dirty_all(struct hda_codec *codec) 170 { 171 struct hda_jack_tbl *jack = codec->jacktbl.list; 172 int i; 173 174 for (i = 0; i < codec->jacktbl.used; i++, jack++) 175 if (jack->nid) 176 jack->jack_dirty = 1; 177 } 178 EXPORT_SYMBOL_GPL(snd_hda_jack_set_dirty_all); 179 180 /** 181 * snd_hda_pin_sense - execute pin sense measurement 182 * @codec: the CODEC to sense 183 * @nid: the pin NID to sense 184 * 185 * Execute necessary pin sense measurement and return its Presence Detect, 186 * Impedance, ELD Valid etc. status bits. 187 */ 188 u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid) 189 { 190 struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid); 191 if (jack) { 192 jack_detect_update(codec, jack); 193 return jack->pin_sense; 194 } 195 return read_pin_sense(codec, nid); 196 } 197 EXPORT_SYMBOL_GPL(snd_hda_pin_sense); 198 199 /** 200 * snd_hda_jack_detect_state - query pin Presence Detect status 201 * @codec: the CODEC to sense 202 * @nid: the pin NID to sense 203 * 204 * Query and return the pin's Presence Detect status, as either 205 * HDA_JACK_NOT_PRESENT, HDA_JACK_PRESENT or HDA_JACK_PHANTOM. 206 */ 207 int snd_hda_jack_detect_state(struct hda_codec *codec, hda_nid_t nid) 208 { 209 struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid); 210 if (jack && jack->phantom_jack) 211 return HDA_JACK_PHANTOM; 212 else if (snd_hda_pin_sense(codec, nid) & AC_PINSENSE_PRESENCE) 213 return HDA_JACK_PRESENT; 214 else 215 return HDA_JACK_NOT_PRESENT; 216 } 217 EXPORT_SYMBOL_GPL(snd_hda_jack_detect_state); 218 219 /** 220 * snd_hda_jack_detect_enable - enable the jack-detection 221 * 222 * In the case of error, the return value will be a pointer embedded with 223 * errno. Check and handle the return value appropriately with standard 224 * macros such as @IS_ERR() and @PTR_ERR(). 225 */ 226 struct hda_jack_callback * 227 snd_hda_jack_detect_enable_callback(struct hda_codec *codec, hda_nid_t nid, 228 hda_jack_callback_fn func) 229 { 230 struct hda_jack_tbl *jack; 231 struct hda_jack_callback *callback = NULL; 232 int err; 233 234 jack = snd_hda_jack_tbl_new(codec, nid); 235 if (!jack) 236 return ERR_PTR(-ENOMEM); 237 if (func) { 238 callback = kzalloc(sizeof(*callback), GFP_KERNEL); 239 if (!callback) 240 return ERR_PTR(-ENOMEM); 241 callback->func = func; 242 callback->tbl = jack; 243 callback->next = jack->callback; 244 jack->callback = callback; 245 } 246 247 if (jack->jack_detect) 248 return callback; /* already registered */ 249 jack->jack_detect = 1; 250 if (codec->jackpoll_interval > 0) 251 return callback; /* No unsol if we're polling instead */ 252 err = snd_hda_codec_write_cache(codec, nid, 0, 253 AC_VERB_SET_UNSOLICITED_ENABLE, 254 AC_USRSP_EN | jack->tag); 255 if (err < 0) 256 return ERR_PTR(err); 257 return callback; 258 } 259 EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable_callback); 260 261 int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid) 262 { 263 return PTR_ERR_OR_ZERO(snd_hda_jack_detect_enable_callback(codec, nid, NULL)); 264 } 265 EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable); 266 267 /** 268 * snd_hda_jack_set_gating_jack - Set gating jack. 269 * 270 * Indicates the gated jack is only valid when the gating jack is plugged. 271 */ 272 int snd_hda_jack_set_gating_jack(struct hda_codec *codec, hda_nid_t gated_nid, 273 hda_nid_t gating_nid) 274 { 275 struct hda_jack_tbl *gated = snd_hda_jack_tbl_new(codec, gated_nid); 276 struct hda_jack_tbl *gating = snd_hda_jack_tbl_new(codec, gating_nid); 277 278 if (!gated || !gating) 279 return -EINVAL; 280 281 gated->gating_jack = gating_nid; 282 gating->gated_jack = gated_nid; 283 284 return 0; 285 } 286 EXPORT_SYMBOL_GPL(snd_hda_jack_set_gating_jack); 287 288 /** 289 * snd_hda_jack_report_sync - sync the states of all jacks and report if changed 290 */ 291 void snd_hda_jack_report_sync(struct hda_codec *codec) 292 { 293 struct hda_jack_tbl *jack; 294 int i, state; 295 296 /* update all jacks at first */ 297 jack = codec->jacktbl.list; 298 for (i = 0; i < codec->jacktbl.used; i++, jack++) 299 if (jack->nid) 300 jack_detect_update(codec, jack); 301 302 /* report the updated jacks; it's done after updating all jacks 303 * to make sure that all gating jacks properly have been set 304 */ 305 jack = codec->jacktbl.list; 306 for (i = 0; i < codec->jacktbl.used; i++, jack++) 307 if (jack->nid) { 308 if (!jack->kctl || jack->block_report) 309 continue; 310 state = get_jack_plug_state(jack->pin_sense); 311 snd_kctl_jack_report(codec->bus->card, jack->kctl, state); 312 #ifdef CONFIG_SND_HDA_INPUT_JACK 313 if (jack->jack) 314 snd_jack_report(jack->jack, 315 state ? jack->type : 0); 316 #endif 317 } 318 } 319 EXPORT_SYMBOL_GPL(snd_hda_jack_report_sync); 320 321 #ifdef CONFIG_SND_HDA_INPUT_JACK 322 /* guess the jack type from the pin-config */ 323 static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid) 324 { 325 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid); 326 switch (get_defcfg_device(def_conf)) { 327 case AC_JACK_LINE_OUT: 328 case AC_JACK_SPEAKER: 329 return SND_JACK_LINEOUT; 330 case AC_JACK_HP_OUT: 331 return SND_JACK_HEADPHONE; 332 case AC_JACK_SPDIF_OUT: 333 case AC_JACK_DIG_OTHER_OUT: 334 return SND_JACK_AVOUT; 335 case AC_JACK_MIC_IN: 336 return SND_JACK_MICROPHONE; 337 default: 338 return SND_JACK_LINEIN; 339 } 340 } 341 342 static void hda_free_jack_priv(struct snd_jack *jack) 343 { 344 struct hda_jack_tbl *jacks = jack->private_data; 345 jacks->nid = 0; 346 jacks->jack = NULL; 347 } 348 #endif 349 350 /** 351 * snd_hda_jack_add_kctl - Add a kctl for the given pin 352 * 353 * This assigns a jack-detection kctl to the given pin. The kcontrol 354 * will have the given name and index. 355 */ 356 static int __snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid, 357 const char *name, int idx, bool phantom_jack) 358 { 359 struct hda_jack_tbl *jack; 360 struct snd_kcontrol *kctl; 361 int err, state; 362 363 jack = snd_hda_jack_tbl_new(codec, nid); 364 if (!jack) 365 return 0; 366 if (jack->kctl) 367 return 0; /* already created */ 368 kctl = snd_kctl_jack_new(name, idx, codec); 369 if (!kctl) 370 return -ENOMEM; 371 err = snd_hda_ctl_add(codec, nid, kctl); 372 if (err < 0) 373 return err; 374 jack->kctl = kctl; 375 jack->phantom_jack = !!phantom_jack; 376 377 state = snd_hda_jack_detect(codec, nid); 378 snd_kctl_jack_report(codec->bus->card, kctl, state); 379 #ifdef CONFIG_SND_HDA_INPUT_JACK 380 if (!phantom_jack) { 381 jack->type = get_input_jack_type(codec, nid); 382 err = snd_jack_new(codec->bus->card, name, jack->type, 383 &jack->jack); 384 if (err < 0) 385 return err; 386 jack->jack->private_data = jack; 387 jack->jack->private_free = hda_free_jack_priv; 388 snd_jack_report(jack->jack, state ? jack->type : 0); 389 } 390 #endif 391 return 0; 392 } 393 394 int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid, 395 const char *name, int idx) 396 { 397 return __snd_hda_jack_add_kctl(codec, nid, name, idx, false); 398 } 399 EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctl); 400 401 /* get the unique index number for the given kctl name */ 402 static int get_unique_index(struct hda_codec *codec, const char *name, int idx) 403 { 404 struct hda_jack_tbl *jack; 405 int i, len = strlen(name); 406 again: 407 jack = codec->jacktbl.list; 408 for (i = 0; i < codec->jacktbl.used; i++, jack++) { 409 /* jack->kctl.id contains "XXX Jack" name string with index */ 410 if (jack->kctl && 411 !strncmp(name, jack->kctl->id.name, len) && 412 !strcmp(" Jack", jack->kctl->id.name + len) && 413 jack->kctl->id.index == idx) { 414 idx++; 415 goto again; 416 } 417 } 418 return idx; 419 } 420 421 static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid, 422 const struct auto_pin_cfg *cfg, 423 const char *base_name) 424 { 425 unsigned int def_conf, conn; 426 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 427 int idx, err; 428 bool phantom_jack; 429 430 if (!nid) 431 return 0; 432 def_conf = snd_hda_codec_get_pincfg(codec, nid); 433 conn = get_defcfg_connect(def_conf); 434 if (conn == AC_JACK_PORT_NONE) 435 return 0; 436 phantom_jack = (conn != AC_JACK_PORT_COMPLEX) || 437 !is_jack_detectable(codec, nid); 438 439 if (base_name) { 440 strlcpy(name, base_name, sizeof(name)); 441 idx = 0; 442 } else 443 snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), &idx); 444 if (phantom_jack) 445 /* Example final name: "Internal Mic Phantom Jack" */ 446 strncat(name, " Phantom", sizeof(name) - strlen(name) - 1); 447 idx = get_unique_index(codec, name, idx); 448 err = __snd_hda_jack_add_kctl(codec, nid, name, idx, phantom_jack); 449 if (err < 0) 450 return err; 451 452 if (!phantom_jack) 453 return snd_hda_jack_detect_enable(codec, nid); 454 return 0; 455 } 456 457 /** 458 * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg 459 */ 460 int snd_hda_jack_add_kctls(struct hda_codec *codec, 461 const struct auto_pin_cfg *cfg) 462 { 463 const hda_nid_t *p; 464 int i, err; 465 466 for (i = 0; i < cfg->num_inputs; i++) { 467 /* If we have headphone mics; make sure they get the right name 468 before grabbed by output pins */ 469 if (cfg->inputs[i].is_headphone_mic) { 470 if (auto_cfg_hp_outs(cfg) == 1) 471 err = add_jack_kctl(codec, auto_cfg_hp_pins(cfg)[0], 472 cfg, "Headphone Mic"); 473 else 474 err = add_jack_kctl(codec, cfg->inputs[i].pin, 475 cfg, "Headphone Mic"); 476 } else 477 err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg, 478 NULL); 479 if (err < 0) 480 return err; 481 } 482 483 for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) { 484 err = add_jack_kctl(codec, *p, cfg, NULL); 485 if (err < 0) 486 return err; 487 } 488 for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) { 489 if (*p == *cfg->line_out_pins) /* might be duplicated */ 490 break; 491 err = add_jack_kctl(codec, *p, cfg, NULL); 492 if (err < 0) 493 return err; 494 } 495 for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) { 496 if (*p == *cfg->line_out_pins) /* might be duplicated */ 497 break; 498 err = add_jack_kctl(codec, *p, cfg, NULL); 499 if (err < 0) 500 return err; 501 } 502 for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) { 503 err = add_jack_kctl(codec, *p, cfg, NULL); 504 if (err < 0) 505 return err; 506 } 507 err = add_jack_kctl(codec, cfg->dig_in_pin, cfg, NULL); 508 if (err < 0) 509 return err; 510 err = add_jack_kctl(codec, cfg->mono_out_pin, cfg, NULL); 511 if (err < 0) 512 return err; 513 return 0; 514 } 515 EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctls); 516 517 static void call_jack_callback(struct hda_codec *codec, 518 struct hda_jack_tbl *jack) 519 { 520 struct hda_jack_callback *cb; 521 522 for (cb = jack->callback; cb; cb = cb->next) 523 cb->func(codec, cb); 524 if (jack->gated_jack) { 525 struct hda_jack_tbl *gated = 526 snd_hda_jack_tbl_get(codec, jack->gated_jack); 527 if (gated) { 528 for (cb = gated->callback; cb; cb = cb->next) 529 cb->func(codec, cb); 530 } 531 } 532 } 533 534 void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res) 535 { 536 struct hda_jack_tbl *event; 537 int tag = (res >> AC_UNSOL_RES_TAG_SHIFT) & 0x7f; 538 539 event = snd_hda_jack_tbl_get_from_tag(codec, tag); 540 if (!event) 541 return; 542 event->jack_dirty = 1; 543 544 call_jack_callback(codec, event); 545 snd_hda_jack_report_sync(codec); 546 } 547 EXPORT_SYMBOL_GPL(snd_hda_jack_unsol_event); 548 549 void snd_hda_jack_poll_all(struct hda_codec *codec) 550 { 551 struct hda_jack_tbl *jack = codec->jacktbl.list; 552 int i, changes = 0; 553 554 for (i = 0; i < codec->jacktbl.used; i++, jack++) { 555 unsigned int old_sense; 556 if (!jack->nid || !jack->jack_dirty || jack->phantom_jack) 557 continue; 558 old_sense = get_jack_plug_state(jack->pin_sense); 559 jack_detect_update(codec, jack); 560 if (old_sense == get_jack_plug_state(jack->pin_sense)) 561 continue; 562 changes = 1; 563 call_jack_callback(codec, jack); 564 } 565 if (changes) 566 snd_hda_jack_report_sync(codec); 567 } 568 EXPORT_SYMBOL_GPL(snd_hda_jack_poll_all); 569 570