Merge ../linux-2.6

8 files changed, 401 insertions, 161 deletions

diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index 3815403ed095..0dbeeaf6113a 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -518,6 +518,13 @@ int snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
                 return -ENODEV;
         }
 
+        if (! codec->subsystem_id) {
+                hda_nid_t nid = codec->afg ? codec->afg : codec->mfg;
+                codec->subsystem_id = snd_hda_codec_read(codec, nid, 0,
+                                                         AC_VERB_GET_SUBSYSTEM_ID,
+                                                         0);
+        }
+
         codec->preset = find_codec_preset(codec);
         if (! *bus->card->mixername)
                 snd_hda_get_codec_name(codec, bus->card->mixername,
@@ -814,6 +821,51 @@ int snd_hda_mixer_amp_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t
 }
 
 /*
+ * bound volume controls
+ *
+ * bind multiple volumes (# indices, from 0)
+ */
+
+#define AMP_VAL_IDX_SHIFT       19
+#define AMP_VAL_IDX_MASK        (0x0f<<19)
+
+int snd_hda_mixer_bind_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        unsigned long pval;
+        int err;
+
+        down(&codec->spdif_mutex); /* reuse spdif_mutex */
+        pval = kcontrol->private_value;
+        kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
+        err = snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
+        kcontrol->private_value = pval;
+        up(&codec->spdif_mutex);
+        return err;
+}
+
+int snd_hda_mixer_bind_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+{
+        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
+        unsigned long pval;
+        int i, indices, err = 0, change = 0;
+
+        down(&codec->spdif_mutex); /* reuse spdif_mutex */
+        pval = kcontrol->private_value;
+        indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
+        for (i = 0; i < indices; i++) {
+                kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) | (i << AMP_VAL_IDX_SHIFT);
+                err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
+                if (err < 0)
+                        break;
+                change |= err;
+        }
+        kcontrol->private_value = pval;
+        up(&codec->spdif_mutex);
+        return err < 0 ? err : change;
+}
+
+/*
  * SPDIF out controls
  */
 
diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h
index bb53bcf76742..1179d6cfa82a 100644
--- a/sound/pci/hda/hda_codec.h
+++ b/sound/pci/hda/hda_codec.h
@@ -79,6 +79,8 @@ enum {
 #define AC_VERB_GET_GPIO_MASK                   0x0f16
 #define AC_VERB_GET_GPIO_DIRECTION              0x0f17
 #define AC_VERB_GET_CONFIG_DEFAULT              0x0f1c
+/* f20: AFG/MFG */
+#define AC_VERB_GET_SUBSYSTEM_ID                0x0f20
 
 /*
  * SET verbs
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index 6fe696e53ea6..9d1412a9f2f8 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -47,23 +47,24 @@
 #include "hda_codec.h"
 
 
-static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
-static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
-static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
-static char *model[SNDRV_CARDS];
-static int position_fix[SNDRV_CARDS];
+static int index = SNDRV_DEFAULT_IDX1;
+static char *id = SNDRV_DEFAULT_STR1;
+static char *model;
+static int position_fix;
 
-module_param_array(index, int, NULL, 0444);
+module_param(index, int, 0444);
 MODULE_PARM_DESC(index, "Index value for Intel HD audio interface.");
-module_param_array(id, charp, NULL, 0444);
+module_param(id, charp, 0444);
 MODULE_PARM_DESC(id, "ID string for Intel HD audio interface.");
-module_param_array(enable, bool, NULL, 0444);
-MODULE_PARM_DESC(enable, "Enable Intel HD audio interface.");
-module_param_array(model, charp, NULL, 0444);
+module_param(model, charp, 0444);
 MODULE_PARM_DESC(model, "Use the given board model.");
-module_param_array(position_fix, int, NULL, 0444);
+module_param(position_fix, int, 0444);
 MODULE_PARM_DESC(position_fix, "Fix DMA pointer (0 = auto, 1 = none, 2 = POSBUF, 3 = FIFO size).");
 
+/* just for backward compatibility */
+static int enable;
+module_param(enable, bool, 0444);
+
 MODULE_LICENSE("GPL");
 MODULE_SUPPORTED_DEVICE("{{Intel, ICH6},"
                          "{Intel, ICH6M},"
@@ -223,6 +224,9 @@ enum {
 #define ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR   0x42
 #define ATI_SB450_HDAUDIO_ENABLE_SNOOP      0x02
 
+/* Defines for Nvidia HDA support */
+#define NVIDIA_HDA_TRANSREG_ADDR      0x4e
+#define NVIDIA_HDA_ENABLE_COHBITS     0x0f
 
 /*
  * Use CORB/RIRB for communication from/to codecs.
@@ -328,6 +332,7 @@ enum {
         AZX_DRIVER_VIA,
         AZX_DRIVER_SIS,
         AZX_DRIVER_ULI,
+        AZX_DRIVER_NVIDIA,
 };
 
 static char *driver_short_names[] __devinitdata = {
@@ -335,7 +340,8 @@ static char *driver_short_names[] __devinitdata = {
         [AZX_DRIVER_ATI] = "HDA ATI SB",
         [AZX_DRIVER_VIA] = "HDA VIA VT82xx",
         [AZX_DRIVER_SIS] = "HDA SIS966",
-        [AZX_DRIVER_ULI] = "HDA ULI M5461"
+        [AZX_DRIVER_ULI] = "HDA ULI M5461",
+        [AZX_DRIVER_NVIDIA] = "HDA NVidia",
 };
 
 /*
@@ -710,14 +716,14 @@ static void azx_stream_stop(azx_t *chip, azx_dev_t *azx_dev)
  */
 static void azx_init_chip(azx_t *chip)
 {
-        unsigned char tcsel_reg, ati_misc_cntl2;
+        unsigned char reg;
 
         /* Clear bits 0-2 of PCI register TCSEL (at offset 0x44)
          * TCSEL == Traffic Class Select Register, which sets PCI express QOS
          * Ensuring these bits are 0 clears playback static on some HD Audio codecs
          */
-        pci_read_config_byte (chip->pci, ICH6_PCIREG_TCSEL, &tcsel_reg);
-        pci_write_config_byte(chip->pci, ICH6_PCIREG_TCSEL, tcsel_reg & 0xf8);
+        pci_read_config_byte (chip->pci, ICH6_PCIREG_TCSEL, &reg);
+        pci_write_config_byte(chip->pci, ICH6_PCIREG_TCSEL, reg & 0xf8);
 
         /* reset controller */
         azx_reset(chip);
@@ -733,13 +739,21 @@ static void azx_init_chip(azx_t *chip)
         azx_writel(chip, DPLBASE, (u32)chip->posbuf.addr);
         azx_writel(chip, DPUBASE, upper_32bit(chip->posbuf.addr));
 
-        /* For ATI SB450 azalia HD audio, we need to enable snoop */
-        if (chip->driver_type == AZX_DRIVER_ATI) {
+        switch (chip->driver_type) {
+        case AZX_DRIVER_ATI:
+                /* For ATI SB450 azalia HD audio, we need to enable snoop */
                 pci_read_config_byte(chip->pci, ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR, 
-                                     &ati_misc_cntl2);
+                                     &reg);
                 pci_write_config_byte(chip->pci, ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR, 
-                                      (ati_misc_cntl2 & 0xf8) | ATI_SB450_HDAUDIO_ENABLE_SNOOP);
-        }
+                                      (reg & 0xf8) | ATI_SB450_HDAUDIO_ENABLE_SNOOP);
+                break;
+        case AZX_DRIVER_NVIDIA:
+                /* For NVIDIA HDA, enable snoop */
+                pci_read_config_byte(chip->pci,NVIDIA_HDA_TRANSREG_ADDR, &reg);
+                pci_write_config_byte(chip->pci,NVIDIA_HDA_TRANSREG_ADDR,
+                                      (reg & 0xf0) | NVIDIA_HDA_ENABLE_COHBITS);
+                break;
+        }
 }
 
 
@@ -1264,6 +1278,7 @@ static int __devinit azx_pcm_create(azx_t *chip)
                         err = create_codec_pcm(chip, codec, &codec->pcm_info[c], pcm_dev);
                         if (err < 0)
                                 return err;
+                        chip->pcm[pcm_dev]->dev_class = SNDRV_PCM_CLASS_MODEM;
                         pcm_dev++;
                 }
         }
