Merge branch 'topic/hda-gateway' into topic/hda
[sfrench/cifs-2.6.git] / sound / pci / hda / patch_sigmatel.c
index c05d4643afd51cdbeb5729a6fea7221306cabfe8..0e6fc56fa3787c37510a8554ac4c9ef073bf715b 100644 (file)
@@ -70,6 +70,7 @@ enum {
 };
 
 enum {
+       STAC_92HD73XX_NO_JD, /* no jack-detection */
        STAC_92HD73XX_REF,
        STAC_DELL_M6_AMIC,
        STAC_DELL_M6_DMIC,
@@ -132,6 +133,7 @@ enum {
 };
 
 enum {
+       STAC_D965_REF_NO_JD, /* no jack-detection */
        STAC_D965_REF,
        STAC_D965_3ST,
        STAC_D965_5ST,
@@ -160,8 +162,6 @@ struct sigmatel_spec {
        int board_config;
        unsigned int eapd_switch: 1;
        unsigned int surr_switch: 1;
-       unsigned int line_switch: 1;
-       unsigned int mic_switch: 1;
        unsigned int alt_switch: 1;
        unsigned int hp_detect: 1;
        unsigned int spdif_mute: 1;
@@ -198,6 +198,8 @@ struct sigmatel_spec {
        unsigned int cur_mmux;
        struct hda_multi_out multiout;
        hda_nid_t dac_nids[5];
+       hda_nid_t hp_dacs[5];
+       hda_nid_t speaker_dacs[5];
 
        /* capture */
        hda_nid_t *adc_nids;
@@ -241,7 +243,9 @@ struct sigmatel_spec {
        /* i/o switches */
        unsigned int io_switch[2];
        unsigned int clfe_swap;
-       unsigned int hp_switch; /* NID of HP as line-out */
+       hda_nid_t line_switch;  /* shared line-in for input and output */
+       hda_nid_t mic_switch;   /* shared mic-in for input and output */
+       hda_nid_t hp_switch; /* NID of HP as line-out */
        unsigned int aloopback;
 
        struct hda_pcm pcm_rec[2];      /* PCM information */
@@ -292,9 +296,6 @@ static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
 };
 
 #define STAC92HD73_DAC_COUNT 5
-static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
-       0x15, 0x16, 0x17, 0x18, 0x19,
-};
 
 static hda_nid_t stac92hd73xx_mux_nids[4] = {
        0x28, 0x29, 0x2a, 0x2b,
@@ -313,11 +314,7 @@ static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
        0x11, 0x12, 0
 };
 
-#define STAC92HD81_DAC_COUNT 2
 #define STAC92HD83_DAC_COUNT 3
-static hda_nid_t stac92hd83xxx_dac_nids[STAC92HD73_DAC_COUNT] = {
-       0x13, 0x14, 0x22,
-};
 
 static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
        0x17, 0x18,
@@ -359,10 +356,6 @@ static hda_nid_t stac92hd71bxx_smux_nids[2] = {
        0x24, 0x25,
 };
 
-static hda_nid_t stac92hd71bxx_dac_nids[1] = {
-       0x10, /*0x11, */
-};
-
 #define STAC92HD71BXX_NUM_DMICS        2
 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
        0x18, 0x19, 0
@@ -594,12 +587,12 @@ static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
                else
                        nid = codec->slave_dig_outs[smux_idx - 1];
                if (spec->cur_smux[smux_idx] == smux->num_items - 1)
-                       val = AMP_OUT_MUTE;
+                       val = HDA_AMP_MUTE;
                else
-                       val = AMP_OUT_UNMUTE;
+                       val = 0;
                /* un/mute SPDIF out */
-               snd_hda_codec_write_cache(codec, nid, 0,
-                       AC_VERB_SET_AMP_GAIN_MUTE, val);
+               snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
+                                        HDA_AMP_MUTE, val);
        }
        return 0;
 }
