Merge branch 'test/hda-jack' into topic/hda

Conflicts:
	sound/pci/hda/patch_hdmi.c
	sound/pci/hda/patch_via.c

19 files changed, 834 insertions, 495 deletions

diff --git a/include/sound/control.h b/include/sound/control.h
index 1a94a216ed99..b2796e83c7ac 100644
--- a/include/sound/control.h
+++ b/include/sound/control.h
@@ -227,4 +227,12 @@ snd_ctl_add_slave_uncached(struct snd_kcontrol *master,
         return _snd_ctl_add_slave(master, slave, SND_CTL_SLAVE_NEED_UPDATE);
 }
 
+/*
+ * Helper functions for jack-detection controls
+ */
+struct snd_kcontrol *
+snd_kctl_jack_new(const char *name, int idx, void *private_data);
+void snd_kctl_jack_report(struct snd_card *card,
+                          struct snd_kcontrol *kctl, bool status);
+
 #endif  /* __SOUND_CONTROL_H */
diff --git a/sound/core/Kconfig b/sound/core/Kconfig
index 475455c76610..66f287f2f759 100644
--- a/sound/core/Kconfig
+++ b/sound/core/Kconfig
@@ -207,6 +207,9 @@ config SND_PCM_XRUN_DEBUG
 config SND_VMASTER
         bool
 
+config SND_KCTL_JACK
+        bool
+
 config SND_DMA_SGBUF
         def_bool y
         depends on X86
diff --git a/sound/core/Makefile b/sound/core/Makefile
index 350a08d277f4..b4637c3e776e 100644
--- a/sound/core/Makefile
+++ b/sound/core/Makefile
@@ -7,6 +7,7 @@ snd-y     := sound.o init.o memory.o info.o control.o misc.o device.o
 snd-$(CONFIG_ISA_DMA_API) += isadma.o
 snd-$(CONFIG_SND_OSSEMUL) += sound_oss.o info_oss.o
 snd-$(CONFIG_SND_VMASTER) += vmaster.o
+snd-$(CONFIG_SND_KCTL_JACK) += ctljack.o
 snd-$(CONFIG_SND_JACK)    += jack.o
 
 snd-pcm-objs := pcm.o pcm_native.o pcm_lib.o pcm_timer.o pcm_misc.o \
diff --git a/sound/core/ctljack.c b/sound/core/ctljack.c
new file mode 100644
index 000000000000..e4b38fbe51da
--- /dev/null
+++ b/sound/core/ctljack.c
@@ -0,0 +1,56 @@
+/*
+ * Helper functions for jack-detection kcontrols
+ *
+ * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/export.h>
+#include <sound/core.h>
+#include <sound/control.h>
+
+#define jack_detect_kctl_info   snd_ctl_boolean_mono_info
+
+static int jack_detect_kctl_get(struct snd_kcontrol *kcontrol,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+        ucontrol->value.integer.value[0] = kcontrol->private_value;
+        return 0;
+}
+
+static struct snd_kcontrol_new jack_detect_kctl = {
+        /* name is filled later */
+        .iface = SNDRV_CTL_ELEM_IFACE_CARD,
+        .access = SNDRV_CTL_ELEM_ACCESS_READ,
+        .info = jack_detect_kctl_info,
+        .get = jack_detect_kctl_get,
+};
+
+struct snd_kcontrol *
+snd_kctl_jack_new(const char *name, int idx, void *private_data)
+{
+        struct snd_kcontrol *kctl;
+        kctl = snd_ctl_new1(&jack_detect_kctl, private_data);
+        if (!kctl)
+                return NULL;
+        snprintf(kctl->id.name, sizeof(kctl->id.name), "%s Jack", name);
+        kctl->id.index = idx;
+        kctl->private_value = 0;
+        return kctl;
+}
+EXPORT_SYMBOL_GPL(snd_kctl_jack_new);
+
+void snd_kctl_jack_report(struct snd_card *card,
+                          struct snd_kcontrol *kctl, bool status)
+{
+        if (kctl->private_value == status)
+                return;
+        kctl->private_value = status;
+        snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
+}
+EXPORT_SYMBOL_GPL(snd_kctl_jack_report);
diff --git a/sound/pci/hda/Kconfig b/sound/pci/hda/Kconfig
index bb7e102d6726..163b6b5de3eb 100644
--- a/sound/pci/hda/Kconfig
+++ b/sound/pci/hda/Kconfig
@@ -2,6 +2,7 @@ menuconfig SND_HDA_INTEL
         tristate "Intel HD Audio"
         select SND_PCM
         select SND_VMASTER
+        select SND_KCTL_JACK
         help
           Say Y here to include support for Intel "High Definition
           Audio" (Azalia) and its compatible devices.
diff --git a/sound/pci/hda/Makefile b/sound/pci/hda/Makefile
index f928d6634723..ace157cc3d15 100644
--- a/sound/pci/hda/Makefile
+++ b/sound/pci/hda/Makefile
@@ -1,6 +1,6 @@
 snd-hda-intel-objs := hda_intel.o
 
-snd-hda-codec-y := hda_codec.o
+snd-hda-codec-y := hda_codec.o hda_jack.o
 snd-hda-codec-$(CONFIG_SND_HDA_GENERIC) += hda_generic.o
 snd-hda-codec-$(CONFIG_PROC_FS) += hda_proc.o
 snd-hda-codec-$(CONFIG_SND_HDA_HWDEP) += hda_hwdep.o
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index 4463f9a9619a..4df72c0e8c37 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -33,6 +33,7 @@
 #include <sound/jack.h>
 #include "hda_local.h"
 #include "hda_beep.h"
+#include "hda_jack.h"
 #include <sound/hda_hwdep.h>
 
 #define CREATE_TRACE_POINTS
@@ -1723,43 +1724,6 @@ int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
 }
 EXPORT_SYMBOL_HDA(snd_hda_override_pin_caps);
 
-/**
- * snd_hda_pin_sense - execute pin sense measurement
- * @codec: the CODEC to sense
- * @nid: the pin NID to sense
- *
- * Execute necessary pin sense measurement and return its Presence Detect,
- * Impedance, ELD Valid etc. status bits.
- */
-u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
-{
-        u32 pincap;
-
-        if (!codec->no_trigger_sense) {
-                pincap = snd_hda_query_pin_caps(codec, nid);
-                if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
-                        snd_hda_codec_read(codec, nid, 0,
-                                        AC_VERB_SET_PIN_SENSE, 0);
-        }
-        return snd_hda_codec_read(codec, nid, 0,
-                                  AC_VERB_GET_PIN_SENSE, 0);
-}
-EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
-
-/**
- * snd_hda_jack_detect - query pin Presence Detect status
- * @codec: the CODEC to sense
- * @nid: the pin NID to sense
- *
- * Query and return the pin's Presence Detect status.
- */
-int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
-{
-        u32 sense = snd_hda_pin_sense(codec, nid);
-        return !!(sense & AC_PINSENSE_PRESENCE);
-}
-EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
-
 /*
  * read the current volume to info
  * if the cache exists, read the cache value.
@@ -2308,6 +2272,7 @@ int snd_hda_codec_reset(struct hda_codec *codec)
         }
         if (codec->patch_ops.free)
                 codec->patch_ops.free(codec);
+        snd_hda_jack_tbl_clear(codec);
         codec->proc_widget_hook = NULL;
         codec->spec = NULL;
         free_hda_cache(&codec->amp_cache);
@@ -3364,6 +3329,7 @@ static void hda_call_codec_resume(struct hda_codec *codec)
         restore_pincfgs(codec); /* restore all current pin configs */
         restore_shutup_pins(codec);
         hda_exec_init_verbs(codec);
+        snd_hda_jack_set_dirty_all(codec);
         if (codec->patch_ops.resume)
                 codec->patch_ops.resume(codec);
         else {
@@ -5010,8 +4976,8 @@ EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr);
  * "Rear", "Internal".
  */
 
-const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin,
-                                        int check_location)
+static const char *hda_get_input_pin_label(struct hda_codec *codec,
+                                           hda_nid_t pin, bool check_location)
 {
         unsigned int def_conf;
         static const char * const mic_names[] = {
@@ -5050,7 +5016,6 @@ const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin,
                 return "Misc";
         }
 }
