sound/pci/hda/hda_jack.c

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