@@ -764,10 +757,6 @@ static struct hda_verb stac9200_eapd_init[] = {
 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
        /* set master volume and direct control */
        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-       /* setup audio connections */
-       { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
-       { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
-       { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
        /* setup adcs to point to mixer */
        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
        { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
@@ -786,10 +775,6 @@ static struct hda_verb dell_eq_core_init[] = {
        /* set master volume to max value without distortion
         * and direct control */
        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
-       /* setup audio connections */
-       { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
-       { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x02},
-       { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01},
        /* setup adcs to point to mixer */
        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
        { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
@@ -803,10 +788,6 @@ static struct hda_verb dell_eq_core_init[] = {
 
 static struct hda_verb dell_m6_core_init[] = {
        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-       /* setup audio connections */
-       { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
-       { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
-       { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x02},
        /* setup adcs to point to mixer */
        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
        { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
@@ -821,13 +802,6 @@ static struct hda_verb dell_m6_core_init[] = {
 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
        /* set master volume and direct control */
        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-       /* setup audio connections */
-       { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
-       { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
-       { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
-       /* connect hp ports to dac3 */
-       { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
-       { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
        /* setup adcs to point to mixer */
        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
        { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
@@ -845,15 +819,8 @@ static struct hda_verb stac92hd73xx_8ch_core_init[] = {
 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
        /* set master volume and direct control */
        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-       /* setup audio connections */
-       { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
-       { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
-       { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
        /* dac3 is connected to import3 mux */
        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
-       /* connect hp ports to dac4 */
-       { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
-       { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
        /* setup adcs to point to mixer */
        { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
        { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
@@ -879,17 +846,17 @@ static struct hda_verb stac92hd83xxx_core_init[] = {
 
        /* power state controls amps */
        { 0x01, AC_VERB_SET_EAPD, 1 << 2},
+       {}
 };
 
 static struct hda_verb stac92hd71bxx_core_init[] = {
        /* set master volume and direct control */
        { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-       /* connect headphone jack to dac1 */
-       { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
        /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
        { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
        { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
        { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+       {}
 };
 
 #define HD_DISABLE_PORTF 2
@@ -904,8 +871,6 @@ static struct hda_verb stac92hd71bxx_analog_core_init[] = {
 
        /* set master volume and direct control */
        { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
-       /* connect headphone jack to dac1 */
-       { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
        /* unmute right and left channels for nodes 0x0a, 0xd */
        { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
        { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
@@ -1105,21 +1070,21 @@ static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
        HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_OUTPUT),
        HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),
 
-       HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0, HDA_INPUT),
-       HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0, HDA_INPUT),
+       HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0x3, HDA_INPUT),
+       HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0x3, HDA_INPUT),
 
-       HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x1, HDA_INPUT),
-       HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x1, HDA_INPUT),
+       HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x4, HDA_INPUT),
+       HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x4, HDA_INPUT),
 
-       HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x2, HDA_INPUT),
-       HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x2, HDA_INPUT),
+       HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x0, HDA_INPUT),
+       HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x0, HDA_INPUT),
 
-       HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x3, HDA_INPUT),
-       HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x3, HDA_INPUT),
+       HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x2, HDA_INPUT),
+       HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x2, HDA_INPUT),
 
        /*
-       HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x4, HDA_INPUT),
-       HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x4, HDA_INPUT),
+       HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x1, HDA_INPUT),
+       HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x1, HDA_INPUT),
        */
        { } /* end */
 };
@@ -1296,7 +1261,7 @@ static int stac92xx_build_controls(struct hda_codec *codec)
                        spec->spdif_mute = 1;
                }
                stac_smux_mixer.count = spec->num_smuxes;
-               err = snd_ctl_add(codec->bus->card,
+               err = snd_hda_ctl_add(codec,
                                  snd_ctl_new1(&stac_smux_mixer, codec));
                if (err < 0)
                        return err;
@@ -1720,6 +1685,7 @@ static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
 };
 
 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
+       [STAC_92HD73XX_NO_JD] = "no-jd",
        [STAC_92HD73XX_REF] = "ref",
        [STAC_DELL_M6_AMIC] = "dell-m6-amic",
        [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
@@ -1749,6 +1715,8 @@ static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
                                "unknown Dell", STAC_DELL_M6_DMIC),
        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
                                "Dell Studio 1537", STAC_DELL_M6_DMIC),
+       SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
+                               "Dell Studio 17", STAC_DELL_M6_DMIC),
        {} /* terminator */
 };
 
@@ -1770,7 +1738,8 @@ static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
        /* SigmaTel reference board */
        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
-                     "DFI LanParty", STAC_92HD71BXX_REF),
+                     "DFI LanParty", STAC_92HD83XXX_REF),
+       {} /* terminator */
 };
 
 static unsigned int ref92hd71bxx_pin_configs[11] = {
@@ -1821,6 +1790,10 @@ static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
                      "HP dv5", STAC_HP_M4),
        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f4,
                      "HP dv7", STAC_HP_M4),
+       SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fc,
+                     "HP dv7", STAC_HP_M4),
+       SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3603,
+                     "HP dv5", STAC_HP_M4),
        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
                                "unknown HP", STAC_HP_M4),
        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
@@ -2136,6 +2109,7 @@ static unsigned int dell_3st_pin_configs[14] = {
 };
 
 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
+       [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
        [STAC_D965_REF]  = ref927x_pin_configs,
        [STAC_D965_3ST]  = d965_3st_pin_configs,
        [STAC_D965_5ST]  = d965_5st_pin_configs,
@@ -2144,6 +2118,7 @@ static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
 };
 
 static const char *stac927x_models[STAC_927X_MODELS] = {
+       [STAC_D965_REF_NO_JD]   = "ref-no-jd",
        [STAC_D965_REF]         = "ref",
        [STAC_D965_3ST]         = "3stack",
        [STAC_D965_5ST]         = "5stack",
@@ -2468,7 +2443,7 @@ static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
 
        if (spec->powerdown_adcs) {
                msleep(40);
-               snd_hda_codec_write_cache(codec, nid, 0,
+               snd_hda_codec_write(codec, nid, 0,
                        AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
        }
        snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
@@ -2484,7 +2459,7 @@ static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
 
        snd_hda_codec_cleanup_stream(codec, nid);
        if (spec->powerdown_adcs)
-               snd_hda_codec_write_cache(codec, nid, 0,
+               snd_hda_codec_write(codec, nid, 0,
                        AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
        return 0;
 }
@@ -2796,70 +2771,53 @@ static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
        return stac92xx_add_control_idx(spec, type, 0, name, val);
 }
 
-/* flag inputs as additional dynamic lineouts */
-static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
+/* check whether the line-input can be used as line-out */
+static hda_nid_t check_line_out_switch(struct hda_codec *codec)
 {
        struct sigmatel_spec *spec = codec->spec;
-       unsigned int wcaps, wtype;
-       int i, num_dacs = 0;
-       
-       /* use the wcaps cache to count all DACs available for line-outs */
-       for (i = 0; i < codec->num_nodes; i++) {
-               wcaps = codec->wcaps[i];
-               wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
+       struct auto_pin_cfg *cfg = &spec->autocfg;
+       hda_nid_t nid;
+       unsigned int pincap;
 
-               if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
-                       num_dacs++;
-       }
+       if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
+               return 0;
+       nid = cfg->input_pins[AUTO_PIN_LINE];
+       pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
+       if (pincap & AC_PINCAP_OUT)
+               return nid;
+       return 0;
+}
 
-       snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
-       
-       switch (cfg->line_outs) {
-       case 3:
-               /* add line-in as side */
-               if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
-                       cfg->line_out_pins[cfg->line_outs] =
-                               cfg->input_pins[AUTO_PIN_LINE];
-                       spec->line_switch = 1;
-                       cfg->line_outs++;
-               }
-               break;
-       case 2:
-               /* add line-in as clfe and mic as side */
-               if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
-                       cfg->line_out_pins[cfg->line_outs] =
-                               cfg->input_pins[AUTO_PIN_LINE];
-                       spec->line_switch = 1;
-                       cfg->line_outs++;
-               }
-               if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
-                       cfg->line_out_pins[cfg->line_outs] =
-                               cfg->input_pins[AUTO_PIN_MIC];
-                       spec->mic_switch = 1;
-                       cfg->line_outs++;
-               }
-               break;
-       case 1:
-               /* add line-in as surr and mic as clfe */
-               if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
-                       cfg->line_out_pins[cfg->line_outs] =
-                               cfg->input_pins[AUTO_PIN_LINE];
-                       spec->line_switch = 1;
-                       cfg->line_outs++;
-               }
-               if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
-                       cfg->line_out_pins[cfg->line_outs] =
-                               cfg->input_pins[AUTO_PIN_MIC];
-                       spec->mic_switch = 1;
-                       cfg->line_outs++;
+/* check whether the mic-input can be used as line-out */
+static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
+{
+       struct sigmatel_spec *spec = codec->spec;
+       struct auto_pin_cfg *cfg = &spec->autocfg;
+       unsigned int def_conf, pincap;
+       unsigned int mic_pin;
+
+       if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
+               return 0;
+       mic_pin = AUTO_PIN_MIC;
+       for (;;) {
+               hda_nid_t nid = cfg->input_pins[mic_pin];
+               def_conf = snd_hda_codec_read(codec, nid, 0,
+                                             AC_VERB_GET_CONFIG_DEFAULT, 0);
+               /* some laptops have an internal analog microphone
+                * which can't be used as a output */
+               if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
+                       pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
+                       if (pincap & AC_PINCAP_OUT)
+                               return nid;
                }
-               break;
+               if (mic_pin == AUTO_PIN_MIC)
+                       mic_pin = AUTO_PIN_FRONT_MIC;
+               else
+                       break;
        }
-
        return 0;
 }
 
-
 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
 {
        int i;
@@ -2872,6 +2830,52 @@ static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
        return 0;
 }
 
+static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
+{
+       int i;
+       if (is_in_dac_nids(spec, nid))
+               return 1;
+       for (i = 0; i < spec->autocfg.hp_outs; i++)
+               if (spec->hp_dacs[i] == nid)
+                       return 1;
+       for (i = 0; i < spec->autocfg.speaker_outs; i++)
+               if (spec->speaker_dacs[i] == nid)
+                       return 1;
+       return 0;
+}
+
+static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
+{
+       struct sigmatel_spec *spec = codec->spec;
+       int j, conn_len;
+       hda_nid_t conn[HDA_MAX_CONNECTIONS];
+       unsigned int wcaps, wtype;
+
+       conn_len = snd_hda_get_connections(codec, nid, conn,
+                                          HDA_MAX_CONNECTIONS);
+       for (j = 0; j < conn_len; j++) {
+               wcaps = snd_hda_param_read(codec, conn[j],
+                                          AC_PAR_AUDIO_WIDGET_CAP);
+               wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
+               /* we check only analog outputs */
+               if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
+                       continue;
+               /* if this route has a free DAC, assign it */
+               if (!check_all_dac_nids(spec, conn[j])) {
+                       if (conn_len > 1) {
+                               /* select this DAC in the pin's input mux */
+                               snd_hda_codec_write_cache(codec, nid, 0,
+                                                 AC_VERB_SET_CONNECT_SEL, j);
+                       }
+                       return conn[j];
+               }
+       }
+       return 0;
+}
+
+static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
+static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
+
 /*
  * Fill in the dac_nids table from the parsed pin configuration
  * This function only works when every pin in line_out_pins[]
@@ -2879,31 +2883,17 @@ static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
  * codecs are not connected directly to a DAC, such as the 9200
  * and 9202/925x. For those, dac_nids[] must be hard-coded.
  */
-static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
-                                      struct auto_pin_cfg *cfg)
+static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
 {
        struct sigmatel_spec *spec = codec->spec;
-       int i, j, conn_len = 0; 
-       hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
-       unsigned int wcaps, wtype;
+       struct auto_pin_cfg *cfg = &spec->autocfg;
+       int i;
+       hda_nid_t nid, dac;
        
        for (i = 0; i < cfg->line_outs; i++) {
                nid = cfg->line_out_pins[i];
-               conn_len = snd_hda_get_connections(codec, nid, conn,
-                                                  HDA_MAX_CONNECTIONS);
-               for (j = 0; j < conn_len; j++) {
-                       wcaps = snd_hda_param_read(codec, conn[j],
-                                                  AC_PAR_AUDIO_WIDGET_CAP);
-                       wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
-                       if (wtype != AC_WID_AUD_OUT ||
-                           (wcaps & AC_WCAP_DIGITAL))
-                               continue;
-                       /* conn[j] is a DAC routed to this line-out */
-                       if (!is_in_dac_nids(spec, conn[j]))
-                               break;
-               }
-
-               if (j == conn_len) {
+               dac = get_unassigned_dac(codec, nid);
+               if (!dac) {
                        if (spec->multiout.num_dacs > 0) {
                                /* we have already working output pins,
                                 * so let's drop the broken ones again
@@ -2917,24 +2907,64 @@ static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
                                   __func__, nid);
                        return -ENODEV;
                }
+               add_spec_dacs(spec, dac);
+       }
 
-               spec->multiout.dac_nids[i] = conn[j];
-               spec->multiout.num_dacs++;
-               if (conn_len > 1) {
-                       /* select this DAC in the pin's input mux */
-                       snd_hda_codec_write_cache(codec, nid, 0,
-                                                 AC_VERB_SET_CONNECT_SEL, j);
+       /* add line-in as output */
+       nid = check_line_out_switch(codec);
+       if (nid) {
+               dac = get_unassigned_dac(codec, nid);
+               if (dac) {
+                       snd_printdd("STAC: Add line-in 0x%x as output %d\n",
+                                   nid, cfg->line_outs);
+                       cfg->line_out_pins[cfg->line_outs] = nid;
+                       cfg->line_outs++;
+                       spec->line_switch = nid;
+                       add_spec_dacs(spec, dac);
+               }
+       }
+       /* add mic as output */
+       nid = check_mic_out_switch(codec);
+       if (nid) {
+               dac = get_unassigned_dac(codec, nid);
+               if (dac) {
+                       snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
+                                   nid, cfg->line_outs);
+                       cfg->line_out_pins[cfg->line_outs] = nid;
+                       cfg->line_outs++;
+                       spec->mic_switch = nid;
+                       add_spec_dacs(spec, dac);
+               }
+       }
 
+       for (i = 0; i < cfg->hp_outs; i++) {
+               nid = cfg->hp_pins[i];
+               dac = get_unassigned_dac(codec, nid);
+               if (dac) {
+                       if (!spec->multiout.hp_nid)
+                               spec->multiout.hp_nid = dac;
+                       else
+                               add_spec_extra_dacs(spec, dac);
                }
+               spec->hp_dacs[i] = dac;
        }
 
-       snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
+       for (i = 0; i < cfg->speaker_outs; i++) {
+               nid = cfg->speaker_pins[i];
+               dac = get_unassigned_dac(codec, nid);
+               if (dac)
+                       add_spec_extra_dacs(spec, dac);
+               spec->speaker_dacs[i] = dac;
+       }
+
+       snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
                   spec->multiout.num_dacs,
                   spec->multiout.dac_nids[0],
                   spec->multiout.dac_nids[1],
                   spec->multiout.dac_nids[2],
                   spec->multiout.dac_nids[3],
                   spec->multiout.dac_nids[4]);
+
        return 0;
 }
 
@@ -2959,9 +2989,7 @@ static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_
 
 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
 {
-       if (!spec->multiout.hp_nid)
-               spec->multiout.hp_nid = nid;
-       else if (spec->multiout.num_dacs > 4) {
+       if (spec->multiout.num_dacs > 4) {
                printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
                return 1;
        } else {
@@ -2971,35 +2999,47 @@ static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
        return 0;
 }
 
-static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
+static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
 {
-       if (is_in_dac_nids(spec, nid))
-               return 1;
+       int i;
+       for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
+               if (!spec->multiout.extra_out_nid[i]) {
+                       spec->multiout.extra_out_nid[i] = nid;
+                       return 0;
+               }
+       }
+       printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
+       return 1;
+}
+
+static int is_unique_dac(struct sigmatel_spec *spec, hda_nid_t nid)
+{
+       int i;
+
+       if (spec->autocfg.line_outs != 1)
+               return 0;
        if (spec->multiout.hp_nid == nid)
-               return 1;
-       return 0;
+               return 0;
+       for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++)
+               if (spec->multiout.extra_out_nid[i] == nid)
+                       return 0;
+       return 1;
 }
 
 /* add playback controls from the parsed DAC table */
 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
                                               const struct auto_pin_cfg *cfg)
 {
+       struct sigmatel_spec *spec = codec->spec;
        static const char *chname[4] = {
                "Front", "Surround", NULL /*CLFE*/, "Side"
        };
        hda_nid_t nid = 0;
        int i, err;
+       unsigned int wid_caps;
 
-       struct sigmatel_spec *spec = codec->spec;
-       unsigned int wid_caps, pincap;
-
-
-       for (i = 0; i < cfg->line_outs && i < spec->multiout.num_dacs; i++) {
-               if (!spec->multiout.dac_nids[i])
-                       continue;
-
+       for (i = 0; i < cfg->line_outs && spec->multiout.dac_nids[i]; i++) {
                nid = spec->multiout.dac_nids[i];
-
                if (i == 2) {
                        /* Center/LFE */
                        err = create_controls(spec, "Center", nid, 1);
@@ -3021,16 +3061,24 @@ static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
                        }
 
                } else {
-                       err = create_controls(spec, chname[i], nid, 3);
+                       const char *name = chname[i];
+                       /* if it's a single DAC, assign a better name */
+                       if (!i && is_unique_dac(spec, nid)) {
+                               switch (cfg->line_out_type) {
+                               case AUTO_PIN_HP_OUT:
+                                       name = "Headphone";
+                                       break;
+                               case AUTO_PIN_SPEAKER_OUT:
+                                       name = "Speaker";
+                                       break;
+                               }
+                       }
+                       err = create_controls(spec, name, nid, 3);
                        if (err < 0)
                                return err;
                }
        }
 
-       if ((spec->multiout.num_dacs - cfg->line_outs) > 0 &&
-                       cfg->hp_outs && !spec->multiout.hp_nid)
-               spec->multiout.hp_nid = nid;
-
        if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
                err = stac92xx_add_control(spec,
                        STAC_CTL_WIDGET_HP_SWITCH,
@@ -3041,45 +3089,19 @@ static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
        }
 
        if (spec->line_switch) {
-               nid = cfg->input_pins[AUTO_PIN_LINE];
-               pincap = snd_hda_param_read(codec, nid,
-                                               AC_PAR_PIN_CAP);
-               if (pincap & AC_PINCAP_OUT) {
-                       err = stac92xx_add_control(spec,
-                               STAC_CTL_WIDGET_IO_SWITCH,
-                               "Line In as Output Switch", nid << 8);
-                       if (err < 0)
-                               return err;
-               }
+               err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
+                                          "Line In as Output Switch",
+                                          spec->line_switch << 8);
+               if (err < 0)
+                       return err;
        }
 
        if (spec->mic_switch) {
-               unsigned int def_conf;
-               unsigned int mic_pin = AUTO_PIN_MIC;
-again:
-               nid = cfg->input_pins[mic_pin];
-               def_conf = snd_hda_codec_read(codec, nid, 0,
-                                               AC_VERB_GET_CONFIG_DEFAULT, 0);
-               /* some laptops have an internal analog microphone
-                * which can't be used as a output */
-               if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
-                       pincap = snd_hda_param_read(codec, nid,
-                                                       AC_PAR_PIN_CAP);
-                       if (pincap & AC_PINCAP_OUT) {
-                               err = stac92xx_add_control(spec,
-                                       STAC_CTL_WIDGET_IO_SWITCH,
-                                       "Mic as Output Switch", (nid << 8) | 1);
-                               nid = snd_hda_codec_read(codec, nid, 0,
-                                        AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
-                               if (!check_in_dac_nids(spec, nid))
-                                       add_spec_dacs(spec, nid);
-                               if (err < 0)
-                                       return err;
-                       }
-               } else if (mic_pin == AUTO_PIN_MIC) {
-                       mic_pin = AUTO_PIN_FRONT_MIC;
-                       goto again;
-               }
+               err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
+                                          "Mic as Output Switch",
+                                          (spec->mic_switch << 8) | 1);
+               if (err < 0)
+                       return err;
        }
 
        return 0;
@@ -3091,55 +3113,39 @@ static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
 {
        struct sigmatel_spec *spec = codec->spec;
        hda_nid_t nid;
-       int i, old_num_dacs, err;
+       int i, err, nums;
 
-       old_num_dacs = spec->multiout.num_dacs;
+       nums = 0;
        for (i = 0; i < cfg->hp_outs; i++) {
+               static const char *pfxs[] = {
+                       "Headphone", "Headphone2", "Headphone3",
+               };
                unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
                if (wid_caps & AC_WCAP_UNSOL_CAP)
                        spec->hp_detect = 1;
-               nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
-                                        AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
-               if (check_in_dac_nids(spec, nid))
-                       nid = 0;
-               if (! nid)
-                       continue;
-               add_spec_dacs(spec, nid);
-       }
-       for (i = 0; i < cfg->speaker_outs; i++) {
-               nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
-                                        AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
-               if (check_in_dac_nids(spec, nid))
-                       nid = 0;
-               if (! nid)
+               if (nums >= ARRAY_SIZE(pfxs))
                        continue;
-               add_spec_dacs(spec, nid);
-       }
-       for (i = 0; i < cfg->line_outs; i++) {
-               nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
-                                       AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
-               if (check_in_dac_nids(spec, nid))
-                       nid = 0;
-               if (! nid)
+               nid = spec->hp_dacs[i];
+               if (!nid)
                        continue;
-               add_spec_dacs(spec, nid);
+               err = create_controls(spec, pfxs[nums++], nid, 3);
+               if (err < 0)
+                       return err;
        }
-       for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
+       nums = 0;
+       for (i = 0; i < cfg->speaker_outs; i++) {
                static const char *pfxs[] = {
                        "Speaker", "External Speaker", "Speaker2",
                };
-               err = create_controls(spec, pfxs[i - old_num_dacs],
-                                     spec->multiout.dac_nids[i], 3);
-               if (err < 0)
-                       return err;
-       }
-       if (spec->multiout.hp_nid) {
-               err = create_controls(spec, "Headphone",
-                                     spec->multiout.hp_nid, 3);
+               if (nums >= ARRAY_SIZE(pfxs))
+                       continue;
+               nid = spec->speaker_dacs[i];
+               if (!nid)
+                       continue;
+               err = create_controls(spec, pfxs[nums++], nid, 3);
                if (err < 0)
                        return err;
        }
-
        return 0;
 }
 
@@ -3477,7 +3483,6 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
 {
        struct sigmatel_spec *spec = codec->spec;
        int err;
-       int hp_speaker_swap = 0;
 
        if ((err = snd_hda_parse_pin_def_config(codec,
                                                &spec->autocfg,
@@ -3495,13 +3500,15 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                 * speaker_outs so that the following routines can handle
                 * HP pins as primary outputs.
                 */
+               snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
                memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
                       sizeof(spec->autocfg.line_out_pins));
                spec->autocfg.speaker_outs = spec->autocfg.line_outs;
                memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
                       sizeof(spec->autocfg.hp_pins));
                spec->autocfg.line_outs = spec->autocfg.hp_outs;
-               hp_speaker_swap = 1;
+               spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
+               spec->autocfg.hp_outs = 0;
        }
        if (spec->autocfg.mono_out_pin) {
                int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
@@ -3553,11 +3560,11 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                                         AC_PINCTL_OUT_EN);
        }
 
-       if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
-               return err;
-       if (spec->multiout.num_dacs == 0)
-               if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
+       if (!spec->multiout.num_dacs) {
+               err = stac92xx_auto_fill_dac_nids(codec);
+               if (err < 0)
                        return err;
+       }
 
        err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
 
@@ -3595,19 +3602,6 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
        }
 #endif
 
-       if (hp_speaker_swap == 1) {
-               /* Restore the hp_outs and line_outs */
-               memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
-                      sizeof(spec->autocfg.line_out_pins));
-               spec->autocfg.hp_outs = spec->autocfg.line_outs;
-               memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
-                      sizeof(spec->autocfg.speaker_pins));
-               spec->autocfg.line_outs = spec->autocfg.speaker_outs;
-               memset(spec->autocfg.speaker_pins, 0,
-                      sizeof(spec->autocfg.speaker_pins));
-               spec->autocfg.speaker_outs = 0;
-       }
-
        err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
 
        if (err < 0)
@@ -3656,7 +3650,8 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                spec->mixers[spec->num_mixers++] = spec->kctls.list;
 
        spec->input_mux = &spec->private_imux;
-       spec->dinput_mux = &spec->private_dimux;
+       if (!spec->dinput_mux)
+               spec->dinput_mux = &spec->private_dimux;
        spec->sinput_mux = &spec->private_smux;
        spec->mono_mux = &spec->private_mono_mux;
        spec->amp_mux = &spec->private_amp_mux;
@@ -3919,9 +3914,8 @@ static void stac92xx_power_down(struct hda_codec *codec)
        /* power down inactive DACs */
        hda_nid_t *dac;
        for (dac = spec->dac_list; *dac; dac++)
-               if (!is_in_dac_nids(spec, *dac) &&
-                       spec->multiout.hp_nid != *dac)
-                       snd_hda_codec_write_cache(codec, *dac, 0,
+               if (!check_all_dac_nids(spec, *dac))
+                       snd_hda_codec_write(codec, *dac, 0,
                                        AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
 }
 
@@ -3940,7 +3934,7 @@ static int stac92xx_init(struct hda_codec *codec)
        /* power down adcs initially */
        if (spec->powerdown_adcs)
                for (i = 0; i < spec->num_adcs; i++)
-                       snd_hda_codec_write_cache(codec,
+                       snd_hda_codec_write(codec,
                                spec->adc_nids[i], 0,
                                AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
 
@@ -3971,24 +3965,36 @@ static int stac92xx_init(struct hda_codec *codec)
        } else {
                stac92xx_auto_init_multi_out(codec);
                stac92xx_auto_init_hp_out(codec);
+               for (i = 0; i < cfg->hp_outs; i++)
+                       stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
        }
        for (i = 0; i < AUTO_PIN_LAST; i++) {
                hda_nid_t nid = cfg->input_pins[i];
                if (nid) {
-                       unsigned int pinctl;
+                       unsigned int pinctl, conf;
                        if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
                                /* for mic pins, force to initialize */
                                pinctl = stac92xx_get_vref(codec, nid);
+                               pinctl |= AC_PINCTL_IN_EN;
+                               stac92xx_auto_set_pinctl(codec, nid, pinctl);
                        } else {
                                pinctl = snd_hda_codec_read(codec, nid, 0,
                                        AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
                                /* if PINCTL already set then skip */
-                               if (pinctl & AC_PINCTL_IN_EN)
-                                       continue;
+                               if (!(pinctl & AC_PINCTL_IN_EN)) {
+                                       pinctl |= AC_PINCTL_IN_EN;
+                                       stac92xx_auto_set_pinctl(codec, nid,
+                                                                pinctl);
+                               }
+                       }
+                       conf = snd_hda_codec_read(codec, nid, 0,
+                                             AC_VERB_GET_CONFIG_DEFAULT, 0);
+                       if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
+                               enable_pin_detect(codec, nid,
+                                                 STAC_INSERT_EVENT);
+                               stac_issue_unsol_event(codec, nid,
+                                                      STAC_INSERT_EVENT);
                        }
-                       pinctl |= AC_PINCTL_IN_EN;
-                       stac92xx_auto_set_pinctl(codec, nid, pinctl);
-                       enable_pin_detect(codec, nid, STAC_INSERT_EVENT);
                }
        }
        for (i = 0; i < spec->num_dmics; i++)
@@ -4004,7 +4010,13 @@ static int stac92xx_init(struct hda_codec *codec)
                hda_nid_t nid = spec->pwr_nids[i];
                int pinctl, def_conf;
 
-               if (is_nid_hp_pin(cfg, nid) && spec->hp_detect)
+               /* power on when no jack detection is available */
+               if (!spec->hp_detect) {
+                       stac_toggle_power_map(codec, nid, 1);
+                       continue;
+               }
+
+               if (is_nid_hp_pin(cfg, nid))
                        continue; /* already has an unsol event */
 
                pinctl = snd_hda_codec_read(codec, nid, 0,
@@ -4013,8 +4025,10 @@ static int stac92xx_init(struct hda_codec *codec)
                 * any attempts on powering down a input port cause the
                 * referenced VREF to act quirky.
                 */
-               if (pinctl & AC_PINCTL_IN_EN)
+               if (pinctl & AC_PINCTL_IN_EN) {
+                       stac_toggle_power_map(codec, nid, 1);
                        continue;
+               }
                def_conf = snd_hda_codec_read(codec, nid, 0,
                                              AC_VERB_GET_CONFIG_DEFAULT, 0);
                def_conf = get_defcfg_connect(def_conf);
@@ -4025,8 +4039,10 @@ static int stac92xx_init(struct hda_codec *codec)
                                stac_toggle_power_map(codec, nid, 1);
                        continue;
                }
-               enable_pin_detect(codec, nid, STAC_PWR_EVENT);
-               stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
+               if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
+                       enable_pin_detect(codec, nid, STAC_PWR_EVENT);
+                       stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
+               }
        }
        if (spec->dac_list)
                stac92xx_power_down(codec);
@@ -4089,11 +4105,7 @@ static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
                 * "xxx as Output" mixer switch
                 */
                struct sigmatel_spec *spec = codec->spec;
-               struct auto_pin_cfg *cfg = &spec->autocfg;
-               if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
-                    spec->line_switch) ||
-                   (nid == cfg->input_pins[AUTO_PIN_MIC] &&
-                    spec->mic_switch))
+               if (nid == spec->line_switch || nid == spec->mic_switch)
                        return;
        }
 