@@ -1530,32 +1545,24 @@ static int __devinit azx_create(snd_card_t *card, struct pci_dev *pci,
 
 static int __devinit azx_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
 {
-        static int dev;
         snd_card_t *card;
         azx_t *chip;
         int err = 0;
 
-        if (dev >= SNDRV_CARDS)
-                return -ENODEV;
-        if (! enable[dev]) {
-                dev++;
-                return -ENOENT;
-        }
-
-        card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
+        card = snd_card_new(index, id, THIS_MODULE, 0);
         if (NULL == card) {
                 snd_printk(KERN_ERR SFX "Error creating card!\n");
                 return -ENOMEM;
         }
 
-        if ((err = azx_create(card, pci, position_fix[dev], pci_id->driver_data,
+        if ((err = azx_create(card, pci, position_fix, pci_id->driver_data,
                               &chip)) < 0) {
                 snd_card_free(card);
                 return err;
         }
 
         /* create codec instances */
-        if ((err = azx_codec_create(chip, model[dev])) < 0) {
+        if ((err = azx_codec_create(chip, model)) < 0) {
                 snd_card_free(card);
                 return err;
         }
@@ -1581,7 +1588,6 @@ static int __devinit azx_probe(struct pci_dev *pci, const struct pci_device_id *
         }
 
         pci_set_drvdata(pci, card);
-        dev++;
 
         return err;
 }
@@ -1601,6 +1607,8 @@ static struct pci_device_id azx_ids[] = {
         { 0x1106, 0x3288, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_VIA }, /* VIA VT8251/VT8237A */
         { 0x1039, 0x7502, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_SIS }, /* SIS966 */
         { 0x10b9, 0x5461, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ULI }, /* ULI M5461 */
+        { 0x10de, 0x026c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA 026c */
+        { 0x10de, 0x0371, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_NVIDIA }, /* NVIDIA 0371 */
         { 0, }
 };
 MODULE_DEVICE_TABLE(pci, azx_ids);
diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h
index 810cfd2d9bba..f51a56f813c8 100644
--- a/sound/pci/hda/hda_local.h
+++ b/sound/pci/hda/hda_local.h
@@ -27,28 +27,36 @@
  * for mixer controls
  */
 #define HDA_COMPOSE_AMP_VAL(nid,chs,idx,dir) ((nid) | ((chs)<<16) | ((dir)<<18) | ((idx)<<19))
+/* mono volume with index (index=0,1,...) (channel=1,2) */
 #define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx,  \
           .info = snd_hda_mixer_amp_volume_info, \
           .get = snd_hda_mixer_amp_volume_get, \
           .put = snd_hda_mixer_amp_volume_put, \
           .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) }
+/* stereo volume with index */
 #define HDA_CODEC_VOLUME_IDX(xname, xcidx, nid, xindex, direction) \
         HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, 3, xindex, direction)
+/* mono volume */
 #define HDA_CODEC_VOLUME_MONO(xname, nid, channel, xindex, direction) \
         HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, channel, xindex, direction)
+/* stereo volume */
 #define HDA_CODEC_VOLUME(xname, nid, xindex, direction) \
         HDA_CODEC_VOLUME_MONO(xname, nid, 3, xindex, direction)
+/* mono mute switch with index (index=0,1,...) (channel=1,2) */
 #define HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \
           .info = snd_hda_mixer_amp_switch_info, \
           .get = snd_hda_mixer_amp_switch_get, \
           .put = snd_hda_mixer_amp_switch_put, \
           .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) }
+/* stereo mute switch with index */
 #define HDA_CODEC_MUTE_IDX(xname, xcidx, nid, xindex, direction) \
         HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, 3, xindex, direction)
+/* mono mute switch */
 #define HDA_CODEC_MUTE_MONO(xname, nid, channel, xindex, direction) \
         HDA_CODEC_MUTE_MONO_IDX(xname, 0, nid, channel, xindex, direction)
+/* stereo mute switch */
 #define HDA_CODEC_MUTE(xname, nid, xindex, direction) \
         HDA_CODEC_MUTE_MONO(xname, nid, 3, xindex, direction)
 
@@ -59,6 +67,20 @@ int snd_hda_mixer_amp_switch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t
 int snd_hda_mixer_amp_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol);
 int snd_hda_mixer_amp_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol);
 
+/* mono switch binding multiple inputs */
+#define HDA_BIND_MUTE_MONO(xname, nid, channel, indices, direction) \
+        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
+          .info = snd_hda_mixer_amp_switch_info, \
+          .get = snd_hda_mixer_bind_switch_get, \
+          .put = snd_hda_mixer_bind_switch_put, \
+          .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, indices, direction) }
+
+/* stereo switch binding multiple inputs */
+#define HDA_BIND_MUTE(xname,nid,indices,dir) HDA_BIND_MUTE_MONO(xname,nid,3,indices,dir)
+
+int snd_hda_mixer_bind_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol);
+int snd_hda_mixer_bind_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol);
+
 int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid);
 int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid);
 
diff --git a/sound/pci/hda/hda_proc.c b/sound/pci/hda/hda_proc.c
index 08f6a6efc5e6..39ddf1cd9019 100644
--- a/sound/pci/hda/hda_proc.c
+++ b/sound/pci/hda/hda_proc.c
@@ -281,6 +281,11 @@ static void print_codec_info(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
                         print_pcm_caps(buffer, codec, nid);
                 }
 