-EXPORT_SYMBOL_HDA(hda_get_input_pin_label);
 
 /* Check whether the location prefix needs to be added to the label.
  * If all mic-jacks are in the same location (e.g. rear panel), we don't
@@ -5107,6 +5072,149 @@ const char *hda_get_autocfg_input_label(struct hda_codec *codec,
 }
 EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label);
 
+/* return the position of NID in the list, or -1 if not found */
+static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
+{
+        int i;
+        for (i = 0; i < nums; i++)
+                if (list[i] == nid)
+                        return i;
+        return -1;
+}
+
+/* get a unique suffix or an index number */
+static const char *check_output_sfx(hda_nid_t nid, const hda_nid_t *pins,
+                                    int num_pins, int *indexp)
+{
+        static const char * const channel_sfx[] = {
+                " Front", " Surround", " CLFE", " Side"
+        };
+        int i;
+
+        i = find_idx_in_nid_list(nid, pins, num_pins);
+        if (i < 0)
+                return NULL;
+        if (num_pins == 1)
+                return "";
+        if (num_pins > ARRAY_SIZE(channel_sfx)) {
+                if (indexp)
+                        *indexp = i;
+                return "";
+        }
+        return channel_sfx[i];
+}
+
+static int fill_audio_out_name(struct hda_codec *codec, hda_nid_t nid,
+                               const struct auto_pin_cfg *cfg,
+                               const char *name, char *label, int maxlen,
+                               int *indexp)
+{
+        unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
+        int attr = snd_hda_get_input_pin_attr(def_conf);
+        const char *pfx = "", *sfx = "";
+
+        /* handle as a speaker if it's a fixed line-out */
+        if (!strcmp(name, "Line-Out") && attr == INPUT_PIN_ATTR_INT)
+                name = "Speaker";
+        /* check the location */
+        switch (attr) {
+        case INPUT_PIN_ATTR_DOCK:
+                pfx = "Dock ";
+                break;
+        case INPUT_PIN_ATTR_FRONT:
+                pfx = "Front ";
+                break;
+        }
+        if (cfg) {
+                /* try to give a unique suffix if needed */
+                sfx = check_output_sfx(nid, cfg->line_out_pins, cfg->line_outs,
+                                       indexp);
+                if (!sfx)
+                        sfx = check_output_sfx(nid, cfg->speaker_pins, cfg->speaker_outs,
+                                               indexp);
+                if (!sfx) {
+                        /* don't add channel suffix for Headphone controls */
+                        int idx = find_idx_in_nid_list(nid, cfg->hp_pins,
+                                                       cfg->hp_outs);
+                        if (idx >= 0)
+                                *indexp = idx;
+                        sfx = "";
+                }
+        }
+        snprintf(label, maxlen, "%s%s%s", pfx, name, sfx);
+        return 1;
+}
+
+/**
+ * snd_hda_get_pin_label - Get a label for the given I/O pin
+ *
+ * Get a label for the given pin.  This function works for both input and
+ * output pins.  When @cfg is given as non-NULL, the function tries to get
+ * an optimized label using hda_get_autocfg_input_label().
+ *
+ * This function tries to give a unique label string for the pin as much as
+ * possible.  For example, when the multiple line-outs are present, it adds
+ * the channel suffix like "Front", "Surround", etc (only when @cfg is given).
+ * If no unique name with a suffix is available and @indexp is non-NULL, the
+ * index number is stored in the pointer.
+ */
+int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid,
+                          const struct auto_pin_cfg *cfg,
+                          char *label, int maxlen, int *indexp)
+{
+        unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
+        const char *name = NULL;
+        int i;
+
+        if (indexp)
+                *indexp = 0;
+        if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
+                return 0;
+
+        switch (get_defcfg_device(def_conf)) {
+        case AC_JACK_LINE_OUT:
+                return fill_audio_out_name(codec, nid, cfg, "Line-Out",
+                                           label, maxlen, indexp);
+        case AC_JACK_SPEAKER:
+                return fill_audio_out_name(codec, nid, cfg, "Speaker",
+                                           label, maxlen, indexp);
+        case AC_JACK_HP_OUT:
+                return fill_audio_out_name(codec, nid, cfg, "Headphone",
+                                           label, maxlen, indexp);
+        case AC_JACK_SPDIF_OUT:
+        case AC_JACK_DIG_OTHER_OUT:
+                if (get_defcfg_location(def_conf) == AC_JACK_LOC_HDMI)
+                        name = "HDMI";
+                else
+                        name = "SPDIF";
+                if (cfg && indexp) {
+                        i = find_idx_in_nid_list(nid, cfg->dig_out_pins,
+                                                 cfg->dig_outs);
+                        if (i >= 0)
+                                *indexp = i;
+                }
+                break;
+        default:
+                if (cfg) {
+                        for (i = 0; i < cfg->num_inputs; i++) {
+                                if (cfg->inputs[i].pin != nid)
+                                        continue;
+                                name = hda_get_autocfg_input_label(codec, cfg, i);
+                                if (name)
+                                        break;
+                        }
+                }
+                if (!name)
+                        name = hda_get_input_pin_label(codec, nid, true);
+                break;
+        }
+        if (!name)
+                return 0;
+        strlcpy(label, name, maxlen);
+        return 1;
+}
+EXPORT_SYMBOL_HDA(snd_hda_get_pin_label);
+
 /**
  * snd_hda_add_imux_item - Add an item to input_mux
  *
@@ -5258,113 +5366,5 @@ void snd_print_pcm_bits(int pcm, char *buf, int buflen)
 }
 EXPORT_SYMBOL_HDA(snd_print_pcm_bits);
 
-#ifdef CONFIG_SND_HDA_INPUT_JACK
-/*
- * Input-jack notification support
- */
-struct hda_jack_item {
-        hda_nid_t nid;
-        int type;
-        struct snd_jack *jack;
-};
-
-static const char *get_jack_default_name(struct hda_codec *codec, hda_nid_t nid,
-                                         int type)
-{
-        switch (type) {
-        case SND_JACK_HEADPHONE:
-                return "Headphone";
-        case SND_JACK_MICROPHONE:
-                return "Mic";
-        case SND_JACK_LINEOUT:
-                return "Line-out";
-        case SND_JACK_LINEIN:
-                return "Line-in";
-        case SND_JACK_HEADSET:
-                return "Headset";
-        case SND_JACK_VIDEOOUT:
-                return "HDMI/DP";
-        default:
-                return "Misc";
-        }
-}
-
-static void hda_free_jack_priv(struct snd_jack *jack)
-{
-        struct hda_jack_item *jacks = jack->private_data;
-        jacks->nid = 0;
-        jacks->jack = NULL;
-}
-
-int snd_hda_input_jack_add(struct hda_codec *codec, hda_nid_t nid, int type,
-                           const char *name)
-{
-        struct hda_jack_item *jack;
-        int err;
-
-        snd_array_init(&codec->jacks, sizeof(*jack), 32);
-        jack = snd_array_new(&codec->jacks);
-        if (!jack)
-                return -ENOMEM;
-
-        jack->nid = nid;
-        jack->type = type;
-        if (!name)
-                name = get_jack_default_name(codec, nid, type);
-        err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
-        if (err < 0) {
-                jack->nid = 0;
-                return err;
-        }
-        jack->jack->private_data = jack;
-        jack->jack->private_free = hda_free_jack_priv;
-        return 0;
-}
-EXPORT_SYMBOL_HDA(snd_hda_input_jack_add);
-
-void snd_hda_input_jack_report(struct hda_codec *codec, hda_nid_t nid)
-{
-        struct hda_jack_item *jacks = codec->jacks.list;
-        int i;
-
-        if (!jacks)
-                return;
-
-        for (i = 0; i < codec->jacks.used; i++, jacks++) {
-                unsigned int pin_ctl;
-                unsigned int present;
-                int type;
-
-                if (jacks->nid != nid)
-                        continue;
-                present = snd_hda_jack_detect(codec, nid);
-                type = jacks->type;
-                if (type == (SND_JACK_HEADPHONE | SND_JACK_LINEOUT)) {
-                        pin_ctl = snd_hda_codec_read(codec, nid, 0,
-                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
-                        type = (pin_ctl & AC_PINCTL_HP_EN) ?
-                                SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
-                }
-                snd_jack_report(jacks->jack, present ? type : 0);
-        }
-}
-EXPORT_SYMBOL_HDA(snd_hda_input_jack_report);
-
-/* free jack instances manually when clearing/reconfiguring */
-void snd_hda_input_jack_free(struct hda_codec *codec)
-{
-        if (!codec->bus->shutdown && codec->jacks.list) {
-                struct hda_jack_item *jacks = codec->jacks.list;
-                int i;
-                for (i = 0; i < codec->jacks.used; i++, jacks++) {
-                        if (jacks->jack)
-                                snd_device_free(codec->bus->card, jacks->jack);
-                }
-        }
-        snd_array_free(&codec->jacks);
-}
-EXPORT_SYMBOL_HDA(snd_hda_input_jack_free);
-#endif /* CONFIG_SND_HDA_INPUT_JACK */
-
 MODULE_DESCRIPTION("HDA codec core");
 MODULE_LICENSE("GPL");
diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h
index 17cee4ee8e65..e9f71dc0d464 100644
--- a/sound/pci/hda/hda_codec.h
+++ b/sound/pci/hda/hda_codec.h
@@ -866,6 +866,9 @@ struct hda_codec {
         void (*proc_widget_hook)(struct snd_info_buffer *buffer,
                                  struct hda_codec *codec, hda_nid_t nid);
 
+        /* jack detection */
+        struct snd_array jacktbl;
+
 #ifdef CONFIG_SND_HDA_INPUT_JACK
         /* jack detection */
         struct snd_array jacks;
diff --git a/sound/pci/hda/hda_jack.c b/sound/pci/hda/hda_jack.c
new file mode 100644
index 000000000000..d8a35da0803f
--- /dev/null
+++ b/sound/pci/hda/hda_jack.c
@@ -0,0 +1,353 @@
+/*
+ * Jack-detection handling for HD-audio
+ *
+ * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
+ *
+ * This driver is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/export.h>
+#include <sound/core.h>
+#include <sound/control.h>
+#include <sound/jack.h>
+#include "hda_codec.h"
+#include "hda_local.h"
+#include "hda_jack.h"
+
+/* execute pin sense measurement */
+static u32 read_pin_sense(struct hda_codec *codec, hda_nid_t nid)
+{
+        u32 pincap;
+
+        if (!codec->no_trigger_sense) {
+                pincap = snd_hda_query_pin_caps(codec, nid);
+                if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
+                        snd_hda_codec_read(codec, nid, 0,
+                                        AC_VERB_SET_PIN_SENSE, 0);
+        }
+        return snd_hda_codec_read(codec, nid, 0,
+                                  AC_VERB_GET_PIN_SENSE, 0);
+}
+
+/**
+ * snd_hda_jack_tbl_get - query the jack-table entry for the given NID
+ */
+struct hda_jack_tbl *
+snd_hda_jack_tbl_get(struct hda_codec *codec, hda_nid_t nid)
+{
+        struct hda_jack_tbl *jack = codec->jacktbl.list;
+        int i;
+
+        if (!nid || !jack)
+                return NULL;
+        for (i = 0; i < codec->jacktbl.used; i++, jack++)
+                if (jack->nid == nid)
+                        return jack;
+        return NULL;
+}
+EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get);
+
+/**
+ * snd_hda_jack_tbl_get_from_tag - query the jack-table entry for the given tag
+ */
+struct hda_jack_tbl *
+snd_hda_jack_tbl_get_from_tag(struct hda_codec *codec, unsigned char tag)
+{
+        struct hda_jack_tbl *jack = codec->jacktbl.list;
+        int i;
+
+        if (!tag || !jack)
+                return NULL;
+        for (i = 0; i < codec->jacktbl.used; i++, jack++)
+                if (jack->tag == tag)
+                        return jack;
+        return NULL;
+}
+EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_get_from_tag);
+
+/**
+ * snd_hda_jack_tbl_new - create a jack-table entry for the given NID
+ */
+struct hda_jack_tbl *
+snd_hda_jack_tbl_new(struct hda_codec *codec, hda_nid_t nid)
+{
+        struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
+        if (jack)
+                return jack;
+        snd_array_init(&codec->jacktbl, sizeof(*jack), 16);
+        jack = snd_array_new(&codec->jacktbl);
+        if (!jack)
+                return NULL;
+        jack->nid = nid;
+        jack->jack_dirty = 1;
+        jack->tag = codec->jacktbl.used;
+        return jack;
+}
+EXPORT_SYMBOL_HDA(snd_hda_jack_tbl_new);
+
+void snd_hda_jack_tbl_clear(struct hda_codec *codec)
+{
+#ifdef CONFIG_SND_HDA_INPUT_JACK
+        /* free jack instances manually when clearing/reconfiguring */
+        if (!codec->bus->shutdown && codec->jacktbl.list) {
+                struct hda_jack_tbl *jack = codec->jacktbl.list;
+                int i;
+                for (i = 0; i < codec->jacktbl.used; i++, jack++) {
+                        if (jack->jack)
+                                snd_device_free(codec->bus->card, jack->jack);
+                }
+        }
+#endif
+        snd_array_free(&codec->jacktbl);
+}
+
+/* update the cached value and notification flag if needed */
+static void jack_detect_update(struct hda_codec *codec,
+                               struct hda_jack_tbl *jack)
+{
+        if (jack->jack_dirty || !jack->jack_detect) {
+                jack->pin_sense = read_pin_sense(codec, jack->nid);
+                jack->jack_dirty = 0;
+        }
+}
+
+/**
+ * snd_hda_set_dirty_all - Mark all the cached as dirty
+ *
+ * This function sets the dirty flag to all entries of jack table.
+ * It's called from the resume path in hda_codec.c.
+ */
+void snd_hda_jack_set_dirty_all(struct hda_codec *codec)
+{
+        struct hda_jack_tbl *jack = codec->jacktbl.list;
+        int i;
+
+        for (i = 0; i < codec->jacktbl.used; i++, jack++)
+                if (jack->nid)
+                        jack->jack_dirty = 1;
+}
+EXPORT_SYMBOL_HDA(snd_hda_jack_set_dirty_all);
+
+/**
+ * snd_hda_pin_sense - execute pin sense measurement
+ * @codec: the CODEC to sense
+ * @nid: the pin NID to sense
+ *
+ * Execute necessary pin sense measurement and return its Presence Detect,
+ * Impedance, ELD Valid etc. status bits.
+ */
+u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid)
+{
+        struct hda_jack_tbl *jack = snd_hda_jack_tbl_get(codec, nid);
+        if (jack) {
+                jack_detect_update(codec, jack);
+                return jack->pin_sense;
+        }
+        return read_pin_sense(codec, nid);
+}
+EXPORT_SYMBOL_HDA(snd_hda_pin_sense);
+
+#define get_jack_plug_state(sense) !!(sense & AC_PINSENSE_PRESENCE)
+
+/**
+ * snd_hda_jack_detect - query pin Presence Detect status
+ * @codec: the CODEC to sense
+ * @nid: the pin NID to sense
+ *
+ * Query and return the pin's Presence Detect status.
+ */
+int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid)
+{
+        u32 sense = snd_hda_pin_sense(codec, nid);
+        return get_jack_plug_state(sense);
+}
+EXPORT_SYMBOL_HDA(snd_hda_jack_detect);
+
+/**
+ * snd_hda_jack_detect_enable - enable the jack-detection
+ */
+int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid,
+                               unsigned char action)
+{
+        struct hda_jack_tbl *jack = snd_hda_jack_tbl_new(codec, nid);
+        if (!jack)
+                return -ENOMEM;
+        if (jack->jack_detect)
+                return 0; /* already registered */
+        jack->jack_detect = 1;
+        if (action)
+                jack->action = action;
+        return snd_hda_codec_write_cache(codec, nid, 0,
+                                         AC_VERB_SET_UNSOLICITED_ENABLE,
+                                         AC_USRSP_EN | jack->tag);
+}
+EXPORT_SYMBOL_HDA(snd_hda_jack_detect_enable);
+
+/**
+ * snd_hda_jack_report_sync - sync the states of all jacks and report if changed
+ */
+void snd_hda_jack_report_sync(struct hda_codec *codec)
+{
+        struct hda_jack_tbl *jack = codec->jacktbl.list;
+        int i, state;
+
+        for (i = 0; i < codec->jacktbl.used; i++, jack++)
+                if (jack->nid) {
+                        jack_detect_update(codec, jack);
+                        if (!jack->kctl)
+                                continue;
+                        state = get_jack_plug_state(jack->pin_sense);
+                        snd_kctl_jack_report(codec->bus->card, jack->kctl, state);
+#ifdef CONFIG_SND_HDA_INPUT_JACK
+                        if (jack->jack)
+                                snd_jack_report(jack->jack,
+                                                state ? jack->type : 0);
+#endif
+                }
+}
+EXPORT_SYMBOL_HDA(snd_hda_jack_report_sync);
+
+#ifdef CONFIG_SND_HDA_INPUT_JACK
+/* guess the jack type from the pin-config */
+static int get_input_jack_type(struct hda_codec *codec, hda_nid_t nid)
+{
+        unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
+        switch (get_defcfg_device(def_conf)) {
+        case AC_JACK_LINE_OUT:
+        case AC_JACK_SPEAKER:
+                return SND_JACK_LINEOUT;
+        case AC_JACK_HP_OUT:
+                return SND_JACK_HEADPHONE;
+        case AC_JACK_SPDIF_OUT:
+        case AC_JACK_DIG_OTHER_OUT:
+                return SND_JACK_AVOUT;
+        case AC_JACK_MIC_IN:
+                return SND_JACK_MICROPHONE;
+        default:
+                return SND_JACK_LINEIN;
+        }
+}
+
+static void hda_free_jack_priv(struct snd_jack *jack)
+{
+        struct hda_jack_tbl *jacks = jack->private_data;
+        jacks->nid = 0;
+        jacks->jack = NULL;
+}
+#endif
+
+/**
+ * snd_hda_jack_add_kctl - Add a kctl for the given pin
+ *
+ * This assigns a jack-detection kctl to the given pin.  The kcontrol
+ * will have the given name and index.
+ */
+int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
+                          const char *name, int idx)
+{
+        struct hda_jack_tbl *jack;
+        struct snd_kcontrol *kctl;
+        int err, state;
+
+        jack = snd_hda_jack_tbl_new(codec, nid);
+        if (!jack)
+                return 0;
+        if (jack->kctl)
+                return 0; /* already created */
+        kctl = snd_kctl_jack_new(name, idx, codec);
+        if (!kctl)
+                return -ENOMEM;
+        err = snd_hda_ctl_add(codec, nid, kctl);
+        if (err < 0)
+                return err;
+        jack->kctl = kctl;
+        state = snd_hda_jack_detect(codec, nid);
+        snd_kctl_jack_report(codec->bus->card, kctl, state);
+#ifdef CONFIG_SND_HDA_INPUT_JACK
+        jack->type = get_input_jack_type(codec, nid);
+        err = snd_jack_new(codec->bus->card, name, jack->type, &jack->jack);
+        if (err < 0)
+                return err;
+        jack->jack->private_data = jack;
+        jack->jack->private_free = hda_free_jack_priv;
+        snd_jack_report(jack->jack, state ? jack->type : 0);
+#endif
+        return 0;
+}
+EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctl);
+
+static int add_jack_kctl(struct hda_codec *codec, hda_nid_t nid,
+                         const struct auto_pin_cfg *cfg)
+{
+        unsigned int def_conf, conn;
+        char name[44];
+        int idx, err;
+
+        if (!nid)
+                return 0;
+        if (!is_jack_detectable(codec, nid))
+                return 0;
+        def_conf = snd_hda_codec_get_pincfg(codec, nid);
+        conn = get_defcfg_connect(def_conf);
+        if (conn != AC_JACK_PORT_COMPLEX)
+                return 0;
+
+        snd_hda_get_pin_label(codec, nid, cfg, name, sizeof(name), &idx);
+        err = snd_hda_jack_add_kctl(codec, nid, name, idx);
+        if (err < 0)
+                return err;
+        return snd_hda_jack_detect_enable(codec, nid, 0);
+}
+
+/**
+ * snd_hda_jack_add_kctls - Add kctls for all pins included in the given pincfg
+ */
+int snd_hda_jack_add_kctls(struct hda_codec *codec,
+                           const struct auto_pin_cfg *cfg)
+{
+        const hda_nid_t *p;
+        int i, err;
+
+        for (i = 0, p = cfg->line_out_pins; i < cfg->line_outs; i++, p++) {
+                err = add_jack_kctl(codec, *p, cfg);
+                if (err < 0)
+                        return err;
+        }
+        for (i = 0, p = cfg->hp_pins; i < cfg->hp_outs; i++, p++) {
+                if (*p == *cfg->line_out_pins) /* might be duplicated */
+                        break;
+                err = add_jack_kctl(codec, *p, cfg);
+                if (err < 0)
+                        return err;
+        }
+        for (i = 0, p = cfg->speaker_pins; i < cfg->speaker_outs; i++, p++) {
+                if (*p == *cfg->line_out_pins) /* might be duplicated */
+                        break;
+                err = add_jack_kctl(codec, *p, cfg);
+                if (err < 0)
+                        return err;
+        }
+        for (i = 0; i < cfg->num_inputs; i++) {
+                err = add_jack_kctl(codec, cfg->inputs[i].pin, cfg);
+                if (err < 0)
+                        return err;
+        }
+        for (i = 0, p = cfg->dig_out_pins; i < cfg->dig_outs; i++, p++) {
+                err = add_jack_kctl(codec, *p, cfg);
+                if (err < 0)
+                        return err;
+        }
+        err = add_jack_kctl(codec, cfg->dig_in_pin, cfg);
+        if (err < 0)
+                return err;
+        err = add_jack_kctl(codec, cfg->mono_out_pin, cfg);
+        if (err < 0)
+                return err;
+        return 0;
+}
+EXPORT_SYMBOL_HDA(snd_hda_jack_add_kctls);
diff --git a/sound/pci/hda/hda_jack.h b/sound/pci/hda/hda_jack.h
new file mode 100644
index 000000000000..f8f97c71c9c1
--- /dev/null
+++ b/sound/pci/hda/hda_jack.h
@@ -0,0 +1,86 @@
+/*
+ * Jack-detection handling for HD-audio
+ *
+ * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
+ *
+ * This driver is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef __SOUND_HDA_JACK_H
+#define __SOUND_HDA_JACK_H
+
+struct hda_jack_tbl {
+        hda_nid_t nid;
+        unsigned char action;           /* event action (0 = none) */
+        unsigned char tag;              /* unsol event tag */
+        unsigned int private_data;      /* arbitrary data */
+        /* jack-detection stuff */
+        unsigned int pin_sense;         /* cached pin-sense value */
+        unsigned int jack_detect:1;     /* capable of jack-detection? */
+        unsigned int jack_dirty:1;      /* needs to update? */
+        struct snd_kcontrol *kctl;      /* assigned kctl for jack-detection */
+#ifdef CONFIG_SND_HDA_INPUT_JACK
+        int type;
+        struct snd_jack *jack;
+#endif
+};
+
+struct hda_jack_tbl *
+snd_hda_jack_tbl_get(struct hda_codec *codec, hda_nid_t nid);
+struct hda_jack_tbl *
+snd_hda_jack_tbl_get_from_tag(struct hda_codec *codec, unsigned char tag);
+
+struct hda_jack_tbl *
+snd_hda_jack_tbl_new(struct hda_codec *codec, hda_nid_t nid);
+void snd_hda_jack_tbl_clear(struct hda_codec *codec);
+
+/**
+ * snd_hda_jack_get_action - get jack-tbl entry for the tag
+ *
+ * Call this from the unsol event handler to get the assigned action for the
+ * event.  This will mark the dirty flag for the later reporting, too.
+ */
+static inline unsigned char
+snd_hda_jack_get_action(struct hda_codec *codec, unsigned int tag)
+{
+        struct hda_jack_tbl *jack = snd_hda_jack_tbl_get_from_tag(codec, tag);
+        if (jack) {
+                jack->jack_dirty = 1;
+                return jack->action;
+        }
+        return 0;
+}
+
+void snd_hda_jack_set_dirty_all(struct hda_codec *codec);
+
+int snd_hda_jack_detect_enable(struct hda_codec *codec, hda_nid_t nid,
+                               unsigned char action);
+
+u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid);
+int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid);
+
+static inline bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid)
+{
+        if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_PRES_DETECT))
+                return false;
+        if (!codec->ignore_misc_bit &&
+            (get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
+             AC_DEFCFG_MISC_NO_PRESENCE))
+                return false;
+        if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
+                return false;
+        return true;
+}
+
+int snd_hda_jack_add_kctl(struct hda_codec *codec, hda_nid_t nid,
+                          const char *name, int idx);
+int snd_hda_jack_add_kctls(struct hda_codec *codec,
+                           const struct auto_pin_cfg *cfg);
+
+void snd_hda_jack_report_sync(struct hda_codec *codec);
+
+
+#endif /* __SOUND_HDA_JACK_H */
diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h
index 618ddad17236..e1abc07f7436 100644
--- a/sound/pci/hda/hda_local.h
+++ b/sound/pci/hda/hda_local.h
@@ -394,11 +394,12 @@ struct auto_pin_cfg_item {
 };
 
 struct auto_pin_cfg;