@@ -4117,20 +4129,13 @@ static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
                        pin_ctl & ~flag);
 }
 
-static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
+static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
 {
        if (!nid)
                return 0;
        if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
-           & (1 << 31)) {
-               unsigned int pinctl;
-               pinctl = snd_hda_codec_read(codec, nid, 0,
-                                           AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
-               if (pinctl & AC_PINCTL_IN_EN)
-                       return 0; /* mic- or line-input */
-               else
-                       return 1; /* HP-output */
-       }
+           & (1 << 31))
+               return 1;
        return 0;
 }
 
@@ -4142,11 +4147,9 @@ static int no_hp_sensing(struct sigmatel_spec *spec, int i)
        struct auto_pin_cfg *cfg = &spec->autocfg;
 
        /* ignore sensing of shared line and mic jacks */
-       if (spec->line_switch &&
-           cfg->hp_pins[i] == cfg->input_pins[AUTO_PIN_LINE])
+       if (cfg->hp_pins[i] == spec->line_switch)
                return 1;
-       if (spec->mic_switch &&
-           cfg->hp_pins[i] == cfg->input_pins[AUTO_PIN_MIC])
+       if (cfg->hp_pins[i] == spec->mic_switch)
                return 1;
        /* ignore if the pin is set as line-out */
        if (cfg->hp_pins[i] == spec->hp_switch)
