771 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Jack-detection handling for HD-audio4 *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-detectable21 * @codec: the HDA codec22 * @nid: pin NID23 *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 jack26 * detection is prohibited in the codec level, the pin config has27 * 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 NID66 * @codec: the HDA codec67 * @nid: pin NID to refer to68 * @dev_id: pin device entry id69 */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 tag87 * @codec: the HDA codec88 * @tag: tag value to refer to89 * @dev_id: pin device entry id90 */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 NID123 * @codec: the HDA codec124 * @nid: pin NID to assign125 * @dev_id: pin device entry id126 */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 avoid150 * snd_hda_jack_detect_enable_callback_mst() making multiple151 * 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_disconnect(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 (!codec->bus->shutdown && jack->jack)168 snd_device_disconnect(codec->card, jack->jack);169 }170}171 172void snd_hda_jack_tbl_clear(struct hda_codec *codec)173{174 struct hda_jack_tbl *jack = codec->jacktbl.list;175 int i;176 177 for (i = 0; i < codec->jacktbl.used; i++, jack++) {178 struct hda_jack_callback *cb, *next;179 180 /* free jack instances manually when clearing/reconfiguring */181 if (!codec->bus->shutdown && jack->jack)182 snd_device_free(codec->card, jack->jack);183 184 for (cb = jack->callback; cb; cb = next) {185 next = cb->next;186 kfree(cb);187 }188 }189 snd_array_free(&codec->jacktbl);190}191 192#define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE)193 194/* update the cached value and notification flag if needed */195static void jack_detect_update(struct hda_codec *codec,196 struct hda_jack_tbl *jack)197{198 if (!jack->jack_dirty)199 return;200 201 if (jack->phantom_jack)202 jack->pin_sense = AC_PINSENSE_PRESENCE;203 else204 jack->pin_sense = read_pin_sense(codec, jack->nid,205 jack->dev_id);206 207 /* A gating jack indicates the jack is invalid if gating is unplugged */208 if (jack->gating_jack &&209 !snd_hda_jack_detect_mst(codec, jack->gating_jack, jack->dev_id))210 jack->pin_sense &= ~AC_PINSENSE_PRESENCE;211 212 jack->jack_dirty = 0;213 214 /* If a jack is gated by this one update it. */215 if (jack->gated_jack) {216 struct hda_jack_tbl *gated =217 snd_hda_jack_tbl_get_mst(codec, jack->gated_jack,218 jack->dev_id);219 if (gated) {220 gated->jack_dirty = 1;221 jack_detect_update(codec, gated);222 }223 }224}225 226/**227 * snd_hda_jack_set_dirty_all - Mark all the cached as dirty228 * @codec: the HDA codec229 *230 * This function sets the dirty flag to all entries of jack table.231 * It's called from the resume path in hda_codec.c.232 */233void snd_hda_jack_set_dirty_all(struct hda_codec *codec)234{235 struct hda_jack_tbl *jack = codec->jacktbl.list;236 int i;237 238 for (i = 0; i < codec->jacktbl.used; i++, jack++)239 if (jack->nid)240 jack->jack_dirty = 1;241}242EXPORT_SYMBOL_GPL(snd_hda_jack_set_dirty_all);243 244/**245 * snd_hda_jack_pin_sense - execute pin sense measurement246 * @codec: the CODEC to sense247 * @nid: the pin NID to sense248 * @dev_id: pin device entry id249 *250 * Execute necessary pin sense measurement and return its Presence Detect,251 * Impedance, ELD Valid etc. status bits.252 */253u32 snd_hda_jack_pin_sense(struct hda_codec *codec, hda_nid_t nid, int dev_id)254{255 struct hda_jack_tbl *jack =256 snd_hda_jack_tbl_get_mst(codec, nid, dev_id);257 if (jack) {258 jack_detect_update(codec, jack);259 return jack->pin_sense;260 }261 return read_pin_sense(codec, nid, dev_id);262}263EXPORT_SYMBOL_GPL(snd_hda_jack_pin_sense);264 265/**266 * snd_hda_jack_detect_state_mst - query pin Presence Detect status267 * @codec: the CODEC to sense268 * @nid: the pin NID to sense269 * @dev_id: pin device entry id270 *271 * Query and return the pin's Presence Detect status, as either272 * HDA_JACK_NOT_PRESENT, HDA_JACK_PRESENT or HDA_JACK_PHANTOM.273 */274int snd_hda_jack_detect_state_mst(struct hda_codec *codec,275 hda_nid_t nid, int dev_id)276{277 struct hda_jack_tbl *jack =278 snd_hda_jack_tbl_get_mst(codec, nid, dev_id);279 if (jack && jack->phantom_jack)280 return HDA_JACK_PHANTOM;281 else if (snd_hda_jack_pin_sense(codec, nid, dev_id) &282 AC_PINSENSE_PRESENCE)283 return HDA_JACK_PRESENT;284 else285 return HDA_JACK_NOT_PRESENT;286}287EXPORT_SYMBOL_GPL(snd_hda_jack_detect_state_mst);288 289static struct hda_jack_callback *290find_callback_from_list(struct hda_jack_tbl *jack,291 hda_jack_callback_fn func)292{293 struct hda_jack_callback *cb;294 295 if (!func)296 return NULL;297 298 for (cb = jack->callback; cb; cb = cb->next) {299 if (cb->func == func)300 return cb;301 }302 303 return NULL;304}305 306/**307 * snd_hda_jack_detect_enable_callback_mst - enable the jack-detection308 * @codec: the HDA codec309 * @nid: pin NID to enable310 * @func: callback function to register311 * @dev_id: pin device entry id312 *313 * In the case of error, the return value will be a pointer embedded with314 * errno. Check and handle the return value appropriately with standard315 * macros such as @IS_ERR() and @PTR_ERR().316 */317struct hda_jack_callback *318snd_hda_jack_detect_enable_callback_mst(struct hda_codec *codec, hda_nid_t nid,319 int dev_id, hda_jack_callback_fn func)320{321 struct hda_jack_tbl *jack;322 struct hda_jack_callback *callback = NULL;323 int err;324 325 jack = snd_hda_jack_tbl_new(codec, nid, dev_id);326 if (!jack)327 return ERR_PTR(-ENOMEM);328 329 callback = find_callback_from_list(jack, func);330 331 if (func && !callback) {332 callback = kzalloc(sizeof(*callback), GFP_KERNEL);333 if (!callback)334 return ERR_PTR(-ENOMEM);335 callback->func = func;336 callback->nid = jack->nid;337 callback->dev_id = jack->dev_id;338 callback->next = jack->callback;339 jack->callback = callback;340 }341 342 if (jack->jack_detect)343 return callback; /* already registered */344 jack->jack_detect = 1;345 if (codec->jackpoll_interval > 0)346 return callback; /* No unsol if we're polling instead */347 err = snd_hda_codec_write_cache(codec, nid, 0,348 AC_VERB_SET_UNSOLICITED_ENABLE,349 AC_USRSP_EN | jack->tag);350 if (err < 0)351 return ERR_PTR(err);352 return callback;353}354EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable_callback_mst);355 356/**357 * snd_hda_jack_detect_enable - Enable the jack detection on the given pin358 * @codec: the HDA codec359 * @nid: pin NID to enable jack detection360 * @dev_id: pin device entry id361 *362 * Enable the jack detection with the default callback. Returns zero if363 * successful or a negative error code.364 */365int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid,366 int dev_id)367{368 return PTR_ERR_OR_ZERO(snd_hda_jack_detect_enable_callback_mst(codec,369 nid,370 dev_id,371 NULL));372}373EXPORT_SYMBOL_GPL(snd_hda_jack_detect_enable);374 375/**376 * snd_hda_jack_set_gating_jack - Set gating jack.377 * @codec: the HDA codec378 * @gated_nid: gated pin NID379 * @gating_nid: gating pin NID380 *381 * Indicates the gated jack is only valid when the gating jack is plugged.382 */383int snd_hda_jack_set_gating_jack(struct hda_codec *codec, hda_nid_t gated_nid,384 hda_nid_t gating_nid)385{386 struct hda_jack_tbl *gated = snd_hda_jack_tbl_new(codec, gated_nid, 0);387 struct hda_jack_tbl *gating =388 snd_hda_jack_tbl_new(codec, gating_nid, 0);389 390 WARN_ON(codec->dp_mst);391 392 if (!gated || !gating)393 return -EINVAL;394 395 gated->gating_jack = gating_nid;396 gating->gated_jack = gated_nid;397 398 return 0;399}400EXPORT_SYMBOL_GPL(snd_hda_jack_set_gating_jack);401 402/**403 * snd_hda_jack_bind_keymap - bind keys generated from one NID to another jack.404 * @codec: the HDA codec405 * @key_nid: key event is generated by this pin NID406 * @keymap: map of key type and key code407 * @jack_nid: key reports to the jack of this pin NID408 *409 * This function is used in the case of key is generated from one NID while is410 * reported to the jack of another NID.411 */412int snd_hda_jack_bind_keymap(struct hda_codec *codec, hda_nid_t key_nid,413 const struct hda_jack_keymap *keymap,414 hda_nid_t jack_nid)415{416 const struct hda_jack_keymap *map;417 struct hda_jack_tbl *key_gen = snd_hda_jack_tbl_get(codec, key_nid);418 struct hda_jack_tbl *report_to = snd_hda_jack_tbl_get(codec, jack_nid);419 420 WARN_ON(codec->dp_mst);421 422 if (!key_gen || !report_to || !report_to->jack)423 return -EINVAL;424 425 key_gen->key_report_jack = jack_nid;426 427 if (keymap)428 for (map = keymap; map->type; map++)429 snd_jack_set_key(report_to->jack, map->type, map->key);430 431 return 0;432}433EXPORT_SYMBOL_GPL(snd_hda_jack_bind_keymap);434 435/**436 * snd_hda_jack_set_button_state - report button event to the hda_jack_tbl button_state.437 * @codec: the HDA codec438 * @jack_nid: the button event reports to the jack_tbl of this NID439 * @button_state: the button event captured by codec440 *441 * Codec driver calls this function to report the button event.442 */443void snd_hda_jack_set_button_state(struct hda_codec *codec, hda_nid_t jack_nid,444 int button_state)445{446 struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, jack_nid);447 448 if (!jack)449 return;450 451 if (jack->key_report_jack) {452 struct hda_jack_tbl *report_to =453 snd_hda_jack_tbl_get(codec, jack->key_report_jack);454 455 if (report_to) {456 report_to->button_state = button_state;457 return;458 }459 }460 461 jack->button_state = button_state;462}463EXPORT_SYMBOL_GPL(snd_hda_jack_set_button_state);464 465/**466 * snd_hda_jack_report_sync - sync the states of all jacks and report if changed467 * @codec: the HDA codec468 */469void snd_hda_jack_report_sync(struct hda_codec *codec)470{471 struct hda_jack_tbl *jack;472 int i, state;473 474 /* update all jacks at first */475 jack = codec->jacktbl.list;476 for (i = 0; i < codec->jacktbl.used; i++, jack++)477 if (jack->nid)478 jack_detect_update(codec, jack);479 480 /* report the updated jacks; it's done after updating all jacks481 * to make sure that all gating jacks properly have been set482 */483 jack = codec->jacktbl.list;484 for (i = 0; i < codec->jacktbl.used; i++, jack++)485 if (jack->nid) {486 if (!jack->jack || jack->block_report)487 continue;488 state = jack->button_state;489 if (get_jack_plug_state(jack->pin_sense))490 state |= jack->type;491 snd_jack_report(jack->jack, state);492 if (jack->button_state) {493 snd_jack_report(jack->jack,494 state & ~jack->button_state);495 jack->button_state = 0; /* button released */496 }497 }498}499EXPORT_SYMBOL_GPL(snd_hda_jack_report_sync);500 501/* guess the jack type from the pin-config */502static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid)503{504 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);505 switch (get_defcfg_device(def_conf)) {506 case AC_JACK_LINE_OUT:507 case AC_JACK_SPEAKER:508 return SND_JACK_LINEOUT;509 case AC_JACK_HP_OUT:510 return SND_JACK_HEADPHONE;511 case AC_JACK_SPDIF_OUT:512 case AC_JACK_DIG_OTHER_OUT:513 return SND_JACK_AVOUT;514 case AC_JACK_MIC_IN:515 return SND_JACK_MICROPHONE;516 default:517 return SND_JACK_LINEIN;518 }519}520 521static void hda_free_jack_priv(struct snd_jack *jack)522{523 struct hda_jack_tbl *jacks = jack->private_data;524 jacks->nid = 0;525 jacks->jack = NULL;526}527 528/**529 * snd_hda_jack_add_kctl_mst - Add a kctl for the given pin530 * @codec: the HDA codec531 * @nid: pin NID to assign532 * @dev_id : pin device entry id533 * @name: string name for the jack534 * @phantom_jack: flag to deal as a phantom jack535 * @type: jack type bits to be reported, 0 for guessing from pincfg536 * @keymap: optional jack / key mapping537 *538 * This assigns a jack-detection kctl to the given pin. The kcontrol539 * will have the given name and index.540 */541int snd_hda_jack_add_kctl_mst(struct hda_codec *codec, hda_nid_t nid,542 int dev_id, const char *name, bool phantom_jack,543 int type, const struct hda_jack_keymap *keymap)544{545 struct hda_jack_tbl *jack;546 const struct hda_jack_keymap *map;547 int err, state, buttons;548 549 jack = snd_hda_jack_tbl_new(codec, nid, dev_id);550 if (!jack)551 return 0;552 if (jack->jack)553 return 0; /* already created */554 555 if (!type)556 type = get_input_jack_type(codec, nid);557 558 buttons = 0;559 if (keymap) {560 for (map = keymap; map->type; map++)561 buttons |= map->type;562 }563 564 err = snd_jack_new(codec->card, name, type | buttons,565 &jack->jack, true, phantom_jack);566 if (err < 0)567 return err;568 569 jack->phantom_jack = !!phantom_jack;570 jack->type = type;571 jack->button_state = 0;572 jack->jack->private_data = jack;573 jack->jack->private_free = hda_free_jack_priv;574 if (keymap) {575 for (map = keymap; map->type; map++)576 snd_jack_set_key(jack->jack, map->type, map->key);577 }578 579 state = snd_hda_jack_detect_mst(codec, nid, dev_id);580 snd_jack_report(jack->jack, state ? jack->type : 0);581 582 return 0;583}584EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctl_mst);585 586static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,587 const struct auto_pin_cfg *cfg,588 const char *base_name)589{590 unsigned int def_conf, conn;591 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];592 int err;593 bool phantom_jack;594 595 WARN_ON(codec->dp_mst);596 597 if (!nid)598 return 0;599 def_conf = snd_hda_codec_get_pincfg(codec, nid);600 conn = get_defcfg_connect(def_conf);601 if (conn == AC_JACK_PORT_NONE)602 return 0;603 phantom_jack = (conn != AC_JACK_PORT_COMPLEX) ||604 !is_jack_detectable(codec, nid);605 606 if (base_name)607 strscpy(name, base_name, sizeof(name));608 else609 snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), NULL);610 if (phantom_jack)611 /* Example final name: "Internal Mic Phantom Jack" */612 strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);613 err = snd_hda_jack_add_kctl(codec, nid, name, phantom_jack, 0, NULL);614 if (err < 0)615 return err;616 617 if (!phantom_jack)618 return snd_hda_jack_detect_enable(codec, nid, 0);619 return 0;620}621 622/**623 * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg624 * @codec: the HDA codec625 * @cfg: pin config table to parse626 */627int snd_hda_jack_add_kctls(struct hda_codec *codec,628 const struct auto_pin_cfg *cfg)629{630 const hda_nid_t *p;631 int i, err;632 633 for (i = 0; i < cfg->num_inputs; i++) {634 /* If we have headphone mics; make sure they get the right name635 before grabbed by output pins */636 if (cfg->inputs[i].is_headphone_mic) {637 if (auto_cfg_hp_outs(cfg) == 1)638 err = add_jack_kctl(codec, auto_cfg_hp_pins(cfg)[0],639 cfg, "Headphone Mic");640 else641 err = add_jack_kctl(codec, cfg->inputs[i].pin,642 cfg, "Headphone Mic");643 } else644 err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg,645 NULL);646 if (err < 0)647 return err;648 }649 650 for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {651 err = add_jack_kctl(codec, *p, cfg, NULL);652 if (err < 0)653 return err;654 }655 for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) {656 if (*p == *cfg->line_out_pins) /* might be duplicated */657 break;658 err = add_jack_kctl(codec, *p, cfg, NULL);659 if (err < 0)660 return err;661 }662 for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) {663 if (*p == *cfg->line_out_pins) /* might be duplicated */664 break;665 err = add_jack_kctl(codec, *p, cfg, NULL);666 if (err < 0)667 return err;668 }669 for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {670 err = add_jack_kctl(codec, *p, cfg, NULL);671 if (err < 0)672 return err;673 }674 err = add_jack_kctl(codec, cfg->dig_in_pin, cfg, NULL);675 if (err < 0)676 return err;677 err = add_jack_kctl(codec, cfg->mono_out_pin, cfg, NULL);678 if (err < 0)679 return err;680 return 0;681}682EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctls);683 684static void call_jack_callback(struct hda_codec *codec, unsigned int res,685 struct hda_jack_tbl *jack)686{687 struct hda_jack_callback *cb;688 689 for (cb = jack->callback; cb; cb = cb->next) {690 cb->jack = jack;691 cb->unsol_res = res;692 cb->func(codec, cb);693 }694 if (jack->gated_jack) {695 struct hda_jack_tbl *gated =696 snd_hda_jack_tbl_get_mst(codec, jack->gated_jack,697 jack->dev_id);698 if (gated) {699 for (cb = gated->callback; cb; cb = cb->next) {700 cb->jack = gated;701 cb->unsol_res = res;702 cb->func(codec, cb);703 }704 }705 }706}707 708/**709 * snd_hda_jack_unsol_event - Handle an unsolicited event710 * @codec: the HDA codec711 * @res: the unsolicited event data712 */713void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res)714{715 struct hda_jack_tbl *event;716 int tag = (res & AC_UNSOL_RES_TAG) >> AC_UNSOL_RES_TAG_SHIFT;717 718 if (codec->dp_mst) {719 int dev_entry =720 (res & AC_UNSOL_RES_DE) >> AC_UNSOL_RES_DE_SHIFT;721 722 event = snd_hda_jack_tbl_get_from_tag(codec, tag, dev_entry);723 } else {724 event = snd_hda_jack_tbl_get_from_tag(codec, tag, 0);725 }726 if (!event)727 return;728 729 if (event->key_report_jack) {730 struct hda_jack_tbl *report_to =731 snd_hda_jack_tbl_get_mst(codec, event->key_report_jack,732 event->dev_id);733 if (report_to)734 report_to->jack_dirty = 1;735 } else736 event->jack_dirty = 1;737 738 call_jack_callback(codec, res, event);739 snd_hda_jack_report_sync(codec);740}741EXPORT_SYMBOL_GPL(snd_hda_jack_unsol_event);742 743/**744 * snd_hda_jack_poll_all - Poll all jacks745 * @codec: the HDA codec746 *747 * Poll all detectable jacks with dirty flag, update the status, call748 * callbacks and call snd_hda_jack_report_sync() if any changes are found.749 */750void snd_hda_jack_poll_all(struct hda_codec *codec)751{752 struct hda_jack_tbl *jack = codec->jacktbl.list;753 int i, changes = 0;754 755 for (i = 0; i < codec->jacktbl.used; i++, jack++) {756 unsigned int old_sense;757 if (!jack->nid || !jack->jack_dirty || jack->phantom_jack)758 continue;759 old_sense = get_jack_plug_state(jack->pin_sense);760 jack_detect_update(codec, jack);761 if (old_sense == get_jack_plug_state(jack->pin_sense))762 continue;763 changes = 1;764 call_jack_callback(codec, 0, jack);765 }766 if (changes)767 snd_hda_jack_report_sync(codec);768}769EXPORT_SYMBOL_GPL(snd_hda_jack_poll_all);770 771