-const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin,
-                                    int check_location);
 const char *hda_get_autocfg_input_label(struct hda_codec *codec,
                                         const struct auto_pin_cfg *cfg,
                                         int input);
+int snd_hda_get_pin_label(struct hda_codec *codec, hda_nid_t nid,
+                          const struct auto_pin_cfg *cfg,
+                          char *label, int maxlen, int *indexp);
 int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label,
                           int index, int *type_index_ret);
 
@@ -505,21 +506,6 @@ int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
 u32 snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid);
 int snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
                               unsigned int caps);
-u32 snd_hda_pin_sense(struct hda_codec *codec, hda_nid_t nid);
-int snd_hda_jack_detect(struct hda_codec *codec, hda_nid_t nid);
-
-static inline bool is_jack_detectable(struct hda_codec *codec, hda_nid_t nid)
-{
-        if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_PRES_DETECT))
-                return false;
-        if (!codec->ignore_misc_bit &&
-            (get_defcfg_misc(snd_hda_codec_get_pincfg(codec, nid)) &
-             AC_DEFCFG_MISC_NO_PRESENCE))
-                return false;
-        if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
-                return false;
-        return true;
-}
 
 /* flags for hda_nid_item */
 #define HDA_NID_ITEM_AMP        (1<<0)