@@ -4170,7 +4173,14 @@ static void stac92xx_hp_detect(struct hda_codec *codec)
                        break;
                if (no_hp_sensing(spec, i))
                        continue;
-               presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
+               presence = get_pin_presence(codec, cfg->hp_pins[i]);
+               if (presence) {
+                       unsigned int pinctl;
+                       pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
+                                           AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
+                       if (pinctl & AC_PINCTL_IN_EN)
+                               presence = 0; /* mic- or line-input */
+               }
        }
 
        if (presence) {
@@ -4247,7 +4257,7 @@ static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
 
 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
 {
-       stac_toggle_power_map(codec, nid, get_hp_pin_presence(codec, nid));
+       stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
 }
 
 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
@@ -4269,7 +4279,7 @@ static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
                                        type = (pin_ctl & AC_PINCTL_HP_EN)
                                        ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
                                snd_jack_report(jacks->jack,
-                                       get_hp_pin_presence(codec, nid)
+                                       get_pin_presence(codec, nid)
                                        ? type : 0);
                        }
                        jacks++;
@@ -4317,6 +4327,52 @@ static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
        }
 }
 
+#ifdef CONFIG_PROC_FS
+static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
+                              struct hda_codec *codec, hda_nid_t nid)
+{
+       if (nid == codec->afg)
+               snd_iprintf(buffer, "Power-Map: 0x%02x\n", 
+                           snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
+}
+
+static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
+                                 struct hda_codec *codec,
+                                 unsigned int verb)
+{
+       snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
+                   snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
+}
+
+/* stac92hd71bxx, stac92hd73xx */
+static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
+                                struct hda_codec *codec, hda_nid_t nid)
+{
+       stac92hd_proc_hook(buffer, codec, nid);
+       if (nid == codec->afg)
+               analog_loop_proc_hook(buffer, codec, 0xfa0);
+}
+
+static void stac9205_proc_hook(struct snd_info_buffer *buffer,
+                              struct hda_codec *codec, hda_nid_t nid)
+{
+       if (nid == codec->afg)
+               analog_loop_proc_hook(buffer, codec, 0xfe0);
+}
+
+static void stac927x_proc_hook(struct snd_info_buffer *buffer,
+                              struct hda_codec *codec, hda_nid_t nid)
+{
+       if (nid == codec->afg)
+               analog_loop_proc_hook(buffer, codec, 0xfeb);
+}
+#else
+#define stac92hd_proc_hook     NULL
+#define stac92hd7x_proc_hook   NULL
+#define stac9205_proc_hook     NULL
+#define stac927x_proc_hook     NULL
+#endif
+
 #ifdef SND_HDA_NEEDS_RESUME
 static int stac92xx_resume(struct hda_codec *codec)
 {
@@ -4515,6 +4571,7 @@ static int patch_stac92hd73xx(struct hda_codec *codec)
        struct sigmatel_spec *spec;
        hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
        int err = 0;
+       int num_dacs;
 
        spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
        if (spec == NULL)
@@ -4541,16 +4598,15 @@ again:
                return err;
        }
 
