sound/pci/hda/hda_jack.c

   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  */
  29 bool 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 }
  43 EXPORT_SYMBOL_GPL(is_jack_detectable);
  44
  45 /* execute pin sense measurement */
  46 static 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  */
  70 struct hda_jack_tbl *
  71 snd_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 }
  83 EXPORT_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  */
  91 struct hda_jack_tbl *
  92 snd_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 }
 105 EXPORT_SYMBOL_GPL(snd_hda_jack_tbl_get_from_tag);
 106
 107 static struct hda_jack_tbl *
 108 any_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  */
 127 static struct hda_jack_tbl *
 128 snd_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
 161 void 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 */
 184 static 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_jack_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  */
 222 void 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 }
 231 EXPORT_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  */
 242 u32 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 }
 252 EXPORT_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  */
 263 int 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 }
 276 EXPORT_SYMBOL_GPL(snd_hda_jack_detect_state_mst);
 277
 278 static struct hda_jack_callback *
 279 find_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_callback_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  */
 306 struct hda_jack_callback *
 307 snd_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 }
 343 EXPORT_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  */
 354 int 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 }
 362 EXPORT_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  */
 372 int 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 }
 389 EXPORT_SYMBOL_GPL(snd_hda_jack_set_gating_jack);
 390
 391 /**
 392  * snd_hda_jack_bind_keymap - bind keys generated from one NID to another jack.
 393  * @codec: the HDA codec
 394  * @key_nid: key event is generated by this pin NID
 395  * @keymap: map of key type and key code
 396  * @jack_nid: key reports to the jack of this pin NID
 397  *
 398  * This function is used in the case of key is generated from one NID while is
 399  * reported to the jack of another NID.
 400  */
 401 int snd_hda_jack_bind_keymap(struct hda_codec *codec, hda_nid_t key_nid,
 402                              const struct hda_jack_keymap *keymap,
 403                              hda_nid_t jack_nid)
 404 {
 405         const struct hda_jack_keymap *map;
 406         struct hda_jack_tbl *key_gen = snd_hda_jack_tbl_get(codec, key_nid);
 407         struct hda_jack_tbl *report_to = snd_hda_jack_tbl_get(codec, jack_nid);
 408
 409         WARN_ON(codec->dp_mst);
 410
 411         if (!key_gen || !report_to || !report_to->jack)
 412                 return -EINVAL;
 413
 414         key_gen->key_report_jack = jack_nid;
 415
 416         if (keymap)
 417                 for (map = keymap; map->type; map++)
 418                         snd_jack_set_key(report_to->jack, map->type, map->key);
 419
 420         return 0;
 421 }
 422 EXPORT_SYMBOL_GPL(snd_hda_jack_bind_keymap);
 423
 424 /**
 425  * snd_hda_jack_set_button_state - report button event to the hda_jack_tbl button_state.
 426  * @codec: the HDA codec
 427  * @jack_nid: the button event reports to the jack_tbl of this NID
 428  * @button_state: the button event captured by codec
 429  *
 430  * Codec driver calls this function to report the button event.
 431  */
 432 void snd_hda_jack_set_button_state(struct hda_codec *codec, hda_nid_t jack_nid,
 433                                    int button_state)
 434 {
 435         struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, jack_nid);
 436
 437         if (!jack)
 438                 return;
 439
 440         if (jack->key_report_jack) {
 441                 struct hda_jack_tbl *report_to =
 442                         snd_hda_jack_tbl_get(codec, jack->key_report_jack);
 443
 444                 if (report_to) {
 445                         report_to->button_state = button_state;
 446                         return;
 447                 }
 448         }
 449
 450         jack->button_state = button_state;
 451 }
 452 EXPORT_SYMBOL_GPL(snd_hda_jack_set_button_state);
 453
 454 /**
 455  * snd_hda_jack_report_sync - sync the states of all jacks and report if changed
 456  * @codec: the HDA codec
 457  */
 458 void snd_hda_jack_report_sync(struct hda_codec *codec)
 459 {
 460         struct hda_jack_tbl *jack;
 461         int i, state;
 462
 463         /* update all jacks at first */
 464         jack = codec->jacktbl.list;
 465         for (i = 0; i < codec->jacktbl.used; i++, jack++)
 466                 if (jack->nid)
 467                         jack_detect_update(codec, jack);
 468
 469         /* report the updated jacks; it's done after updating all jacks
 470          * to make sure that all gating jacks properly have been set
 471          */
 472         jack = codec->jacktbl.list;
 473         for (i = 0; i < codec->jacktbl.used; i++, jack++)
 474                 if (jack->nid) {
 475                         if (!jack->jack || jack->block_report)
 476                                 continue;
 477                         state = jack->button_state;
 478                         if (get_jack_plug_state(jack->pin_sense))
 479                                 state |= jack->type;
 480                         snd_jack_report(jack->jack, state);
 481                         if (jack->button_state) {
 482                                 snd_jack_report(jack->jack,
 483                                                 state & ~jack->button_state);
 484                                 jack->button_state = 0; /* button released */
 485                         }
 486                 }
 487 }
 488 EXPORT_SYMBOL_GPL(snd_hda_jack_report_sync);
 489
 490 /* guess the jack type from the pin-config */
 491 static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid)
 492 {
 493         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
 494         switch (get_defcfg_device(def_conf)) {
 495         case AC_JACK_LINE_OUT:
 496         case AC_JACK_SPEAKER:
 497                 return SND_JACK_LINEOUT;
 498         case AC_JACK_HP_OUT:
 499                 return SND_JACK_HEADPHONE;
 500         case AC_JACK_SPDIF_OUT:
 501         case AC_JACK_DIG_OTHER_OUT:
 502                 return SND_JACK_AVOUT;
 503         case AC_JACK_MIC_IN:
 504                 return SND_JACK_MICROPHONE;
 505         default:
 506                 return SND_JACK_LINEIN;
 507         }
 508 }
 509
 510 static void hda_free_jack_priv(struct snd_jack *jack)
 511 {
 512         struct hda_jack_tbl *jacks = jack->private_data;
 513         jacks->nid = 0;
 514         jacks->jack = NULL;
 515 }
 516
 517 /**
 518  * snd_hda_jack_add_kctl_mst - Add a kctl for the given pin
 519  * @codec: the HDA codec
 520  * @nid: pin NID to assign
 521  * @dev_id : pin device entry id
 522  * @name: string name for the jack
 523  * @phantom_jack: flag to deal as a phantom jack
 524  * @type: jack type bits to be reported, 0 for guessing from pincfg
 525  * @keymap: optional jack / key mapping
 526  *
 527  * This assigns a jack-detection kctl to the given pin.  The kcontrol
 528  * will have the given name and index.
 529  */
 530 int snd_hda_jack_add_kctl_mst(struct hda_codec *codec, hda_nid_t nid,
 531                               int dev_id, const char *name, bool phantom_jack,
 532                               int type, const struct hda_jack_keymap *keymap)
 533 {
 534         struct hda_jack_tbl *jack;
 535         const struct hda_jack_keymap *map;
 536         int err, state, buttons;
 537
 538         jack = snd_hda_jack_tbl_new(codec, nid, dev_id);
 539         if (!jack)
 540                 return 0;
 541         if (jack->jack)
 542                 return 0; /* already created */
 543
 544         if (!type)
 545                 type = get_input_jack_type(codec, nid);
 546
 547         buttons = 0;
 548         if (keymap) {
 549                 for (map = keymap; map->type; map++)
 550                         buttons |= map->type;
 551         }
 552
 553         err = snd_jack_new(codec->card, name, type | buttons,
 554                            &jack->jack, true, phantom_jack);
 555         if (err < 0)
 556                 return err;
 557
 558         jack->phantom_jack = !!phantom_jack;
 559         jack->type = type;
 560         jack->button_state = 0;
 561         jack->jack->private_data = jack;
 562         jack->jack->private_free = hda_free_jack_priv;
 563         if (keymap) {
 564                 for (map = keymap; map->type; map++)
 565                         snd_jack_set_key(jack->jack, map->type, map->key);
 566         }
 567
 568         state = snd_hda_jack_detect_mst(codec, nid, dev_id);
 569         snd_jack_report(jack->jack, state ? jack->type : 0);
 570
 571         return 0;
 572 }
 573 EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctl_mst);
 574
 575 static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
 576                          const struct auto_pin_cfg *cfg,
 577                          const char *base_name)
 578 {
 579         unsigned int def_conf, conn;
 580         char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
 581         int err;
 582         bool phantom_jack;
 583
 584         WARN_ON(codec->dp_mst);
 585
 586         if (!nid)
 587                 return 0;
 588         def_conf = snd_hda_codec_get_pincfg(codec, nid);
 589         conn = get_defcfg_connect(def_conf);
 590         if (conn == AC_JACK_PORT_NONE)
 591                 return 0;
 592         phantom_jack = (conn != AC_JACK_PORT_COMPLEX) ||
 593                        !is_jack_detectable(codec, nid);
 594
 595         if (base_name)
 596                 strscpy(name, base_name, sizeof(name));
 597         else
 598                 snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), NULL);
 599         if (phantom_jack)
 600                 /* Example final name: "Internal Mic Phantom Jack" */
 601                 strncat(name, " Phantom", sizeof(name) - strlen(name) - 1);
 602         err = snd_hda_jack_add_kctl(codec, nid, name, phantom_jack, 0, NULL);
 603         if (err < 0)
 604                 return err;
 605
 606         if (!phantom_jack)
 607                 return snd_hda_jack_detect_enable(codec, nid, 0);
 608         return 0;
 609 }
 610
 611 /**
 612  * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
 613  * @codec: the HDA codec
 614  * @cfg: pin config table to parse
 615  */
 616 int snd_hda_jack_add_kctls(struct hda_codec *codec,
 617                            const struct auto_pin_cfg *cfg)
 618 {
 619         const hda_nid_t *p;
 620         int i, err;
 621
 622         for (i = 0; i < cfg->num_inputs; i++) {
 623                 /* If we have headphone mics; make sure they get the right name
 624                    before grabbed by output pins */
 625                 if (cfg->inputs[i].is_headphone_mic) {
 626                         if (auto_cfg_hp_outs(cfg) == 1)
 627                                 err = add_jack_kctl(codec, auto_cfg_hp_pins(cfg)[0],
 628                                                     cfg, "Headphone Mic");
 629                         else
 630                                 err = add_jack_kctl(codec, cfg->inputs[i].pin,
 631                                                     cfg, "Headphone Mic");
 632                 } else
 633                         err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg,
 634                                             NULL);
 635                 if (err < 0)
 636                         return err;
 637         }
 638
 639         for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
 640                 err = add_jack_kctl(codec, *p, cfg, NULL);
 641                 if (err < 0)
 642                         return err;
 643         }
 644         for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) {
 645                 if (*p == *cfg->line_out_pins) /* might be duplicated */
 646                         break;
 647                 err = add_jack_kctl(codec, *p, cfg, NULL);
 648                 if (err < 0)
 649                         return err;
 650         }
 651         for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) {
 652                 if (*p == *cfg->line_out_pins) /* might be duplicated */
 653                         break;
 654                 err = add_jack_kctl(codec, *p, cfg, NULL);
 655                 if (err < 0)
 656                         return err;
 657         }
 658         for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
 659                 err = add_jack_kctl(codec, *p, cfg, NULL);
 660                 if (err < 0)
 661                         return err;
 662         }
 663         err = add_jack_kctl(codec, cfg->dig_in_pin, cfg, NULL);
 664         if (err < 0)
 665                 return err;
 666         err = add_jack_kctl(codec, cfg->mono_out_pin, cfg, NULL);
 667         if (err < 0)
 668                 return err;
 669         return 0;
 670 }
 671 EXPORT_SYMBOL_GPL(snd_hda_jack_add_kctls);
 672
 673 static void call_jack_callback(struct hda_codec *codec, unsigned int res,
 674                                struct hda_jack_tbl *jack)
 675 {
 676         struct hda_jack_callback *cb;
 677
 678         for (cb = jack->callback; cb; cb = cb->next) {
 679                 cb->jack = jack;
 680                 cb->unsol_res = res;
 681                 cb->func(codec, cb);
 682         }
 683         if (jack->gated_jack) {
 684                 struct hda_jack_tbl *gated =
 685                         snd_hda_jack_tbl_get_mst(codec, jack->gated_jack,
 686                                                  jack->dev_id);
 687                 if (gated) {
 688                         for (cb = gated->callback; cb; cb = cb->next) {
 689                                 cb->jack = gated;
 690                                 cb->unsol_res = res;
 691                                 cb->func(codec, cb);
 692                         }
 693                 }
 694         }
 695 }
 696
 697 /**
 698  * snd_hda_jack_unsol_event - Handle an unsolicited event
 699  * @codec: the HDA codec
 700  * @res: the unsolicited event data
 701  */
 702 void snd_hda_jack_unsol_event(struct hda_codec *codec, unsigned int res)
 703 {
 704         struct hda_jack_tbl *event;
 705         int tag = (res & AC_UNSOL_RES_TAG) >> AC_UNSOL_RES_TAG_SHIFT;
 706
 707         if (codec->dp_mst) {
 708                 int dev_entry =
 709                         (res & AC_UNSOL_RES_DE) >> AC_UNSOL_RES_DE_SHIFT;
 710
 711                 event = snd_hda_jack_tbl_get_from_tag(codec, tag, dev_entry);
 712         } else {
 713                 event = snd_hda_jack_tbl_get_from_tag(codec, tag, 0);
 714         }
 715         if (!event)
 716                 return;
 717
 718         if (event->key_report_jack) {
 719                 struct hda_jack_tbl *report_to =
 720                         snd_hda_jack_tbl_get_mst(codec, event->key_report_jack,
 721                                                  event->dev_id);
 722                 if (report_to)
 723                         report_to->jack_dirty = 1;
 724         } else
 725                 event->jack_dirty = 1;
 726
 727         call_jack_callback(codec, res, event);
 728         snd_hda_jack_report_sync(codec);
 729 }
 730 EXPORT_SYMBOL_GPL(snd_hda_jack_unsol_event);
 731
 732 /**
 733  * snd_hda_jack_poll_all - Poll all jacks
 734  * @codec: the HDA codec
 735  *
 736  * Poll all detectable jacks with dirty flag, update the status, call
 737  * callbacks and call snd_hda_jack_report_sync() if any changes are found.
 738  */
 739 void snd_hda_jack_poll_all(struct hda_codec *codec)
 740 {
 741         struct hda_jack_tbl *jack = codec->jacktbl.list;
 742         int i, changes = 0;
 743
 744         for (i = 0; i < codec->jacktbl.used; i++, jack++) {
 745                 unsigned int old_sense;
 746                 if (!jack->nid || !jack->jack_dirty || jack->phantom_jack)
 747                         continue;
 748                 old_sense = get_jack_plug_state(jack->pin_sense);
 749                 jack_detect_update(codec, jack);
 750                 if (old_sense == get_jack_plug_state(jack->pin_sense))
 751                         continue;
 752                 changes = 1;
 753                 call_jack_callback(codec, 0, jack);
 754         }
 755         if (changes)
 756                 snd_hda_jack_report_sync(codec);
 757 }
 758 EXPORT_SYMBOL_GPL(snd_hda_jack_poll_all);
 759