@@ -688,28 +674,4 @@ static inline void snd_hda_eld_proc_free(struct hda_codec *codec,
 #define SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE 80
 void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen);
 
-/*
- * Input-jack notification support
- */
-#ifdef CONFIG_SND_HDA_INPUT_JACK
-int snd_hda_input_jack_add(struct hda_codec *codec, hda_nid_t nid, int type,
-                           const char *name);
-void snd_hda_input_jack_report(struct hda_codec *codec, hda_nid_t nid);
-void snd_hda_input_jack_free(struct hda_codec *codec);
-#else /* CONFIG_SND_HDA_INPUT_JACK */
-static inline int snd_hda_input_jack_add(struct hda_codec *codec,
-                                         hda_nid_t nid, int type,
-                                         const char *name)
-{
-        return 0;
-}
-static inline void snd_hda_input_jack_report(struct hda_codec *codec,
-                                             hda_nid_t nid)
-{
-}
-static inline void snd_hda_input_jack_free(struct hda_codec *codec)
-{
-}
-#endif /* CONFIG_SND_HDA_INPUT_JACK */
-
 #endif /* __SOUND_HDA_LOCAL_H */
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index bcb3310c394f..9cb14b42dfff 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -29,6 +29,7 @@
 #include "hda_codec.h"
 #include "hda_local.h"
 #include "hda_beep.h"
+#include "hda_jack.h"
 
 struct ad198x_spec {
         const struct snd_kcontrol_new *mixers[6];
diff --git a/sound/pci/hda/patch_ca0110.c b/sound/pci/hda/patch_ca0110.c
index 993757b65736..09ccfabb4a17 100644
--- a/sound/pci/hda/patch_ca0110.c
+++ b/sound/pci/hda/patch_ca0110.c
@@ -41,7 +41,7 @@ struct ca0110_spec {
         hda_nid_t dig_out;
         hda_nid_t dig_in;
         unsigned int num_inputs;
-        const char *input_labels[AUTO_PIN_LAST];
+        char input_labels[AUTO_PIN_LAST][32];
         struct hda_pcm pcm_rec[2];      /* PCM information */
 };
 
@@ -476,7 +476,9 @@ static void parse_input(struct hda_codec *codec)
                 if (j >= cfg->num_inputs)
                         continue;
                 spec->input_pins[n] = pin;
-                spec->input_labels[n] = hda_get_input_pin_label(codec, pin, 1);
+                snd_hda_get_pin_label(codec, pin, cfg,
+                                      spec->input_labels[n],
+                                      sizeof(spec->input_labels[n]), NULL);
                 spec->adcs[n] = nid;
                 n++;
         }
diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c
index 70a7abda7e22..acfb64534bf0 100644
--- a/sound/pci/hda/patch_cirrus.c
+++ b/sound/pci/hda/patch_cirrus.c
@@ -26,6 +26,7 @@
 #include <sound/core.h>
 #include "hda_codec.h"
 #include "hda_local.h"
+#include "hda_jack.h"
 #include <sound/tlv.h>
 
 /*
@@ -721,8 +722,9 @@ static int cs_capture_source_info(struct snd_kcontrol *kcontrol,
         if (uinfo->value.enumerated.item >= spec->num_inputs)
                 uinfo->value.enumerated.item = spec->num_inputs - 1;
         idx = spec->input_idx[uinfo->value.enumerated.item];
-        strcpy(uinfo->value.enumerated.name,
-               hda_get_input_pin_label(codec, cfg->inputs[idx].pin, 1));
+        snd_hda_get_pin_label(codec, cfg->inputs[idx].pin, cfg,
+                              uinfo->value.enumerated.name,
+                              sizeof(uinfo->value.enumerated.name), NULL);
         return 0;
 }
 
@@ -1027,9 +1029,7 @@ static void init_output(struct hda_codec *codec)
                 if (!cfg->speaker_outs)
                         continue;
                 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
-                        snd_hda_codec_write(codec, nid, 0,
-                                            AC_VERB_SET_UNSOLICITED_ENABLE,
-                                            AC_USRSP_EN | HP_EVENT);
+                        snd_hda_jack_detect_enable(codec, nid, HP_EVENT);
                         spec->hp_detect = 1;
                 }
         }
@@ -1070,9 +1070,7 @@ static void init_input(struct hda_codec *codec)
                                     AC_VERB_SET_AMP_GAIN_MUTE,
                                     AMP_IN_MUTE(spec->adc_idx[i]));
                 if (spec->mic_detect && spec->automic_idx == i)
-                        snd_hda_codec_write(codec, pin, 0,
-                                            AC_VERB_SET_UNSOLICITED_ENABLE,
-                                            AC_USRSP_EN | MIC_EVENT);
+                        snd_hda_jack_detect_enable(codec, pin, MIC_EVENT);
         }
         /* specific to CS421x */
         if (spec->vendor_nid == CS421X_VENDOR_NID) {
@@ -1200,11 +1198,14 @@ static int cs_init(struct hda_codec *codec)
         init_output(codec);
         init_input(codec);
         init_digital(codec);
+        snd_hda_jack_report_sync(codec);
+
         return 0;
 }
 
 static int cs_build_controls(struct hda_codec *codec)
 {
+        struct cs_spec *spec = codec->spec;
         int err;
 
         err = build_output(codec);
@@ -1219,7 +1220,15 @@ static int cs_build_controls(struct hda_codec *codec)
         err = build_digital_input(codec);
         if (err < 0)
                 return err;
-        return cs_init(codec);
+        err = cs_init(codec);
+        if (err < 0)
+                return err;
+
+        err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
+        return 0;
 }
 
 static void cs_free(struct hda_codec *codec)