-       spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
+       num_dacs = snd_hda_get_connections(codec, 0x0a,
                        conn, STAC92HD73_DAC_COUNT + 2) - 1;
 
-       if (spec->multiout.num_dacs < 0) {
+       if (num_dacs < 3 || num_dacs > 5) {
                printk(KERN_WARNING "hda_codec: Could not determine "
                       "number of channels defaulting to DAC count\n");
-               spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
+               num_dacs = STAC92HD73_DAC_COUNT;
        }
-
-       switch (spec->multiout.num_dacs) {
+       switch (num_dacs) {
        case 0x3: /* 6 Channel */
                spec->mixer = stac92hd73xx_6ch_mixer;
                spec->init = stac92hd73xx_6ch_core_init;
@@ -4562,9 +4618,9 @@ again:
        case 0x5: /* 10 Channel */
                spec->mixer = stac92hd73xx_10ch_mixer;
                spec->init = stac92hd73xx_10ch_core_init;
-       };
+       }
+       spec->multiout.dac_nids = spec->dac_nids;
 
-       spec->multiout.dac_nids = stac92hd73xx_dac_nids;
        spec->aloopback_mask = 0x01;
        spec->aloopback_shift = 8;
 
@@ -4596,7 +4652,7 @@ again:
                spec->eapd_switch = 0;
                spec->num_amps = 1;
 
-               if (!spec->init)
+               if (spec->board_config != STAC_DELL_EQ)
                        spec->init = dell_m6_core_init;
                switch (spec->board_config) {
                case STAC_DELL_M6_AMIC: /* Analog Mics */
@@ -4649,8 +4705,13 @@ again:
                return err;
        }
 
+       if (spec->board_config == STAC_92HD73XX_NO_JD)
+               spec->hp_detect = 0;
+
        codec->patch_ops = stac92xx_patch_ops;
 
+       codec->proc_widget_hook = stac92hd7x_proc_hook;
+
        return 0;
 }
 
