1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Jack-detection handling for HD-audio 4 * 5 * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de> 6 */ 7 8#include <linux/init.h> 9#include <linux/slab.h> 10#include <linux/export.h> 11#include <sound/core.h> 12#include <sound/control.h> 13#include <sound/jack.h> 14#include <sound/hda_codec.h> 15#include "hda_local.h" 16#include "hda_auto_parser.h" 17#include "hda_jack.h" 18 19/** 20 * is_jack_detectable - Check whether the given pin is jack-detectable 21 * @codec: the HDA codec 22 * @nid: pin NID 23 * 24 * Check whether the given pin is capable to report the jack detection. 25 * The jack detection might not work by various reasons, e.g. the jack 26 * detection is prohibited in the codec level, the pin config has 27 * AC_DEFCFG_MISC_NO_PRESENCE bit, no unsol support, etc. 28 */ 29bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid) 30{ 31 if (codec->no_jack_detect) 32 return false; 33 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_PRES_DETECT)) 34 return false; 35 if (get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) & 36 AC_DEFCFG_MISC_NO_PRESENCE) 37 return false; 38 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) && 39 !codec->jackpoll_interval) 40 return false; 41 return true; 42} 43EXPORT_SYMBOL_GPL(is_jack_detectable); 44 45/* execute pin sense measurement */ 46static u32 read_pin_sense(struct hda_codec *codec, hda_nid_t nid, int dev_id) 47{ 48 u32 pincap; 49 u32 val; 50 51 if (!codec->no_trigger_sense) { 52 pincap = snd_hda_query_pin_caps(codec, nid); 53 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */ 54 snd_hda_codec_read(codec, nid, 0, 55 AC_VERB_SET_PIN_SENSE, 0); 56 } 57 val = snd_hda_codec_read(codec, nid, 0, 58 AC_VERB_GET_PIN_SENSE, dev_id); 59 if (codec->inv_jack_detect) 60 val ^= AC_PINSENSE_PRESENCE; 61 return val; 62} 63 64/** 65 * snd_hda_jack_tbl_get_mst - query the jack-table entry for the given NID 66 * @codec: the HDA codec 67 * @nid: pin NID to refer to 68 * @dev_id: pin device entry id 69 */ 70struct hda_jack_tbl * 71snd_hda_jack_tbl_get_mst(struct hda_codec *codec, hda_nid_t nid, int dev_id) 72{ 73 struct hda_jack_tbl *jack = codec->jacktbl.list; 74 int i; 75 76 if (!nid || !jack) 77 return NULL; 78 for (i = 0; i < codec->jacktbl.used; i++, jack++) 79 if (jack->nid == nid && jack->dev_id == dev_id) 80 return jack; 81 return NULL; 82} 83EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get_mst); 84 85/** 86 * snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag 87 * @codec: the HDA codec 88 * @tag: tag value to refer to 89 * @dev_id: pin device entry id 90 */ 91struct hda_jack_tbl * 92snd_hda_jack_tbl_get_from_tag(struct hda_codec *codec, 93 unsigned char tag, int dev_id) 94{ 95 struct hda_jack_tbl *jack = codec->jacktbl.list; 96 int i; 97 98 if (!tag || !jack) 99 return NULL; 100 for (i = 0; i < codec->jacktbl.used; i++, jack++) 101 if (jack->tag == tag && jack->dev_id == dev_id) 102 return jack; 103 return NULL; 104} 105EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get_from_tag); 106 107static struct hda_jack_tbl * 108any_jack_tbl_get_from_nid(struct hda_codec *codec, hda_nid_t nid) 109{ 110 struct hda_jack_tbl *jack = codec->jacktbl.list; 111 int i; 112 113 if (!nid || !jack) 114 return NULL; 115 for (i = 0; i < codec->jacktbl.used; i++, jack++) 116 if (jack->nid == nid) 117 return jack; 118 return NULL; 119} 120 121/** 122 * snd_hda_jack_tbl_new - create a jack-table entry for the given NID 123 * @codec: the HDA codec 124 * @nid: pin NID to assign 125 * @dev_id: pin device entry id 126 */ 127static struct hda_jack_tbl * 128snd_hda_jack_tbl_new(struct hda_codec *codec, hda_nid_t nid, int dev_id) 129{ 130 struct hda_jack_tbl *jack = 131 snd_hda_jack_tbl_get_mst(codec, nid, dev_id); 132 struct hda_jack_tbl *existing_nid_jack = 133 any_jack_tbl_get_from_nid(codec, nid); 134 135 WARN_ON(dev_id != 0 && !codec->dp_mst); 136 137 if (jack) 138 return jack; 139 jack = snd_array_new(&codec->jacktbl); 140 if (!jack) 141 return NULL; 142 jack->nid = nid; 143 jack->dev_id = dev_id; 144 jack->jack_dirty = 1; 145 if (existing_nid_jack) { 146 jack->tag = existing_nid_jack->tag; 147 148 /* 149 * Copy jack_detect from existing_nid_jack to avoid 150 * snd_hda_jack_detect_enable_callback_mst() making multiple 151 * SET_UNSOLICITED_ENABLE calls on the same pin. 152 */ 153 jack->jack_detect = existing_nid_jack->jack_detect; 154 } else { 155 jack->tag = codec->jacktbl.used; 156 } 157 158 return jack; 159} 160 161void snd_hda_jack_tbl_clear(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 struct hda_jack_callback *cb, *next; 168 169 /* free jack instances manually when clearing/reconfiguring */ 170 if (!codec->bus->shutdown && jack->jack) 171 snd_device_free(codec->card, jack->jack); 172 173 for (cb = jack->callback; cb; cb = next) { 174 next = cb->next; 175 kfree(cb); 176 } 177 } 178 snd_array_free(&codec->jacktbl); 179} 180 181#define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE) 182 183/* update the cached value and notification flag if needed */ 184static void jack_detect_update(struct hda_codec *codec, 185 struct hda_jack_tbl *jack) 186{ 187 if (!jack->jack_dirty) 188 return; 189 190 if (jack->phantom_jack) 191 jack->pin_sense = AC_PINSENSE_PRESENCE; 192 else 193 jack->pin_sense = read_pin_sense(codec, jack->nid, 194 jack->dev_id); 195 196 /* A gating jack indicates the jack is invalid if gating is unplugged */ 197 if (jack->gating_jack && 198 !snd_hda_jack_detect_mst(codec, jack->gating_jack, jack->dev_id)) 199 jack->pin_sense &= ~AC_PINSENSE_PRESENCE; 200 201 jack->jack_dirty = 0; 202 203 /* If a jack is gated by this one update it. */ 204 if (jack->gated_jack) { 205 struct hda_jack_tbl *gated = 206 snd_hda_jack_tbl_get_mst(codec, jack->gated_jack, 207 jack->dev_id); 208 if (gated) { 209 gated->jack_dirty = 1; 210 jack_detect_update(codec, gated); 211 } 212 } 213} 214 215/** 216 * snd_hda_set_dirty_all - Mark all the cached as dirty 217 * @codec: the HDA codec 218 * 219 * This function sets the dirty flag to all entries of jack table. 220 * It's called from the resume path in hda_codec.c. 221 */ 222void snd_hda_jack_set_dirty_all(struct hda_codec *codec) 223{ 224 struct hda_jack_tbl *jack = codec->jacktbl.list; 225 int i; 226 227 for (i = 0; i < codec->jacktbl.used; i++, jack++) 228 if (jack->nid) 229 jack->jack_dirty = 1; 230} 231EXPORT_SYMBOL_GPL(snd_hda_jack_set_dirty_all); 232 233/** 234 * snd_hda_jack_pin_sense - execute pin sense measurement 235 * @codec: the CODEC to sense 236 * @nid: the pin NID to sense 237 * @dev_id: pin device entry id 238 * 239 * Execute necessary pin sense measurement and return its Presence Detect, 240 * Impedance, ELD Valid etc. status bits. 241 */ 242u32 snd_hda_jack_pin_sense(struct hda_codec *codec, hda_nid_t nid, int dev_id) 243{ 244 struct hda_jack_tbl *jack = 245 snd_hda_jack_tbl_get_mst(codec, nid, dev_id); 246 if (jack) { 247 jack_detect_update(codec, jack); 248 return jack->pin_sense; 249 } 250 return read_pin_sense(codec, nid, dev_id); 251} 252EXPORT_SYMBOL_GPL(snd_hda_jack_pin_sense); 253 254/** 255 * snd_hda_jack_detect_state_mst - query pin Presence Detect status 256 * @codec: the CODEC to sense 257 * @nid: the pin NID to sense 258 * @dev_id: pin device entry id 259 * 260 * Query and return the pin's Presence Detect status, as either 261 * HDA_JACK_NOT_PRESENT, HDA_JACK_PRESENT or HDA_JACK_PHANTOM. 262 */ 263int snd_hda_jack_detect_state_mst(struct hda_codec *codec, 264 hda_nid_t nid, int dev_id) 265{ 266 struct hda_jack_tbl *jack = 267 snd_hda_jack_tbl_get_mst(codec, nid, dev_id); 268 if (jack && jack->phantom_jack) 269 return HDA_JACK_PHANTOM; 270 else if (snd_hda_jack_pin_sense(codec, nid, dev_id) & 271 AC_PINSENSE_PRESENCE) 272 return HDA_JACK_PRESENT; 273 else 274 return HDA_JACK_NOT_PRESENT; 275} 276EXPORT_SYMBOL_GPL(snd_hda_jack_detect_state_mst); 277 278static struct hda_jack_callback * 279find_callback_from_list(struct hda_jack_tbl *jack, 280 hda_jack_callback_fn func) 281{ 282 struct hda_jack_callback *cb; 283 284 if (!func) 285 return NULL; 286 287 for (cb = jack->callback; cb; cb = cb->next) { 288 if (cb->func == func) 289 return cb; 290 } 291 292 return NULL; 293} 294 295/** 296 * snd_hda_jack_detect_enable_mst - enable the jack-detection 297 * @codec: the HDA codec 298 * @nid: pin NID to enable 299 * @func: callback function to register 300 * @dev_id: pin device entry id 301 * 302 * In the case of error, the return value will be a pointer embedded with 303 * errno. Check and handle the return value appropriately with standard 304 * macros such as @IS_ERR() and @PTR_ERR(). 305 */ 306struct hda_jack_callback * 307snd_hda_jack_detect_enable_callback_mst(struct hda_codec *codec, hda_nid_t nid, 308 int dev_id, hda_jack_callback_fn func) 309{ 310 struct hda_jack_tbl *jack; 311 struct hda_jack_callback *callback = NULL; 312 int err; 313 314 jack = snd_hda_jack_tbl_new(codec, nid, dev_id); 315 if (!jack) 316 return ERR_PTR(-ENOMEM); 317 318 callback = find_callback_from_list(jack, func); 319 320 if (func && !callback) { 321 callback = kzalloc(sizeof(*callback), GFP_KERNEL); 322 if (!callback) 323 return ERR_PTR(-ENOMEM); 324 callback->func = func; 325 callback->nid = jack->nid; 326 callback->dev_id = jack->dev_id; 327 callback->next = jack->callback; 328 jack->callback = callback; 329 } 330 331 if (jack->jack_detect) 332 return callback; /* already registered */ 333 jack->jack_detect = 1; 334 if (codec->jackpoll_interval > 0) 335 return callback; /* No unsol if we're polling instead */ 336 err = snd_hda_codec_write_cache(codec, nid, 0, 337 AC_VERB_SET_UNSOLICITED_ENABLE, 338 AC_USRSP_EN | jack->tag); 339 if (err < 0) 340 return ERR_PTR(err); 341 return callback; 342} 343EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable_callback_mst); 344 345/** 346 * snd_hda_jack_detect_enable - Enable the jack detection on the given pin 347 * @codec: the HDA codec 348 * @nid: pin NID to enable jack detection 349 * @dev_id: pin device entry id 350 * 351 * Enable the jack detection with the default callback. Returns zero if 352 * successful or a negative error code. 353 */ 354int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid, 355 int dev_id) 356{ 357 return PTR_ERR_OR_ZERO(snd_hda_jack_detect_enable_callback_mst(codec, 358 nid, 359 dev_id, 360 NULL)); 361} 362EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable); 363 364/** 365 * snd_hda_jack_set_gating_jack - Set gating jack. 366 * @codec: the HDA codec 367 * @gated_nid: gated pin NID 368 * @gating_nid: gating pin NID 369 * 370 * Indicates the gated jack is only valid when the gating jack is plugged. 371 */ 372int snd_hda_jack_set_gating_jack(struct hda_codec *codec, hda_nid_t gated_nid, 373 hda_nid_t gating_nid) 374{ 375 struct hda_jack_tbl *gated = snd_hda_jack_tbl_new(codec, gated_nid, 0); 376 struct hda_jack_tbl *gating = 377 snd_hda_jack_tbl_new(codec, gating_nid, 0); 378 379 WARN_ON(codec->dp_mst); 380 381 if (!gated || !gating) 382 return -EINVAL; 383 384 gated->gating_jack = gating_nid; 385 gating->gated_jack = gated_nid; 386 387 return 0; 388} 389EXPORT_SYMBOL_GPL(snd_hda_jack_set_gating_jack); 390 391/** 392 * snd_hda_jack_report_sync - sync the states of all jacks and report if changed 393 * @codec: the HDA codec 394 */ 395void snd_hda_jack_report_sync(struct hda_codec *codec) 396{ 397 struct hda_jack_tbl *jack; 398 int i, state; 399 400 /* update all jacks at first */ 401 jack = codec->jacktbl.list; 402 for (i = 0; i < codec->jacktbl.used; i++, jack++) 403 if (jack->nid) 404 jack_detect_update(codec, jack); 405 406 /* report the updated jacks; it's done after updating all jacks 407 * to make sure that all gating jacks properly have been set 408 */ 409 jack = codec->jacktbl.list; 410 for (i = 0; i < codec->jacktbl.used; i++, jack++) 411 if (jack->nid) { 412 if (!jack->jack || jack->block_report) 413 continue; 414 state = jack->button_state; 415 if (get_jack_plug_state(jack->pin_sense)) 416 state |= jack->type; 417 snd_jack_report(jack->jack, state); 418 if (jack->button_state) { 419 snd_jack_report(jack->jack, 420 state & ~jack->button_state); 421 jack->button_state = 0; /* button released */ 422 } 423 } 424} 425EXPORT_SYMBOL_GPL(snd_hda_jack_report_sync); 426 427/* guess the jack type from the pin-config */ 428static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid) 429{ 430 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid); 431 switch (get_defcfg_device(def_conf)) { 432 case AC_JACK_LINE_OUT: 433 case AC_JACK_SPEAKER: 434 return SND_JACK_LINEOUT; 435 case AC_JACK_HP_OUT: 436 return SND_JACK_HEADPHONE; 437 case AC_JACK_SPDIF_OUT: 438 case AC_JACK_DIG_OTHER_OUT: 439 return SND_JACK_AVOUT; 440 case AC_JACK_MIC_IN: 441 return SND_JACK_MICROPHONE; 442 default: 443 return SND_JACK_LINEIN; 444 } 445} 446 447static void hda_free_jack_priv(struct snd_jack *jack) 448{ 449 struct hda_jack_tbl *jacks = jack->private_data; 450 jacks->nid = 0; 451 jacks->jack = NULL; 452} 453 454/** 455 * snd_hda_jack_add_kctl_mst - Add a kctl for the given pin 456 * @codec: the HDA codec 457 * @nid: pin NID to assign 458 * @dev_id : pin device entry id 459 * @name: string name for the jack 460 * @phantom_jack: flag to deal as a phantom jack 461 * @type: jack type bits to be reported, 0 for guessing from pincfg 462 * @keymap: optional jack / key mapping 463 * 464 * This assigns a jack-detection kctl to the given pin. The kcontrol 465 * will have the given name and index. 466 */ 467int snd_hda_jack_add_kctl_mst(struct hda_codec *codec, hda_nid_t nid, 468 int dev_id, const char *name, bool phantom_jack, 469 int type, const struct hda_jack_keymap *keymap) 470{ 471 struct hda_jack_tbl *jack; 472 const struct hda_jack_keymap *map; 473 int err, state, buttons; 474 475 jack = snd_hda_jack_tbl_new(codec, nid, dev_id); 476 if (!jack) 477 return 0; 478 if (jack->jack) 479 return 0; /* already created */ 480 481 if (!type) 482 type = get_input_jack_type(codec, nid); 483 484 buttons = 0; 485 if (keymap) { 486 for (map = keymap; map->type; map++) 487 buttons |= map->type; 488 } 489 490 err = snd_jack_new(codec->card, name, type | buttons, 491 &jack->jack, true, phantom_jack); 492 if (err < 0) 493 return err; 494 495 jack->phantom_jack = !!phantom_jack; 496 jack->type = type; 497 jack->button_state = 0; 498 jack->jack->private_data = jack; 499 jack->jack->private_free = hda_free_jack_priv; 500 if (keymap) { 501 for (map = keymap; map->type; map++) 502 snd_jack_set_key(jack->jack, map->type, map->key); 503 } 504 505 state = snd_hda_jack_detect_mst(codec, nid, dev_id); 506 snd_jack_report(jack->jack, state ? jack->type : 0); 507 508 return 0; 509} 510EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctl_mst); 511 512static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid, 513 const struct auto_pin_cfg *cfg, 514 const char *base_name) 515{ 516 unsigned int def_conf, conn; 517 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 518 int err; 519 bool phantom_jack; 520 521 WARN_ON(codec->dp_mst); 522 523 if (!nid) 524 return 0; 525 def_conf = snd_hda_codec_get_pincfg(codec, nid); 526 conn = get_defcfg_connect(def_conf); 527 if (conn == AC_JACK_PORT_NONE) 528 return 0; 529 phantom_jack = (conn != AC_JACK_PORT_COMPLEX) || 530 !is_jack_detectable(codec, nid); 531 532 if (base_name) 533 strlcpy(name, base_name, sizeof(name)); 534 else 535 snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), NULL); 536 if (phantom_jack) 537 /* Example final name: "Internal Mic Phantom Jack" */ 538 strncat(name, " Phantom", sizeof(name) - strlen(name) - 1); 539 err = snd_hda_jack_add_kctl(codec, nid, name, phantom_jack, 0, NULL); 540 if (err < 0) 541 return err; 542 543 if (!phantom_jack) 544 return snd_hda_jack_detect_enable(codec, nid, 0); 545 return 0; 546} 547 548/** 549 * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg 550 * @codec: the HDA codec 551 * @cfg: pin config table to parse 552 */ 553int snd_hda_jack_add_kctls(struct hda_codec *codec, 554 const struct auto_pin_cfg *cfg) 555{ 556 const hda_nid_t *p; 557 int i, err; 558 559 for (i = 0; i < cfg->num_inputs; i++) { 560 /* If we have headphone mics; make sure they get the right name 561 before grabbed by output pins */ 562 if (cfg->inputs[i].is_headphone_mic) { 563 if (auto_cfg_hp_outs(cfg) == 1) 564 err = add_jack_kctl(codec, auto_cfg_hp_pins(cfg)[0], 565 cfg, "Headphone Mic"); 566 else 567 err = add_jack_kctl(codec, cfg->inputs[i].pin, 568 cfg, "Headphone Mic"); 569 } else 570 err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg, 571 NULL); 572 if (err < 0) 573 return err; 574 } 575 576 for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) { 577 err = add_jack_kctl(codec, *p, cfg, NULL); 578 if (err < 0) 579 return err; 580 } 581 for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) { 582 if (*p == *cfg->line_out_pins) /* might be duplicated */ 583 break; 584 err = add_jack_kctl(codec, *p, cfg, NULL); 585 if (err < 0) 586 return err; 587 } 588 for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) { 589 if (*p == *cfg->line_out_pins) /* might be duplicated */ 590 break; 591 err = add_jack_kctl(codec, *p, cfg, NULL); 592 if (err < 0) 593 return err; 594 } 595 for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) { 596 err = add_jack_kctl(codec, *p, cfg, NULL); 597 if (err < 0) 598 return err; 599 } 600 err = add_jack_kctl(codec, cfg->dig_in_pin, cfg, NULL); 601 if (err < 0) 602 return err; 603 err = add_jack_kctl(codec, cfg->mono_out_pin, cfg, NULL); 604 if (err < 0) 605 return err; 606 return 0; 607} 608EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctls); 609 610static void call_jack_callback(struct hda_codec *codec, unsigned int res, 611 struct hda_jack_tbl *jack) 612{ 613 struct hda_jack_callback *cb; 614 615 for (cb = jack->callback; cb; cb = cb->next) { 616 cb->jack = jack; 617 cb->unsol_res = res; 618 cb->func(codec, cb); 619 } 620 if (jack->gated_jack) { 621 struct hda_jack_tbl *gated = 622 snd_hda_jack_tbl_get_mst(codec, jack->gated_jack, 623 jack->dev_id); 624 if (gated) { 625 for (cb = gated->callback; cb; cb = cb->next) { 626 cb->jack = gated; 627 cb->unsol_res = res; 628 cb->func(codec, cb); 629 } 630 } 631 } 632} 633 634/** 635 * snd_hda_jack_unsol_event - Handle an unsolicited event 636 * @codec: the HDA codec 637 * @res: the unsolicited event data 638 */ 639void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res) 640{ 641 struct hda_jack_tbl *event; 642 int tag = (res & AC_UNSOL_RES_TAG) >> AC_UNSOL_RES_TAG_SHIFT; 643 644 if (codec->dp_mst) { 645 int dev_entry = 646 (res & AC_UNSOL_RES_DE) >> AC_UNSOL_RES_DE_SHIFT; 647 648 event = snd_hda_jack_tbl_get_from_tag(codec, tag, dev_entry); 649 } else { 650 event = snd_hda_jack_tbl_get_from_tag(codec, tag, 0); 651 } 652 if (!event) 653 return; 654 event->jack_dirty = 1; 655 656 call_jack_callback(codec, res, event); 657 snd_hda_jack_report_sync(codec); 658} 659EXPORT_SYMBOL_GPL(snd_hda_jack_unsol_event); 660 661/** 662 * snd_hda_jack_poll_all - Poll all jacks 663 * @codec: the HDA codec 664 * 665 * Poll all detectable jacks with dirty flag, update the status, call 666 * callbacks and call snd_hda_jack_report_sync() if any changes are found. 667 */ 668void snd_hda_jack_poll_all(struct hda_codec *codec) 669{ 670 struct hda_jack_tbl *jack = codec->jacktbl.list; 671 int i, changes = 0; 672 673 for (i = 0; i < codec->jacktbl.used; i++, jack++) { 674 unsigned int old_sense; 675 if (!jack->nid || !jack->jack_dirty || jack->phantom_jack) 676 continue; 677 old_sense = get_jack_plug_state(jack->pin_sense); 678 jack_detect_update(codec, jack); 679 if (old_sense == get_jack_plug_state(jack->pin_sense)) 680 continue; 681 changes = 1; 682 call_jack_callback(codec, 0, jack); 683 } 684 if (changes) 685 snd_hda_jack_report_sync(codec); 686} 687EXPORT_SYMBOL_GPL(snd_hda_jack_poll_all); 688 689