@@ -1232,7 +1241,7 @@ static void cs_free(struct hda_codec *codec)
 
 static void cs_unsol_event(struct hda_codec *codec, unsigned int res)
 {
-        switch ((res >> 26) & 0x7f) {
+        switch (snd_hda_jack_get_action(codec, res >> 26)) {
         case HP_EVENT:
                 cs_automute(codec);
                 break;
@@ -1240,6 +1249,7 @@ static void cs_unsol_event(struct hda_codec *codec, unsigned int res)
                 cs_automic(codec);
                 break;
         }
+        snd_hda_jack_report_sync(codec);
 }
 
 static const struct hda_codec_ops cs_patch_ops = {
@@ -1602,10 +1612,7 @@ static void init_cs421x_digital(struct hda_codec *codec)
                 if (!cfg->speaker_outs)
                         continue;
                 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
-
-                        snd_hda_codec_write(codec, nid, 0,
-                                    AC_VERB_SET_UNSOLICITED_ENABLE,
-                                    AC_USRSP_EN | SPDIF_EVENT);
+                        snd_hda_jack_detect_enable(codec, nid, SPDIF_EVENT);
                         spec->spdif_detect = 1;
                 }
         }
@@ -1632,6 +1639,7 @@ static int cs421x_init(struct hda_codec *codec)
         init_output(codec);
         init_input(codec);
         init_cs421x_digital(codec);
+        snd_hda_jack_report_sync(codec);
 
         return 0;
 }
@@ -1807,6 +1815,7 @@ static int build_cs421x_output(struct hda_codec *codec)
 
 static int cs421x_build_controls(struct hda_codec *codec)
 {
+        struct cs_spec *spec = codec->spec;
         int err;
 
         err = build_cs421x_output(codec);
@@ -1818,12 +1827,20 @@ static int cs421x_build_controls(struct hda_codec *codec)
         err = build_digital_output(codec);
         if (err < 0)
                 return err;
-        return cs421x_init(codec);
+        err =  cs421x_init(codec);
+        if (err < 0)
+                return err;
+
+        err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
+        return 0;
 }
 
 static void cs421x_unsol_event(struct hda_codec *codec, unsigned int res)
 {
-        switch ((res >> 26) & 0x3f) {
+        switch (snd_hda_jack_get_action(codec, res >> 26)) {
         case HP_EVENT:
         case SPDIF_EVENT:
                 cs_automute(codec);
@@ -1833,6 +1850,7 @@ static void cs421x_unsol_event(struct hda_codec *codec, unsigned int res)
                 cs_automic(codec);
                 break;
         }
+        snd_hda_jack_report_sync(codec);
 }
 
 static int parse_cs421x_input(struct hda_codec *codec)
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
index 0de21193a2b0..bf14a0a0ce1c 100644
--- a/sound/pci/hda/patch_conexant.c
+++ b/sound/pci/hda/patch_conexant.c
@@ -31,6 +31,7 @@
 #include "hda_codec.h"
 #include "hda_local.h"
 #include "hda_beep.h"
+#include "hda_jack.h"
 
 #define CXT_PIN_DIR_IN              0x00
 #define CXT_PIN_DIR_OUT             0x01
@@ -415,40 +416,6 @@ static int conexant_mux_enum_put(struct snd_kcontrol *kcontrol,
                                      &spec->cur_mux[adc_idx]);
 }
 