@@ -4682,17 +4743,15 @@ static int patch_stac92hd83xxx(struct hda_codec *codec)
        spec->pwr_nids = stac92hd83xxx_pwr_nids;
        spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
        spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
-       spec->multiout.dac_nids = stac92hd83xxx_dac_nids;
+       spec->multiout.dac_nids = spec->dac_nids;
 
        spec->init = stac92hd83xxx_core_init;
        switch (codec->vendor_id) {
        case 0x111d7605:
-               spec->multiout.num_dacs = STAC92HD81_DAC_COUNT;
                break;
        default:
                spec->num_pwrs--;
                spec->init++; /* switch to config #2 */
-               spec->multiout.num_dacs = STAC92HD83_DAC_COUNT;
        }
 
        spec->mixer = stac92hd83xxx_mixer;
@@ -4737,51 +4796,11 @@ again:
 
        codec->patch_ops = stac92xx_patch_ops;
 
-       return 0;
-}
+       codec->proc_widget_hook = stac92hd_proc_hook;
 
-#ifdef SND_HDA_NEEDS_RESUME
-static void stac92hd71xx_set_power_state(struct hda_codec *codec, int pwr)
-{
-       struct sigmatel_spec *spec = codec->spec;
-       int i;
-       snd_hda_codec_write_cache(codec, codec->afg, 0,
-               AC_VERB_SET_POWER_STATE, pwr);
-
-       msleep(1);
-       for (i = 0; i < spec->num_adcs; i++) {
-               snd_hda_codec_write_cache(codec,
-                       spec->adc_nids[i], 0,
-                       AC_VERB_SET_POWER_STATE, pwr);
-       }
-};
-
-static int stac92hd71xx_resume(struct hda_codec *codec)
-{
-       stac92hd71xx_set_power_state(codec, AC_PWRST_D0);
-       return stac92xx_resume(codec);
+       return 0;
 }
 