+                if (wid_caps & AC_WCAP_POWER)
+                        snd_iprintf(buffer, "  Power: 0x%x\n",
+                                    snd_hda_codec_read(codec, nid, 0,
+                                                       AC_VERB_GET_POWER_STATE, 0));
+
                 if (wid_caps & AC_WCAP_CONN_LIST) {
                         int c, curr = -1;
                         if (conn_len > 1 && wid_type != AC_WID_AUD_MIX)
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index da6874d3988c..d7d636decef8 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -28,15 +28,38 @@
 #include "hda_local.h"
 
 struct ad198x_spec {
-        struct semaphore amp_mutex;     /* PCM volume/mute control mutex */
-        struct hda_multi_out multiout;  /* playback */
-        hda_nid_t adc_nid;
+        snd_kcontrol_new_t *mixers[5];
+        int num_mixers;
+
+        const struct hda_verb *init_verbs[3];   /* initialization verbs
+                                                 * don't forget NULL termination!
+                                                 */
+        unsigned int num_init_verbs;
+
+        /* playback */
+        struct hda_multi_out multiout;  /* playback set-up
+                                         * max_channels, dacs must be set
+                                         * dig_out_nid and hp_nid are optional
+                                         */
+
+        /* capture */
+        unsigned int num_adc_nids;
+        hda_nid_t *adc_nids;
+        hda_nid_t dig_in_nid;           /* digital-in NID; optional */
+
+        /* capture source */
         const struct hda_input_mux *input_mux;
-        unsigned int cur_mux;           /* capture source */
+        unsigned int cur_mux[3];
+
+        /* channel model */
+        const struct alc_channel_mode *channel_mode;
+        int num_channel_mode;
+
+        /* PCM information */
+        struct hda_pcm pcm_rec[2];      /* used in alc_build_pcms() */
+
+        struct semaphore amp_mutex;     /* PCM volume/mute control mutex */
         unsigned int spdif_route;
-        snd_kcontrol_new_t *mixers;
-        const struct hda_verb *init_verbs;
-        struct hda_pcm pcm_rec[2];      /* PCM information */
 };
 
 /*
@@ -54,8 +77,9 @@ static int ad198x_mux_enum_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         struct ad198x_spec *spec = codec->spec;
+        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 
-        ucontrol->value.enumerated.item[0] = spec->cur_mux;
+        ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
         return 0;
 }
 
@@ -63,9 +87,10 @@ static int ad198x_mux_enum_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
         struct ad198x_spec *spec = codec->spec;
+        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 
         return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
-                                     spec->adc_nid, &spec->cur_mux);
+                                     spec->adc_nids[adc_idx], &spec->cur_mux[adc_idx]);
 }
 
 /*
@@ -74,22 +99,34 @@ static int ad198x_mux_enum_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u
 static int ad198x_init(struct hda_codec *codec)
 {
         struct ad198x_spec *spec = codec->spec;
-        snd_hda_sequence_write(codec, spec->init_verbs);
+        int i;
+
+        for (i = 0; i < spec->num_init_verbs; i++)
+                snd_hda_sequence_write(codec, spec->init_verbs[i]);
         return 0;
 }
 
 static int ad198x_build_controls(struct hda_codec *codec)
 {
         struct ad198x_spec *spec = codec->spec;
+        unsigned int i;
         int err;
 
-        err = snd_hda_add_new_ctls(codec, spec->mixers);
-        if (err < 0)
-                return err;
-        if (spec->multiout.dig_out_nid)
+        for (i = 0; i < spec->num_mixers; i++) {
+                err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
+                if (err < 0)
+                        return err;
+        }
+        if (spec->multiout.dig_out_nid) {
                 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
-        if (err < 0)
-                return err;
+                if (err < 0)
+                        return err;
+        } 
+        if (spec->dig_in_nid) {
+                err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
+                if (err < 0)
+                        return err;
+        }
         return 0;
 }
 
@@ -152,7 +189,8 @@ static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
                                       snd_pcm_substream_t *substream)
 {
         struct ad198x_spec *spec = codec->spec;
-        snd_hda_codec_setup_stream(codec, spec->adc_nid, stream_tag, 0, format);
+        snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
+                                   stream_tag, 0, format);
         return 0;
 }
 
@@ -161,7 +199,8 @@ static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
                                       snd_pcm_substream_t *substream)
 {
         struct ad198x_spec *spec = codec->spec;
-        snd_hda_codec_setup_stream(codec, spec->adc_nid, 0, 0, 0);
+        snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
+                                   0, 0, 0);
         return 0;
 }
 
@@ -171,7 +210,7 @@ static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
 static struct hda_pcm_stream ad198x_pcm_analog_playback = {
         .substreams = 1,
         .channels_min = 2,
-        .channels_max = 6,
+        .channels_max = 6, /* changed later */
         .nid = 0, /* fill later */
         .ops = {
                 .open = ad198x_playback_pcm_open,
@@ -181,7 +220,7 @@ static struct hda_pcm_stream ad198x_pcm_analog_playback = {
 };
 
 static struct hda_pcm_stream ad198x_pcm_analog_capture = {
-        .substreams = 2,
+        .substreams = 1,
         .channels_min = 2,
         .channels_max = 2,
         .nid = 0, /* fill later */
@@ -202,6 +241,13 @@ static struct hda_pcm_stream ad198x_pcm_digital_playback = {
         },
 };
 
+static struct hda_pcm_stream ad198x_pcm_digital_capture = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        /* NID is set in alc_build_pcms */
+};
+
 static int ad198x_build_pcms(struct hda_codec *codec)
 {
         struct ad198x_spec *spec = codec->spec;
@@ -215,7 +261,8 @@ static int ad198x_build_pcms(struct hda_codec *codec)
         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
         info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
-        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nid;
+        info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
+        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
 
         if (spec->multiout.dig_out_nid) {
                 info++;
@@ -223,6 +270,10 @@ static int ad198x_build_pcms(struct hda_codec *codec)
                 info->name = "AD198x Digital";
                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
+                if (spec->dig_in_nid) {
+                        info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
+                        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
+                }
         }
 
         return 0;
@@ -237,10 +288,15 @@ static void ad198x_free(struct hda_codec *codec)
 static int ad198x_resume(struct hda_codec *codec)
 {
         struct ad198x_spec *spec = codec->spec;
+        int i;
 
         ad198x_init(codec);
-        snd_hda_resume_ctls(codec, spec->mixers);
-        snd_hda_resume_spdif_out(codec);
+        for (i = 0; i < spec->num_mixers; i++)
+                snd_hda_resume_ctls(codec, spec->mixers[i]);
+        if (spec->multiout.dig_out_nid)
+                snd_hda_resume_spdif_out(codec);
+        if (spec->dig_in_nid)
+                snd_hda_resume_spdif_in(codec);
         return 0;
 }
 #endif
@@ -269,6 +325,7 @@ static struct hda_codec_ops ad198x_patch_ops = {
 static hda_nid_t ad1986a_dac_nids[3] = {
         AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
 };
+static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
 
 static struct hda_input_mux ad1986a_capture_source = {
         .num_items = 7,
@@ -476,10 +533,13 @@ static int patch_ad1986a(struct hda_codec *codec)
         spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
         spec->multiout.dac_nids = ad1986a_dac_nids;
         spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
-        spec->adc_nid = AD1986A_ADC;
+        spec->num_adc_nids = 1;
+        spec->adc_nids = ad1986a_adc_nids;
         spec->input_mux = &ad1986a_capture_source;
-        spec->mixers = ad1986a_mixers;
-        spec->init_verbs = ad1986a_init_verbs;
+        spec->num_mixers = 1;
+        spec->mixers[0] = ad1986a_mixers;
+        spec->num_init_verbs = 1;
+        spec->init_verbs[0] = ad1986a_init_verbs;
 
         codec->patch_ops = ad198x_patch_ops;
 
@@ -495,6 +555,7 @@ static int patch_ad1986a(struct hda_codec *codec)
 #define AD1983_ADC              0x04
 
 static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
+static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
 
 static struct hda_input_mux ad1983_capture_source = {
         .num_items = 4,
@@ -619,6 +680,7 @@ static struct hda_verb ad1983_init_verbs[] = {
         { } /* end */
 };
 
+
 static int patch_ad1983(struct hda_codec *codec)
 {
         struct ad198x_spec *spec;
@@ -634,10 +696,13 @@ static int patch_ad1983(struct hda_codec *codec)
         spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
         spec->multiout.dac_nids = ad1983_dac_nids;
         spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
-        spec->adc_nid = AD1983_ADC;
+        spec->num_adc_nids = 1;
+        spec->adc_nids = ad1983_adc_nids;
         spec->input_mux = &ad1983_capture_source;
-        spec->mixers = ad1983_mixers;
-        spec->init_verbs = ad1983_init_verbs;
+        spec->num_mixers = 1;
+        spec->mixers[0] = ad1983_mixers;
+        spec->num_init_verbs = 1;
+        spec->init_verbs[0] = ad1983_init_verbs;
         spec->spdif_route = 0;
 
         codec->patch_ops = ad198x_patch_ops;
@@ -655,6 +720,7 @@ static int patch_ad1983(struct hda_codec *codec)
 #define AD1981_ADC              0x04
 
 static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
+static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
 
 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
 static struct hda_input_mux ad1981_capture_source = {
@@ -775,10 +841,13 @@ static int patch_ad1981(struct hda_codec *codec)
         spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
         spec->multiout.dac_nids = ad1981_dac_nids;
         spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
-        spec->adc_nid = AD1981_ADC;
+        spec->num_adc_nids = 1;
+        spec->adc_nids = ad1981_adc_nids;
         spec->input_mux = &ad1981_capture_source;
-        spec->mixers = ad1981_mixers;
-        spec->init_verbs = ad1981_init_verbs;
+        spec->num_mixers = 1;
+        spec->mixers[0] = ad1981_mixers;
+        spec->num_init_verbs = 1;
+        spec->init_verbs[0] = ad1981_init_verbs;
         spec->spdif_route = 0;
 
         codec->patch_ops = ad198x_patch_ops;
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 7327deb6df9f..cffb83fdcff7 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -57,6 +57,7 @@ enum {
 enum {
         ALC260_BASIC,
         ALC260_HP,
+        ALC260_FUJITSU_S702x,
         ALC260_MODEL_LAST /* last tag */
 };
 
@@ -72,6 +73,7 @@ enum {
 #define PIN_VREF50      0x21
 #define PIN_OUT         0x40
 #define PIN_HP          0xc0
+#define PIN_HP_AMP      0x80
 
 struct alc_spec {
         /* codec parameterization */
@@ -113,8 +115,6 @@ struct alc_spec {
         /* PCM information */
         struct hda_pcm pcm_rec[2];      /* used in alc_build_pcms() */
 
-        struct semaphore bind_mutex;    /* for bound controls */
-
         /* dynamic controls, init_verbs and input_mux */
         struct auto_pin_cfg autocfg;
         unsigned int num_kctl_alloc, num_kctl_used;
@@ -218,72 +218,53 @@ static int alc880_ch_mode_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *uc
 
 
 /*
- * bound volume controls
- *
- * bind multiple volumes (# indices, from 0)
+ * Control of pin widget settings via the mixer.  Only boolean settings are
+ * supported, so VrefEn can't be controlled using these functions as they
+ * stand.
  */
-
-#define AMP_VAL_IDX_SHIFT       19
-#define AMP_VAL_IDX_MASK        (0x0f<<19)
-
-static int alc_bind_switch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
+static int alc_pinctl_switch_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
 {
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct alc_spec *spec = codec->spec;
-        unsigned long pval;
-
-        down(&spec->bind_mutex);
-        pval = kcontrol->private_value;
-        kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
-        snd_hda_mixer_amp_switch_info(kcontrol, uinfo);
-        kcontrol->private_value = pval;
-        up(&spec->bind_mutex);
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
         return 0;
 }
 
-static int alc_bind_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int alc_pinctl_switch_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct alc_spec *spec = codec->spec;
-        unsigned long pval;
-
-        down(&spec->bind_mutex);
-        pval = kcontrol->private_value;
-        kcontrol->private_value = pval & ~AMP_VAL_IDX_MASK; /* index 0 */
-        snd_hda_mixer_amp_switch_get(kcontrol, ucontrol);
-        kcontrol->private_value = pval;
-        up(&spec->bind_mutex);
+        hda_nid_t nid = kcontrol->private_value & 0xffff;
+        long mask = (kcontrol->private_value >> 16) & 0xff;
+        long *valp = ucontrol->value.integer.value;
+
+        *valp = 0;
+        if (snd_hda_codec_read(codec,nid,0,AC_VERB_GET_PIN_WIDGET_CONTROL,0x00) & mask)
+                *valp = 1;
         return 0;
 }
 
-static int alc_bind_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int alc_pinctl_switch_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct alc_spec *spec = codec->spec;
-        unsigned long pval;
-        int i, indices, change = 0;
-
-        down(&spec->bind_mutex);
-        pval = kcontrol->private_value;
-        indices = (pval & AMP_VAL_IDX_MASK) >> AMP_VAL_IDX_SHIFT;
-        for (i = 0; i < indices; i++) {
-                kcontrol->private_value = (pval & ~AMP_VAL_IDX_MASK) | (i << AMP_VAL_IDX_SHIFT);
-                change |= snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
-        }
-        kcontrol->private_value = pval;
-        up(&spec->bind_mutex);
+        hda_nid_t nid = kcontrol->private_value & 0xffff;
+        long mask = (kcontrol->private_value >> 16) & 0xff;
+        long *valp = ucontrol->value.integer.value;
+        unsigned int pinctl = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_PIN_WIDGET_CONTROL,0x00);
+        int change = ((pinctl & mask)!=0) != *valp;
+
+        if (change)
+                snd_hda_codec_write(codec,nid,0,AC_VERB_SET_PIN_WIDGET_CONTROL,
+                        *valp?(pinctl|mask):(pinctl&~mask));
         return change;
 }
 
-#define ALC_BIND_MUTE_MONO(xname, nid, channel, indices, direction) \
+#define ALC_PINCTL_SWITCH(xname, nid, mask) \
         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
-          .info = alc_bind_switch_info, \
-          .get = alc_bind_switch_get, \
-          .put = alc_bind_switch_put, \
-          .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, indices, direction) }
-
-#define ALC_BIND_MUTE(xname,nid,indices,dir) ALC_BIND_MUTE_MONO(xname,nid,3,indices,dir)
-
+          .info = alc_pinctl_switch_info, \
+          .get = alc_pinctl_switch_get, \
+          .put = alc_pinctl_switch_put, \
+          .private_value = (nid) | (mask<<16) }
 
 /*
  * ALC880 3-stack model
@@ -354,13 +335,13 @@ static struct alc_channel_mode alc880_threestack_modes[2] = {
 
 static snd_kcontrol_new_t alc880_three_stack_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-        ALC_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
@@ -441,7 +422,7 @@ static snd_kcontrol_new_t alc880_capture_alt_mixer[] = {
 /* additional mixers to alc880_three_stack_mixer */
 static snd_kcontrol_new_t alc880_five_stack_mixer[] = {
         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
         { } /* end */
 };
 
@@ -498,15 +479,15 @@ static struct alc_channel_mode alc880_sixstack_modes[1] = {
 
 static snd_kcontrol_new_t alc880_six_stack_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-        ALC_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
@@ -566,13 +547,13 @@ static struct alc_channel_mode alc880_w810_modes[1] = {
 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
 static snd_kcontrol_new_t alc880_w810_base_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-        ALC_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
         { } /* end */
 };
@@ -597,9 +578,9 @@ static struct alc_channel_mode alc880_2_jack_modes[1] = {
 
 static snd_kcontrol_new_t alc880_z71v_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
@@ -623,9 +604,9 @@ static hda_nid_t alc880_f1734_dac_nids[1] = {
 
 static snd_kcontrol_new_t alc880_f1734_mixer[] = {
         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Internal Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
@@ -648,13 +629,13 @@ static snd_kcontrol_new_t alc880_f1734_mixer[] = {
 
 static snd_kcontrol_new_t alc880_asus_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-        ALC_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
@@ -1383,10 +1364,10 @@ static snd_kcontrol_new_t alc880_test_mixer[] = {
         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
-        ALC_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
-        ALC_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
-        ALC_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
         PIN_CTL_TEST("Front Pin Mode", 0x14),
         PIN_CTL_TEST("Surround Pin Mode", 0x15),
         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
@@ -1769,7 +1750,7 @@ enum {
 static snd_kcontrol_new_t alc880_control_templates[] = {
         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
         HDA_CODEC_MUTE(NULL, 0, 0, 0),
-        ALC_BIND_MUTE(NULL, 0, 0, 0),
+        HDA_BIND_MUTE(NULL, 0, 0, 0),
 };
 
 /* add dynamic controls */
@@ -2087,7 +2068,6 @@ static int patch_alc880(struct hda_codec *codec)
         if (spec == NULL)
                 return -ENOMEM;
 
-        init_MUTEX(&spec->bind_mutex);
         codec->spec = spec;
 
         board_config = snd_hda_check_board_config(codec, alc880_cfg_tbl);
@@ -2205,6 +2185,17 @@ static struct hda_input_mux alc260_capture_source = {
         },
 };
 
+/* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack
+ * and the internal CD lines.
+ */
+static struct hda_input_mux alc260_fujitsu_capture_source = {
+        .num_items = 2,
+        .items = {
+                { "Mic/Line", 0x0 },
+                { "CD", 0x4 },
+        },
+};
+
 /*
  * This is just place-holder, so there's something for alc_build_pcms to look
  * at when it calculates the maximum number of channels. ALC260 has no mixer
@@ -2217,7 +2208,7 @@ static struct alc_channel_mode alc260_modes[1] = {
 
 static snd_kcontrol_new_t alc260_base_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
@@ -2229,9 +2220,9 @@ static snd_kcontrol_new_t alc260_base_mixer[] = {
         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
         {
@@ -2246,7 +2237,7 @@ static snd_kcontrol_new_t alc260_base_mixer[] = {
 
 static snd_kcontrol_new_t alc260_hp_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
@@ -2256,9 +2247,9 @@ static snd_kcontrol_new_t alc260_hp_mixer[] = {
         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
         {
@@ -2271,6 +2262,30 @@ static snd_kcontrol_new_t alc260_hp_mixer[] = {
         { } /* end */
 };
 
+static snd_kcontrol_new_t alc260_fujitsu_mixer[] = {
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
+        ALC_PINCTL_SWITCH("Headphone Amp Switch", 0x14, PIN_HP_AMP),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
+        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
+        HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
+        HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x09, 2, HDA_INPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .info = alc_mux_enum_info,
+                .get = alc_mux_enum_get,
+                .put = alc_mux_enum_put,
+        },
+        { } /* end */
+};
+
 static struct hda_verb alc260_init_verbs[] = {
         /* Line In pin widget for input */
         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
@@ -2332,6 +2347,60 @@ static struct hda_verb alc260_init_verbs[] = {
         { }
 };
 
+/* Initialisation sequence for ALC260 as configured in Fujitsu S702x
+ * laptops.
+ */
+static struct hda_verb alc260_fujitsu_init_verbs[] = {
+        /* Disable all GPIOs */
+        {0x01, AC_VERB_SET_GPIO_MASK, 0},
+        /* Internal speaker is connected to headphone pin */
+        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Headphone/Line-out jack connects to Line1 pin; make it an output */
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        /* Ensure all other unused pins are disabled and muted.
+         * Note: trying to set widget 0x15 to anything blocks all audio
+         * output for some reason, so just leave that at the default.
+         */
+        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
+        {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        /* Disable digital (SPDIF) pins */
+        {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
+        {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
+
+        /* Start with mixer outputs muted */
+        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+
+        /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
+        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Unmute Line1 pin widget amp left and right (no equiv mixer ctrl) */
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        /* Unmute pin widget used for Line-in (no equiv mixer ctrl) */
+        {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
+
+        /* Mute capture amp left and right */
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
+        /* Set ADC connection select to line in (on mic1 pin) */
+        {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
+
+        /* Mute all inputs to mixer widget (even unconnected ones) */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
+        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
+};
+
 static struct hda_pcm_stream alc260_pcm_analog_playback = {
         .substreams = 1,
         .channels_min = 2,
@@ -2347,6 +2416,8 @@ static struct hda_pcm_stream alc260_pcm_analog_capture = {
 static struct hda_board_config alc260_cfg_tbl[] = {
         { .modelname = "hp", .config = ALC260_HP },
         { .pci_subvendor = 0x103c, .config = ALC260_HP },
+        { .modelname = "fujitsu", .config = ALC260_FUJITSU_S702x },
+        { .pci_subvendor = 0x10cf, .pci_subdevice = 0x1326, .config = ALC260_FUJITSU_S702x },
         {}
 };
 
@@ -2359,7 +2430,6 @@ static int patch_alc260(struct hda_codec *codec)
         if (spec == NULL)
                 return -ENOMEM;
 
-        init_MUTEX(&spec->bind_mutex);
         codec->spec = spec;
 
         board_config = snd_hda_check_board_config(codec, alc260_cfg_tbl);
@@ -2373,14 +2443,23 @@ static int patch_alc260(struct hda_codec *codec)
                 spec->mixers[spec->num_mixers] = alc260_hp_mixer;
                 spec->num_mixers++;
                 break;
+        case ALC260_FUJITSU_S702x:
+                spec->mixers[spec->num_mixers] = alc260_fujitsu_mixer;
+                spec->num_mixers++;
+                break;
         default:
                 spec->mixers[spec->num_mixers] = alc260_base_mixer;
                 spec->num_mixers++;
                 break;
         }
 
-        spec->init_verbs[0] = alc260_init_verbs;
-        spec->num_init_verbs = 1;
+        if (board_config != ALC260_FUJITSU_S702x) {
+                spec->init_verbs[0] = alc260_init_verbs;
+                spec->num_init_verbs = 1;
+        } else {
+                spec->init_verbs[0] = alc260_fujitsu_init_verbs;
+                spec->num_init_verbs = 1;
+        }
 
         spec->channel_mode = alc260_modes;
         spec->num_channel_mode = ARRAY_SIZE(alc260_modes);
@@ -2393,7 +2472,11 @@ static int patch_alc260(struct hda_codec *codec)
         spec->multiout.num_dacs = ARRAY_SIZE(alc260_dac_nids);
         spec->multiout.dac_nids = alc260_dac_nids;
 
-        spec->input_mux = &alc260_capture_source;
+        if (board_config != ALC260_FUJITSU_S702x) {
+                spec->input_mux = &alc260_capture_source;
+        } else {
+                spec->input_mux = &alc260_fujitsu_capture_source;
+        }
         switch (board_config) {
         case ALC260_HP:
                 spec->num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids);
@@ -2483,15 +2566,15 @@ static int alc882_mux_enum_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u
  */
 static snd_kcontrol_new_t alc882_base_mixer[] = {
         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
-        ALC_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
+        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
-        ALC_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
+        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
@@ -2609,7 +2692,6 @@ static int patch_alc882(struct hda_codec *codec)
         if (spec == NULL)
                 return -ENOMEM;
 
-        init_MUTEX(&spec->bind_mutex);
         codec->spec = spec;
 
         spec->mixers[spec->num_mixers] = alc882_base_mixer;
diff --git a/sound/pci/hda/patch_si3054.c b/sound/pci/hda/patch_si3054.c
index d014b7bb70df..9c7fe0b3200a 100644
--- a/sound/pci/hda/patch_si3054.c
+++ b/sound/pci/hda/patch_si3054.c
@@ -3,7 +3,7 @@
  *
  * HD audio interface patch for Silicon Labs 3054/5 modem codec
  *
- * Copyright (c) 2005 Sasha Khapyorsky <sashak@smlink.com>
+ * Copyright (c) 2005 Sasha Khapyorsky <sashak@alsa-project.org>
  *                    Takashi Iwai <tiwai@suse.de>
  *
  *