-static int conexant_init_jacks(struct hda_codec *codec)
-{
-#ifdef CONFIG_SND_HDA_INPUT_JACK
-        struct conexant_spec *spec = codec->spec;
-        int i;
-
-        for (i = 0; i < spec->num_init_verbs; i++) {
-                const struct hda_verb *hv;
-
-                hv = spec->init_verbs[i];
-                while (hv->nid) {
-                        int err = 0;
-                        switch (hv->param ^ AC_USRSP_EN) {
-                        case CONEXANT_HP_EVENT:
-                                err = snd_hda_input_jack_add(codec, hv->nid,
-                                                SND_JACK_HEADPHONE, NULL);
-                                snd_hda_input_jack_report(codec, hv->nid);
-                                break;
-                        case CXT5051_PORTC_EVENT:
-                        case CONEXANT_MIC_EVENT:
-                                err = snd_hda_input_jack_add(codec, hv->nid,
-                                                SND_JACK_MICROPHONE, NULL);
-                                snd_hda_input_jack_report(codec, hv->nid);
-                                break;
-                        }
-                        if (err < 0)
-                                return err;
-                        ++hv;
-                }
-        }
-#endif /* CONFIG_SND_HDA_INPUT_JACK */
-        return 0;
-}
-
 static void conexant_set_power(struct hda_codec *codec, hda_nid_t fg,
                                unsigned int power_state)
 {
@@ -474,7 +441,6 @@ static int conexant_init(struct hda_codec *codec)
 
 static void conexant_free(struct hda_codec *codec)
 {
-        snd_hda_input_jack_free(codec);
         snd_hda_detach_beep_device(codec);
         kfree(codec->spec);
 }
@@ -1750,7 +1716,6 @@ static void cxt5051_hp_automute(struct hda_codec *codec)
 static void cxt5051_hp_unsol_event(struct hda_codec *codec,
                                    unsigned int res)
 {
-        int nid = (res & AC_UNSOL_RES_SUBTAG) >> 20;
         switch (res >> 26) {
         case CONEXANT_HP_EVENT:
                 cxt5051_hp_automute(codec);
@@ -1762,7 +1727,6 @@ static void cxt5051_hp_unsol_event(struct hda_codec *codec,
                 cxt5051_portc_automic(codec);
                 break;
         }
-        snd_hda_input_jack_report(codec, nid);
 }
 
 static const struct snd_kcontrol_new cxt5051_playback_mixers[] = {
@@ -1901,8 +1865,6 @@ static void cxt5051_init_mic_port(struct hda_codec *codec, hda_nid_t nid,
         snd_hda_codec_write(codec, nid, 0,
                             AC_VERB_SET_UNSOLICITED_ENABLE,
                             AC_USRSP_EN | event);
-        snd_hda_input_jack_add(codec, nid, SND_JACK_MICROPHONE, NULL);
-        snd_hda_input_jack_report(codec, nid);
 }
 
 static const struct hda_verb cxt5051_ideapad_init_verbs[] = {
@@ -1918,7 +1880,6 @@ static int cxt5051_init(struct hda_codec *codec)
         struct conexant_spec *spec = codec->spec;
 
         conexant_init(codec);
-        conexant_init_jacks(codec);
 
         if (spec->auto_mic & AUTO_MIC_PORTB)
                 cxt5051_init_mic_port(codec, 0x17, CXT5051_PORTB_EVENT);
@@ -3450,7 +3411,6 @@ static int detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
                 hda_nid_t nid = pins[i];
                 if (!nid || !is_jack_detectable(codec, nid))
                         break;
-                snd_hda_input_jack_report(codec, nid);
                 present |= snd_hda_jack_detect(codec, nid);
         }
         return present;
@@ -3755,8 +3715,7 @@ static void cx_auto_automic(struct hda_codec *codec)
 
 static void cx_auto_unsol_event(struct hda_codec *codec, unsigned int res)
 {
-        int nid = (res & AC_UNSOL_RES_SUBTAG) >> 20;
-        switch (res >> 26) {
+        switch (snd_hda_jack_get_action(codec, res >> 26)) {
         case CONEXANT_HP_EVENT:
                 cx_auto_hp_automute(codec);
                 break;
@@ -3765,9 +3724,9 @@ static void cx_auto_unsol_event(struct hda_codec *codec, unsigned int res)
                 break;
         case CONEXANT_MIC_EVENT:
                 cx_auto_automic(codec);
-                snd_hda_input_jack_report(codec, nid);
                 break;
         }
+        snd_hda_jack_report_sync(codec);
 }
 
 /* check whether the pin config is suitable for auto-mic switching;
@@ -3979,13 +3938,11 @@ static void mute_outputs(struct hda_codec *codec, int num_nids,
 }
 
 static void enable_unsol_pins(struct hda_codec *codec, int num_pins,
-                              hda_nid_t *pins, unsigned int tag)
+                              hda_nid_t *pins, unsigned int action)
 {
         int i;
         for (i = 0; i < num_pins; i++)
-                snd_hda_codec_write(codec, pins[i], 0,
-                                    AC_VERB_SET_UNSOLICITED_ENABLE,
-                                    AC_USRSP_EN | tag);
+                snd_hda_jack_detect_enable(codec, pins[i], action);
 }
 
 static void cx_auto_init_output(struct hda_codec *codec)
@@ -4060,16 +4017,14 @@ static void cx_auto_init_input(struct hda_codec *codec)
 
         if (spec->auto_mic) {
                 if (spec->auto_mic_ext >= 0) {
-                        snd_hda_codec_write(codec,
-                                cfg->inputs[spec->auto_mic_ext].pin, 0,
-                                AC_VERB_SET_UNSOLICITED_ENABLE,
-                                AC_USRSP_EN | CONEXANT_MIC_EVENT);
+                        snd_hda_jack_detect_enable(codec,
+                                cfg->inputs[spec->auto_mic_ext].pin,
+                                CONEXANT_MIC_EVENT);
                 }
                 if (spec->auto_mic_dock >= 0) {
-                        snd_hda_codec_write(codec,
-                                cfg->inputs[spec->auto_mic_dock].pin, 0,
-                                AC_VERB_SET_UNSOLICITED_ENABLE,
-                                AC_USRSP_EN | CONEXANT_MIC_EVENT);
+                        snd_hda_jack_detect_enable(codec,
+                                cfg->inputs[spec->auto_mic_dock].pin,
+                                CONEXANT_MIC_EVENT);
                 }
                 cx_auto_automic(codec);
         } else {
@@ -4097,6 +4052,7 @@ static int cx_auto_init(struct hda_codec *codec)
         cx_auto_init_output(codec);
         cx_auto_init_input(codec);
         cx_auto_init_digital(codec);
+        snd_hda_jack_report_sync(codec);
         return 0;
 }
 
@@ -4326,6 +4282,7 @@ static int cx_auto_build_input_controls(struct hda_codec *codec)
 
 static int cx_auto_build_controls(struct hda_codec *codec)
 {
+        struct conexant_spec *spec = codec->spec;
         int err;
 
         err = cx_auto_build_output_controls(codec);
@@ -4334,7 +4291,13 @@ static int cx_auto_build_controls(struct hda_codec *codec)
         err = cx_auto_build_input_controls(codec);
         if (err < 0)
                 return err;
-        return conexant_build_controls(codec);
+        err = conexant_build_controls(codec);
+        if (err < 0)
+                return err;
+        err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
+        if (err < 0)
+                return err;
+        return 0;
 }
 
 static int cx_auto_search_adcs(struct hda_codec *codec)
diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
index 6e0756febb2e..3f42cc965b46 100644
--- a/sound/pci/hda/patch_hdmi.c
+++ b/sound/pci/hda/patch_hdmi.c
@@ -36,6 +36,7 @@
 #include <sound/jack.h>
 #include "hda_codec.h"
 #include "hda_local.h"
+#include "hda_jack.h"
 
 static bool static_hdmi_pcm;
 module_param(static_hdmi_pcm, bool, 0644);
@@ -754,10 +755,18 @@ static void hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll);
 static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
 {
         struct hdmi_spec *spec = codec->spec;
-        int pin_nid = res >> AC_UNSOL_RES_TAG_SHIFT;
+        int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
+        int pin_nid;
         int pd = !!(res & AC_UNSOL_RES_PD);
         int eldv = !!(res & AC_UNSOL_RES_ELDV);
         int pin_idx;
+        struct hda_jack_tbl *jack;
+
+        jack = snd_hda_jack_tbl_get_from_tag(codec, tag);
+        if (!jack)
+                return;
+        pin_nid = jack->nid;
+        jack->jack_dirty = 1;
 
         printk(KERN_INFO
                 "HDMI hot plug event: Codec=%d Pin=%d Presence_Detect=%d ELD_Valid=%d\n",
@@ -768,6 +777,7 @@ static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
                 return;
 
         hdmi_present_sense(&spec->pins[pin_idx], 1);
+        snd_hda_jack_report_sync(codec);
 }
 
 static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
@@ -799,7 +809,7 @@ static void hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
         int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
         int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
 
-        if (pin_nid_to_pin_index(spec, tag) < 0) {
+        if (!snd_hda_jack_tbl_get_from_tag(codec, tag)) {
                 snd_printd(KERN_INFO "Unexpected HDMI event tag 0x%x\n", tag);
                 return;
         }
@@ -996,8 +1006,6 @@ static void hdmi_present_sense(struct hdmi_spec_per_pin *per_pin, int repoll)
                                            msecs_to_jiffies(300));
                 }
         }
-
-        snd_hda_input_jack_report(codec, pin_nid);
 }
 
 static void hdmi_repoll_eld(struct work_struct *work)
@@ -1226,21 +1234,16 @@ static int generic_hdmi_build_pcms(struct hda_codec *codec)
 
 static int generic_hdmi_build_jack(struct hda_codec *codec, int pin_idx)
 {
-        int err;
-        char hdmi_str[32];
+        char hdmi_str[32] = "HDMI/DP";
         struct hdmi_spec *spec = codec->spec;
         struct hdmi_spec_per_pin *per_pin = &spec->pins[pin_idx];
         int pcmdev = spec->pcm_rec[pin_idx].device;
 
-        snprintf(hdmi_str, sizeof(hdmi_str), "HDMI/DP,pcm=%d", pcmdev);
-
-        err = snd_hda_input_jack_add(codec, per_pin->pin_nid,
-                             SND_JACK_VIDEOOUT, pcmdev > 0 ? hdmi_str : NULL);
-        if (err < 0)
-                return err;
+        if (pcmdev > 0)
+                sprintf(hdmi_str + strlen(hdmi_str), ",pcm=%d", pcmdev);
 
         hdmi_present_sense(per_pin, 0);
-        return 0;
+        return snd_hda_jack_add_kctl(codec, per_pin->pin_nid, hdmi_str, 0);
 }
 
 static int generic_hdmi_build_controls(struct hda_codec *codec)
@@ -1270,6 +1273,8 @@ static int generic_hdmi_build_controls(struct hda_codec *codec)
 
                 if (err < 0)
                         return err;
+
+                hdmi_present_sense(per_pin, false);
         }
 
         return 0;
@@ -1286,14 +1291,13 @@ static int generic_hdmi_init(struct hda_codec *codec)
                 struct hdmi_eld *eld = &per_pin->sink_eld;
 
                 hdmi_init_pin(codec, pin_nid);
-                snd_hda_codec_write(codec, pin_nid, 0,
-                                    AC_VERB_SET_UNSOLICITED_ENABLE,
-                                    AC_USRSP_EN | pin_nid);
+                snd_hda_jack_detect_enable(codec, pin_nid, pin_nid);
 
                 per_pin->codec = codec;
                 INIT_DELAYED_WORK(&per_pin->work, hdmi_repoll_eld);
                 snd_hda_eld_proc_new(codec, eld, pin_idx);
         }
+        snd_hda_jack_report_sync(codec);
         return 0;
 }
 
@@ -1309,7 +1313,6 @@ static void generic_hdmi_free(struct hda_codec *codec)
                 cancel_delayed_work(&per_pin->work);
                 snd_hda_eld_proc_free(codec, eld);
         }
-        snd_hda_input_jack_free(codec);
 
         flush_workqueue(codec->bus->workq);
         kfree(spec);
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 690f2a2a4595..d24adbd023ee 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -33,6 +33,7 @@
 #include "hda_codec.h"
 #include "hda_local.h"
 #include "hda_beep.h"
+#include "hda_jack.h"
 
 /* unsol event tags */
 #define ALC_FRONT_EVENT         0x01
@@ -184,6 +185,7 @@ struct alc_spec {
         unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
         unsigned int parse_flags; /* passed to snd_hda_parse_pin_defcfg() */
         unsigned int shared_mic_hp:1; /* HP/Mic-in sharing */
+        unsigned int use_jack_tbl:1; /* 1 for model=auto */
 
         /* auto-mute control */
         int automute_mode;
@@ -466,46 +468,6 @@ static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 }
 
 /*
- * Jack-reporting via input-jack layer
- */
-
-/* initialization of jacks; currently checks only a few known pins */
-static int alc_init_jacks(struct hda_codec *codec)
-{
-#ifdef CONFIG_SND_HDA_INPUT_JACK
-        struct alc_spec *spec = codec->spec;
-        int err;
-        unsigned int hp_nid = spec->autocfg.hp_pins[0];
-        unsigned int mic_nid = spec->ext_mic_pin;
-        unsigned int dock_nid = spec->dock_mic_pin;
-
-        if (hp_nid) {
-                err = snd_hda_input_jack_add(codec, hp_nid,
-                                             SND_JACK_HEADPHONE, NULL);
-                if (err < 0)
-                        return err;
-                snd_hda_input_jack_report(codec, hp_nid);
-        }
-
-        if (mic_nid) {
-                err = snd_hda_input_jack_add(codec, mic_nid,
-                                             SND_JACK_MICROPHONE, NULL);
-                if (err < 0)
-                        return err;
-                snd_hda_input_jack_report(codec, mic_nid);
-        }
-        if (dock_nid) {
-                err = snd_hda_input_jack_add(codec, dock_nid,
-                                             SND_JACK_MICROPHONE, NULL);
-                if (err < 0)
-                        return err;
-                snd_hda_input_jack_report(codec, dock_nid);
-        }
-#endif /* CONFIG_SND_HDA_INPUT_JACK */
-        return 0;
-}
-
-/*
  * Jack detections for HP auto-mute and mic-switch
  */
 
@@ -518,7 +480,6 @@ static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
                 hda_nid_t nid = pins[i];
                 if (!nid)
                         break;
-                snd_hda_input_jack_report(codec, nid);
                 present |= snd_hda_jack_detect(codec, nid);
         }
         return present;
@@ -658,19 +619,18 @@ static void alc_mic_automute(struct hda_codec *codec)
                 alc_mux_select(codec, 0, spec->dock_mic_idx, false);
         else
                 alc_mux_select(codec, 0, spec->int_mic_idx, false);
-
-        snd_hda_input_jack_report(codec, pins[spec->ext_mic_idx]);
-        if (spec->dock_mic_idx >= 0)
-                snd_hda_input_jack_report(codec, pins[spec->dock_mic_idx]);
 }
 
 /* unsolicited event for HP jack sensing */
 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 {
+        struct alc_spec *spec = codec->spec;
         if (codec->vendor_id == 0x10ec0880)
                 res >>= 28;
         else
                 res >>= 26;
+        if (spec->use_jack_tbl)
+                res = snd_hda_jack_get_action(codec, res);
         switch (res) {
         case ALC_HP_EVENT:
                 alc_hp_automute(codec);
@@ -682,6 +642,7 @@ static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
                 alc_mic_automute(codec);
                 break;
         }
+        snd_hda_jack_report_sync(codec);
 }
 
 /* call init functions of standard auto-mute helpers */
@@ -971,9 +932,7 @@ static void alc_init_automute(struct hda_codec *codec)
                         continue;
                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
                             nid);
-                snd_hda_codec_write_cache(codec, nid, 0,
-                                  AC_VERB_SET_UNSOLICITED_ENABLE,
-                                  AC_USRSP_EN | ALC_HP_EVENT);
+                snd_hda_jack_detect_enable(codec, nid, ALC_HP_EVENT);
                 spec->detect_hp = 1;
         }
 