-static int stac92hd71xx_suspend(struct hda_codec *codec, pm_message_t state)
-{
-       stac92hd71xx_set_power_state(codec, AC_PWRST_D3);
-       return stac92xx_suspend(codec, state);
-};
-
-#endif
-
-static struct hda_codec_ops stac92hd71bxx_patch_ops = {
-       .build_controls = stac92xx_build_controls,
-       .build_pcms = stac92xx_build_pcms,
-       .init = stac92xx_init,
-       .free = stac92xx_free,
-       .unsol_event = stac92xx_unsol_event,
-#ifdef SND_HDA_NEEDS_RESUME
-       .suspend = stac92hd71xx_suspend,
-       .resume = stac92hd71xx_resume,
-#endif
-};
-
 static struct hda_input_mux stac92hd71bxx_dmux = {
        .num_items = 4,
        .items = {
@@ -4858,12 +4877,8 @@ again:
                        break;
                }
                if ((codec->revision_id & 0xf) == 0 ||
-                               (codec->revision_id & 0xf) == 1) {
-#ifdef SND_HDA_NEEDS_RESUME
-                       codec->patch_ops = stac92hd71bxx_patch_ops;
-#endif
+                   (codec->revision_id & 0xf) == 1)
                        spec->stream_delay = 40; /* 40 milliseconds */
-               }
 
                /* no output amps */
                spec->num_pwrs = 0;
