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