@@ -985,9 +944,8 @@ static void alc_init_automute(struct hda_codec *codec)
                                         continue;
                                 snd_printdd("realtek: Enable Line-Out "
                                             "auto-muting on NID 0x%x\n", nid);
-                                snd_hda_codec_write_cache(codec, nid, 0,
-                                                AC_VERB_SET_UNSOLICITED_ENABLE,
-                                                AC_USRSP_EN | ALC_FRONT_EVENT);
+                                snd_hda_jack_detect_enable(codec, nid,
+                                                           ALC_FRONT_EVENT);
                                 spec->detect_lo = 1;
                 }
                 spec->automute_lo_possible = spec->detect_hp;
@@ -1126,13 +1084,10 @@ static bool alc_auto_mic_check_imux(struct hda_codec *codec)
                 return false; /* no corresponding imux */
         }
 
-        snd_hda_codec_write_cache(codec, spec->ext_mic_pin, 0,
-                                  AC_VERB_SET_UNSOLICITED_ENABLE,
-                                  AC_USRSP_EN | ALC_MIC_EVENT);
+        snd_hda_jack_detect_enable(codec, spec->ext_mic_pin, ALC_MIC_EVENT);
         if (spec->dock_mic_pin)
-                snd_hda_codec_write_cache(codec, spec->dock_mic_pin, 0,
-                                  AC_VERB_SET_UNSOLICITED_ENABLE,
-                                  AC_USRSP_EN | ALC_MIC_EVENT);
+                snd_hda_jack_detect_enable(codec, spec->dock_mic_pin,
+                                           ALC_MIC_EVENT);
 
         spec->auto_mic_valid_imux = 1;
         spec->auto_mic = 1;
@@ -2074,6 +2029,10 @@ static int alc_build_controls(struct hda_codec *codec)
 
         alc_free_kctls(codec); /* no longer needed */
 
+        err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
         return 0;
 }
 
@@ -2101,6 +2060,8 @@ static int alc_init(struct hda_codec *codec)
 
         alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
 
+        snd_hda_jack_report_sync(codec);
+
         hda_call_check_power_status(codec, 0x01);
         return 0;
 }
@@ -2484,7 +2445,6 @@ static void alc_free(struct hda_codec *codec)
                 return;
 
         alc_shutup(codec);
-        snd_hda_input_jack_free(codec);
         alc_free_kctls(codec);
         alc_free_bind_ctls(codec);
         kfree(spec);
@@ -3944,6 +3904,7 @@ static void set_capture_mixer(struct hda_codec *codec)
 static void alc_auto_init_std(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
+        spec->use_jack_tbl = 1;
         alc_auto_init_multi_out(codec);
         alc_auto_init_extra_out(codec);
         alc_auto_init_analog_input(codec);
@@ -4731,7 +4692,6 @@ static int patch_alc882(struct hda_codec *codec)
         if (board_config == ALC_MODEL_AUTO)
                 spec->init_hook = alc_auto_init_std;
 
-        alc_init_jacks(codec);
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc882_loopbacks;
@@ -4909,7 +4869,6 @@ static int patch_alc262(struct hda_codec *codec)
         spec->init_hook = alc_auto_init_std;
         spec->shutup = alc_eapd_shutup;
 
-        alc_init_jacks(codec);
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc262_loopbacks;
@@ -5020,8 +4979,6 @@ static int patch_alc268(struct hda_codec *codec)
         spec->init_hook = alc_auto_init_std;
         spec->shutup = alc_eapd_shutup;
 
-        alc_init_jacks(codec);
-
         return 0;
 
  error:
@@ -5577,7 +5534,6 @@ static int patch_alc269(struct hda_codec *codec)
         spec->init_hook = alc_auto_init_std;
         spec->shutup = alc269_shutup;
 
-        alc_init_jacks(codec);
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc269_loopbacks;
@@ -6187,8 +6143,6 @@ static int patch_alc662(struct hda_codec *codec)
         spec->init_hook = alc_auto_init_std;
         spec->shutup = alc_eapd_shutup;
 
-        alc_init_jacks(codec);
-
 #ifdef CONFIG_SND_HDA_POWER_SAVE
         if (!spec->loopback.amplist)
                 spec->loopback.amplist = alc662_loopbacks;
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index aaed004eacc5..03145aec65f1 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -37,6 +37,7 @@
 #include "hda_codec.h"
 #include "hda_local.h"
 #include "hda_beep.h"
+#include "hda_jack.h"
 
 enum {
         STAC_VREF_EVENT = 1,
@@ -175,13 +176,6 @@ enum {
         STAC_9872_MODELS
 };
 
-struct sigmatel_event {
-        hda_nid_t nid;
-        unsigned char type;
-        unsigned char tag;
-        int data;
-};
-
 struct sigmatel_mic_route {
         hda_nid_t pin;
         signed char mux_idx;
@@ -230,9 +224,6 @@ struct sigmatel_spec {
         const hda_nid_t *pwr_nids;
         const hda_nid_t *dac_list;
 
-        /* events */
-        struct snd_array events;
-
         /* playback */
         struct hda_input_mux *mono_mux;
         unsigned int cur_mmux;
@@ -1093,13 +1084,10 @@ static const char * const slave_sws[] = {
 };
 
 static void stac92xx_free_kctls(struct hda_codec *codec);
-static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
 
 static int stac92xx_build_controls(struct hda_codec *codec)
 {
         struct sigmatel_spec *spec = codec->spec;
-        struct auto_pin_cfg *cfg = &spec->autocfg;
-        hda_nid_t nid;
         int err;
         int i;
 
@@ -1185,31 +1173,9 @@ static int stac92xx_build_controls(struct hda_codec *codec)
 
         stac92xx_free_kctls(codec); /* no longer needed */
 
-        /* create jack input elements */
-        if (spec->hp_detect) {
-                for (i = 0; i < cfg->hp_outs; i++) {
-                        int type = SND_JACK_HEADPHONE;
-                        nid = cfg->hp_pins[i];
-                        /* jack detection */
-                        if (cfg->hp_outs == i)
-                                type |= SND_JACK_LINEOUT;
-                        err = stac92xx_add_jack(codec, nid, type);
-                        if (err < 0)
-                                return err;
-                }
-        }
-        for (i = 0; i < cfg->line_outs; i++) {
-                err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
-                                        SND_JACK_LINEOUT);
-                if (err < 0)
-                        return err;
-        }
-        for (i = 0; i < cfg->num_inputs; i++) {
-                nid = cfg->inputs[i].pin;
-                err = stac92xx_add_jack(codec, nid, SND_JACK_MICROPHONE);
-                if (err < 0)
-                        return err;
-        }
+        err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
+        if (err < 0)
+                return err;
 
         return 0;       
 }
@@ -2871,7 +2837,8 @@ static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
         }
 
         if (control) {
-                strcpy(name, hda_get_input_pin_label(codec, nid, 1));
+                snd_hda_get_pin_label(codec, nid, &spec->autocfg,
+                                      name, sizeof(name), NULL);
                 return stac92xx_add_control(codec->spec, control,
                                         strcat(name, " Jack Mode"), nid);
         }
@@ -3549,7 +3516,7 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
         for (i = 0; i < spec->num_dmics; i++) {
                 hda_nid_t nid;
                 int index, type_idx;
-                const char *label;
+                char label[32];
 
                 nid = spec->dmic_nids[i];
                 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
@@ -3562,7 +3529,8 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
                 if (index < 0)
                         continue;
 
-                label = hda_get_input_pin_label(codec, nid, 1);
+                snd_hda_get_pin_label(codec, nid, &spec->autocfg,
+                                      label, sizeof(label), NULL);
                 snd_hda_add_imux_item(dimux, label, index, &type_idx);
                 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1)
                         snd_hda_add_imux_item(imux, label, index, &type_idx);
@@ -4160,65 +4128,18 @@ static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
                            AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
 }
 
-static int stac92xx_add_jack(struct hda_codec *codec,
-                hda_nid_t nid, int type)
-{
-#ifdef CONFIG_SND_HDA_INPUT_JACK
-        int def_conf = snd_hda_codec_get_pincfg(codec, nid);
-        int connectivity = get_defcfg_connect(def_conf);
-
-        if (connectivity && connectivity != AC_JACK_PORT_FIXED)
-                return 0;
-
-        return snd_hda_input_jack_add(codec, nid, type, NULL);
-#else
-        return 0;
-#endif /* CONFIG_SND_HDA_INPUT_JACK */
-}
-
-static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
+static int stac_add_event(struct hda_codec *codec, hda_nid_t nid,
                           unsigned char type, int data)
 {
-        struct sigmatel_event *event;
+        struct hda_jack_tbl *event;
 
-        snd_array_init(&spec->events, sizeof(*event), 32);
-        event = snd_array_new(&spec->events);
+        event = snd_hda_jack_tbl_new(codec, nid);
         if (!event)
                 return -ENOMEM;
-        event->nid = nid;
-        event->type = type;
-        event->tag = spec->events.used;
-        event->data = data;
-
-        return event->tag;
-}
-
-static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
-                                             hda_nid_t nid)
-{
-        struct sigmatel_spec *spec = codec->spec;
-        struct sigmatel_event *event = spec->events.list;
-        int i;
-
-        for (i = 0; i < spec->events.used; i++, event++) {
-                if (event->nid == nid)
-                        return event;
-        }
-        return NULL;
-}
-
-static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
-                                                      unsigned char tag)
-{
-        struct sigmatel_spec *spec = codec->spec;
-        struct sigmatel_event *event = spec->events.list;
-        int i;
+        event->action = type;
+        event->private_data = data;
 
-        for (i = 0; i < spec->events.used; i++, event++) {
-                if (event->tag == tag)
-                        return event;
-        }
-        return NULL;
+        return 0;
 }
 
 /* check if given nid is a valid pin and no other events are assigned
@@ -4228,24 +4149,17 @@ static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
 static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
                              unsigned int type)
 {
-        struct sigmatel_event *event;
-        int tag;
+        struct hda_jack_tbl *event;
 
         if (!is_jack_detectable(codec, nid))
                 return 0;
-        event = stac_get_event(codec, nid);
-        if (event) {
-                if (event->type != type)
-                        return 0;
-                tag = event->tag;
-        } else {
-                tag = stac_add_event(codec->spec, nid, type, 0);
-                if (tag < 0)
-                        return 0;
-        }
-        snd_hda_codec_write_cache(codec, nid, 0,
-                                  AC_VERB_SET_UNSOLICITED_ENABLE,
-                                  AC_USRSP_EN | tag);
+        event = snd_hda_jack_tbl_new(codec, nid);
+        if (!event)
+                return -ENOMEM;
+        if (event->action && event->action != type)
+                return 0;
+        event->action = type;
+        snd_hda_jack_detect_enable(codec, nid, 0);
         return 1;
 }
 
@@ -4473,6 +4387,8 @@ static int stac92xx_init(struct hda_codec *codec)
                 stac_toggle_power_map(codec, nid, 0);
         }
 
+        snd_hda_jack_report_sync(codec);
+
         /* sync mute LED */
         if (spec->gpio_led)
                 hda_call_check_power_status(codec, 0x01);