@@ -4875,12 +4890,8 @@ again:
                stac_change_pin_config(codec, 0xf, 0x40f000f0);
                break;
        case 0x111d7603: /* 6 Port with Analog Mixer */
-               if ((codec->revision_id & 0xf) == 1) {
-#ifdef SND_HDA_NEEDS_RESUME
-                       codec->patch_ops = stac92hd71bxx_patch_ops;
-#endif
+               if ((codec->revision_id & 0xf) == 1)
                        spec->stream_delay = 40; /* 40 milliseconds */
-               }
 
                /* no output amps */
                spec->num_pwrs = 0;
@@ -4931,9 +4942,7 @@ again:
                spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
        };
 
-       spec->multiout.num_dacs = 1;
-       spec->multiout.hp_nid = 0x11;
-       spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
+       spec->multiout.dac_nids = spec->dac_nids;
        if (spec->dinput_mux)
                spec->private_dimux.num_items +=
                        spec->num_dmics -
@@ -4955,6 +4964,8 @@ again:
                return err;
        }
 
+       codec->proc_widget_hook = stac92hd7x_proc_hook;
+
        return 0;
 };
 
@@ -5175,6 +5186,8 @@ static int patch_stac927x(struct hda_codec *codec)
 
        codec->patch_ops = stac92xx_patch_ops;
 
+       codec->proc_widget_hook = stac927x_proc_hook;
+
        /*
         * !!FIXME!!
         * The STAC927x seem to require fairly long delays for certain
@@ -5187,6 +5200,10 @@ static int patch_stac927x(struct hda_codec *codec)
         */
        codec->bus->needs_damn_long_delay = 1;
 
+       /* no jack detecion for ref-no-jd model */
+       if (spec->board_config == STAC_D965_REF_NO_JD)
+               spec->hp_detect = 0;
+
        return 0;
 }
 
@@ -5290,6 +5307,8 @@ static int patch_stac9205(struct hda_codec *codec)
 
        codec->patch_ops = stac92xx_patch_ops;
 
+       codec->proc_widget_hook = stac9205_proc_hook;
+
        return 0;
 }
 
@@ -5410,7 +5429,7 @@ static int stac9872_vaio_init(struct hda_codec *codec)
 
 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
 {
-       if (get_hp_pin_presence(codec, 0x0a)) {
+       if (get_pin_presence(codec, 0x0a)) {
                stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
                stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
        } else {