@@ -4529,8 +4445,6 @@ static void stac92xx_free(struct hda_codec *codec)
                 return;
 
         stac92xx_shutup(codec);
-        snd_hda_input_jack_free(codec);
-        snd_array_free(&spec->events);
 
         kfree(spec);
         snd_hda_detach_beep_device(codec);
@@ -4794,26 +4708,13 @@ static void stac92xx_mic_detect(struct hda_codec *codec)
                                           mic->mux_idx);
 }
 
-static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
-{
-        struct sigmatel_event *event = stac_get_event(codec, nid);
-        if (!event)
-                return;
-        codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
-}
-
-static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
+static void handle_unsol_event(struct hda_codec *codec,
+                               struct hda_jack_tbl *event)
 {
         struct sigmatel_spec *spec = codec->spec;
-        struct sigmatel_event *event;
-        int tag, data;
-
-        tag = (res >> 26) & 0x7f;
-        event = stac_get_event_from_tag(codec, tag);
-        if (!event)
-                return;
+        int data;
 
-        switch (event->type) {
+        switch (event->action) {
         case STAC_HP_EVENT:
         case STAC_LO_EVENT:
                 stac92xx_hp_detect(codec);
@@ -4823,7 +4724,7 @@ static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
                 break;
         }
 
-        switch (event->type) {
+        switch (event->action) {
         case STAC_HP_EVENT:
         case STAC_LO_EVENT:
         case STAC_MIC_EVENT:
@@ -4831,7 +4732,6 @@ static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
         case STAC_PWR_EVENT:
                 if (spec->num_pwrs > 0)
                         stac92xx_pin_sense(codec, event->nid);
-                snd_hda_input_jack_report(codec, event->nid);
 
                 switch (codec->subsystem_id) {
                 case 0x103c308f:
@@ -4856,11 +4756,33 @@ static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
                                           AC_VERB_GET_GPIO_DATA, 0);
                 /* toggle VREF state based on GPIOx status */
                 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
-                                    !!(data & (1 << event->data)));
+                                    !!(data & (1 << event->private_data)));
                 break;
         }
 }
 
+static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
+{
+        struct hda_jack_tbl *event = snd_hda_jack_tbl_get(codec, nid);
+        if (!event)
+                return;
+        handle_unsol_event(codec, event);
+}
+
+static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
+{
+        struct hda_jack_tbl *event;
+        int tag;
+
+        tag = (res >> 26) & 0x7f;
+        event = snd_hda_jack_tbl_get_from_tag(codec, tag);
+        if (!event)
+                return;
+        event->jack_dirty = 1;
+        handle_unsol_event(codec, event);
+        snd_hda_jack_report_sync(codec);
+}
+
 static int hp_blike_system(u32 subsystem_id);
 
 static void set_hp_led_gpio(struct hda_codec *codec)
@@ -5837,15 +5759,13 @@ again:
                 switch (spec->board_config) {
                 case STAC_HP_M4:
                         /* Enable VREF power saving on GPIO1 detect */
-                        err = stac_add_event(spec, codec->afg,
+                        err = stac_add_event(codec, codec->afg,
                                              STAC_VREF_EVENT, 0x02);
                         if (err < 0)
                                 return err;
                         snd_hda_codec_write_cache(codec, codec->afg, 0,
                                 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
-                        snd_hda_codec_write_cache(codec, codec->afg, 0,
-                                AC_VERB_SET_UNSOLICITED_ENABLE,
-                                AC_USRSP_EN | err);
+                        snd_hda_jack_detect_enable(codec, codec->afg, 0);
                         spec->gpio_mask |= 0x02;
                         break;
                 }
@@ -6316,14 +6236,12 @@ static int patch_stac9205(struct hda_codec *codec)
                 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
 
                 /* Enable unsol response for GPIO4/Dock HP connection */
-                err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
+                err = stac_add_event(codec, codec->afg, STAC_VREF_EVENT, 0x01);
                 if (err < 0)
                         return err;
                 snd_hda_codec_write_cache(codec, codec->afg, 0,
                         AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
-                snd_hda_codec_write_cache(codec, codec->afg, 0,
-                                          AC_VERB_SET_UNSOLICITED_ENABLE,
-                                          AC_USRSP_EN | err);
+                snd_hda_jack_detect_enable(codec, codec->afg, 0);
 
                 spec->gpio_dir = 0x0b;
                 spec->eapd_mask = 0x01;
diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c
index b5137629f8e9..ab56866cc94e 100644
--- a/sound/pci/hda/patch_via.c
+++ b/sound/pci/hda/patch_via.c
@@ -54,6 +54,7 @@
 #include <sound/asoundef.h>
 #include "hda_codec.h"
 #include "hda_local.h"
+#include "hda_jack.h"
 
 /* Pin Widget NID */
 #define VT1708_HP_PIN_NID       0x20
@@ -1503,6 +1504,11 @@ static int via_build_controls(struct hda_codec *codec)
         analog_low_current_mode(codec);
 
         via_free_kctls(codec); /* no longer needed */
+
+        err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
         return 0;
 }
 
@@ -1714,6 +1720,7 @@ static void via_unsol_event(struct hda_codec *codec,
                                   unsigned int res)
 {
         res >>= 26;
+        res = snd_hda_jack_get_action(codec, res);
 
         if (res & VIA_JACK_EVENT)
                 set_widgets_power_state(codec);
@@ -1724,6 +1731,7 @@ static void via_unsol_event(struct hda_codec *codec,
                 via_hp_automute(codec);
         else if (res == VIA_GPIO_EVENT)
                 via_gpio_control(codec);
+        snd_hda_jack_report_sync(codec);
 }
 
 #ifdef CONFIG_PM
@@ -2736,9 +2744,8 @@ static void via_auto_init_unsol_event(struct hda_codec *codec)
         int i;
 
         if (cfg->hp_pins[0] && is_jack_detectable(codec, cfg->hp_pins[0]))
-                snd_hda_codec_write(codec, cfg->hp_pins[0], 0,
-                                AC_VERB_SET_UNSOLICITED_ENABLE,
-                                AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT);
+                snd_hda_jack_detect_enable(codec, cfg->hp_pins[0],
+                                           VIA_HP_EVENT | VIA_JACK_EVENT);
 
         if (cfg->speaker_pins[0])
                 ev = VIA_LINE_EVENT;
@@ -2747,16 +2754,14 @@ static void via_auto_init_unsol_event(struct hda_codec *codec)
         for (i = 0; i < cfg->line_outs; i++) {
                 if (cfg->line_out_pins[i] &&
                     is_jack_detectable(codec, cfg->line_out_pins[i]))
-                        snd_hda_codec_write(codec, cfg->line_out_pins[i], 0,
-                                AC_VERB_SET_UNSOLICITED_ENABLE,
-                                AC_USRSP_EN | ev | VIA_JACK_EVENT);
+                        snd_hda_jack_detect_enable(codec, cfg->line_out_pins[i],
+                                                   ev | VIA_JACK_EVENT);
         }
 
         for (i = 0; i < cfg->num_inputs; i++) {
                 if (is_jack_detectable(codec, cfg->inputs[i].pin))
-                        snd_hda_codec_write(codec, cfg->inputs[i].pin, 0,
-                                AC_VERB_SET_UNSOLICITED_ENABLE,
-                                AC_USRSP_EN | VIA_JACK_EVENT);
+                        snd_hda_jack_detect_enable(codec, cfg->inputs[i].pin,
+                                                   VIA_JACK_EVENT);
         }
 }
 
@@ -2779,6 +2784,7 @@ static int via_init(struct hda_codec *codec)
 
         via_hp_automute(codec);
         vt1708_update_hp_work(spec);
+        snd_hda_jack_report_sync(codec);
 
         return 0;
 }
@@ -2789,6 +2795,7 @@ static void vt1708_update_hp_jack_state(struct work_struct *work)
                                              vt1708_hp_work.work);
         if (spec->codec_type != VT1708)
                 return;
+        snd_hda_jack_set_dirty_all(spec->codec);
         /* if jack state toggled */
         if (spec->vt1708_hp_present
             != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) {