Merge branch 'for-2.6.36' into for-2.6.37

Fairly simple conflicts, the most serious ones are the i.MX ones which I suspect now need another rename. Conflicts: arch/arm/mach-mx2/clock_imx27.c arch/arm/mach-mx2/devices.c arch/arm/mach-omap2/board-rx51-peripherals.c arch/arm/mach-omap2/board-zoom2.c sound/soc/fsl/mpc5200_dma.c sound/soc/fsl/mpc5200_dma.h sound/soc/fsl/mpc8610_hpcd.c sound/soc/pxa/spitz.c
author: Mark Brown <broonie@opensource.wolfsonmicro.com> 2010-08-16 13:42:58 -0400
committer: Mark Brown <broonie@opensource.wolfsonmicro.com> 2010-08-16 13:42:58 -0400
commit: e4862f2f6f5653dfb67f3ba2b6f0bc74516ed51a (patch)
tree: 1db5a0540a4eecfad9b7daee476b985e82ddc810 /sound
parent: ec62dbd7eb8e3dddb221da89ecbcea0fc3dee8c1 (diff)
parent: b2c1e07b81a126e5846dfc3d36f559d861df59f4 (diff)
87 files changed, 2825 insertions, 963 deletions
diff --git a/sound/aoa/soundbus/core.c b/sound/aoa/soundbus/core.c
index 99ca7120e269..7487eb76e034 100644
--- a/sound/aoa/soundbus/core.c
+++ b/sound/aoa/soundbus/core.c
@@ -59,7 +59,7 @@ static int soundbus_probe(struct device *dev)
 static int soundbus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
        struct soundbus_dev * soundbus_dev;
-        struct of_device * of;
+        struct platform_device * of;
        const char *compat;
        int retval = 0;
        int cplen, seen = 0;
diff --git a/sound/aoa/soundbus/i2sbus/core.c b/sound/aoa/soundbus/i2sbus/core.c
index 678933721735..3ff8cc5f487a 100644
--- a/sound/aoa/soundbus/i2sbus/core.c
+++ b/sound/aoa/soundbus/i2sbus/core.c
@@ -437,9 +437,11 @@ static int i2sbus_shutdown(struct macio_dev* dev)
 }
 static struct macio_driver i2sbus_drv = {
-        .name = "soundbus-i2s",
+        .driver = {
-        .owner = THIS_MODULE,
+                .name = "soundbus-i2s",
-        .match_table = i2sbus_match,
+                .owner = THIS_MODULE,
+                .of_match_table = i2sbus_match,
+        },
        .probe = i2sbus_probe,
        .remove = i2sbus_remove,
 #ifdef CONFIG_PM
diff --git a/sound/aoa/soundbus/soundbus.h b/sound/aoa/soundbus/soundbus.h
index a0f223c13f66..adecbf36f4f6 100644
--- a/sound/aoa/soundbus/soundbus.h
+++ b/sound/aoa/soundbus/soundbus.h
@@ -141,7 +141,7 @@ struct soundbus_dev {
        struct list_head onbuslist;
        /* the of device it represents */
-        struct of_device ofdev;
+        struct platform_device ofdev;
        /* what modules go by */
        char modalias[32];
diff --git a/sound/aoa/soundbus/sysfs.c b/sound/aoa/soundbus/sysfs.c
index 6496e754f00a..e0980b5c2cd8 100644
--- a/sound/aoa/soundbus/sysfs.c
+++ b/sound/aoa/soundbus/sysfs.c
@@ -16,7 +16,7 @@ static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
                             char *buf)
 {
        struct soundbus_dev *sdev = to_soundbus_device(dev);
-        struct of_device *of = &sdev->ofdev;
+        struct platform_device *of = &sdev->ofdev;
        int length;
        if (*sdev->modalias) {
diff --git a/sound/atmel/ac97c.c b/sound/atmel/ac97c.c
index 428121a7e705..10c3a871a12d 100644
--- a/sound/atmel/ac97c.c
+++ b/sound/atmel/ac97c.c
@@ -657,7 +657,7 @@ static irqreturn_t atmel_ac97c_interrupt(int irq, void *dev)
        if (sr & AC97C_SR_CAEVT) {
                struct snd_pcm_runtime *runtime;
                int offset, next_period, block_size;
-                dev_info(&chip->pdev->dev, "channel A event%s%s%s%s%s%s\n",
+                dev_dbg(&chip->pdev->dev, "channel A event%s%s%s%s%s%s\n",
                                casr & AC97C_CSR_OVRUN   ? " OVRUN"   : "",
                                casr & AC97C_CSR_RXRDY   ? " RXRDY"   : "",
                                casr & AC97C_CSR_UNRUN   ? " UNRUN"   : "",
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index e9d98be190c5..e23e0e7ab26f 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -67,6 +67,8 @@ void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_ufram
        } else {
                if (new_hw_ptr == ULONG_MAX) {  /* initialization */
                        snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);
+                        if (avail > runtime->buffer_size)
+                                avail = runtime->buffer_size;
                        runtime->silence_filled = avail > 0 ? avail : 0;
                        runtime->silence_start = (runtime->status->hw_ptr +
                                                  runtime->silence_filled) %
@@ -287,8 +289,11 @@ int snd_pcm_update_state(struct snd_pcm_substream *substream,
                        return -EPIPE;
                }
        }
-        if (avail >= runtime->control->avail_min)
+        if (runtime->twake) {
-                wake_up(runtime->twake ? &runtime->tsleep : &runtime->sleep);
+                if (avail >= runtime->twake)
+                        wake_up(&runtime->tsleep);
+        } else if (avail >= runtime->control->avail_min)
+                wake_up(&runtime->sleep);
        return 0;
 }
@@ -1707,7 +1712,7 @@ EXPORT_SYMBOL(snd_pcm_period_elapsed);
 * The available space is stored on availp.  When err = 0 and avail = 0
 * on the capture stream, it indicates the stream is in DRAINING state.
 */
-static int wait_for_avail_min(struct snd_pcm_substream *substream,
+static int wait_for_avail(struct snd_pcm_substream *substream,
                              snd_pcm_uframes_t *availp)
 {
        struct snd_pcm_runtime *runtime = substream->runtime;
@@ -1757,7 +1762,7 @@ static int wait_for_avail_min(struct snd_pcm_substream *substream,
                        avail = snd_pcm_playback_avail(runtime);
                else
                        avail = snd_pcm_capture_avail(runtime);
-                if (avail >= runtime->control->avail_min)
+                if (avail >= runtime->twake)
                        break;
        }
 _endloop:
@@ -1820,7 +1825,7 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
                goto _end_unlock;
        }
-        runtime->twake = 1;
+        runtime->twake = runtime->control->avail_min ? : 1;
        while (size > 0) {
                snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
                snd_pcm_uframes_t avail;
@@ -1833,7 +1838,9 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
                                err = -EAGAIN;
                                goto _end_unlock;
                        }
-                        err = wait_for_avail_min(substream, &avail);
+                        runtime->twake = min_t(snd_pcm_uframes_t, size,
+                                        runtime->control->avail_min ? : 1);
+                        err = wait_for_avail(substream, &avail);
                        if (err < 0)
                                goto _end_unlock;
                }
@@ -2042,7 +2049,7 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                goto _end_unlock;
        }
-        runtime->twake = 1;
+        runtime->twake = runtime->control->avail_min ? : 1;
        while (size > 0) {
                snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
                snd_pcm_uframes_t avail;
@@ -2060,7 +2067,9 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                                err = -EAGAIN;
                                goto _end_unlock;
                        }
-                        err = wait_for_avail_min(substream, &avail);
+                        runtime->twake = min_t(snd_pcm_uframes_t, size,
+                                        runtime->control->avail_min ? : 1);
+                        err = wait_for_avail(substream, &avail);
                        if (err < 0)
                                goto _end_unlock;
                        if (!avail)
diff --git a/sound/core/pcm_misc.c b/sound/core/pcm_misc.c
index ea2bf82c9373..434af3c56d52 100644
--- a/sound/core/pcm_misc.c
+++ b/sound/core/pcm_misc.c
@@ -128,6 +128,14 @@ static struct pcm_format_data pcm_formats[SNDRV_PCM_FORMAT_LAST+1] = {
                .width = 4, .phys = 4, .le = -1, .signd = -1,
                .silence = {},
        },
+        [SNDRV_PCM_FORMAT_G723_24] = {
+                .width = 3, .phys = 3, .le = -1, .signd = -1,
+                .silence = {},
+        },
+        [SNDRV_PCM_FORMAT_G723_40] = {
+                .width = 5, .phys = 5, .le = -1, .signd = -1,
+                .silence = {},
+        },
        /* FIXME: the following three formats are not defined properly yet */
        [SNDRV_PCM_FORMAT_MPEG] = {
                .le = -1, .signd = -1,
@@ -186,6 +194,14 @@ static struct pcm_format_data pcm_formats[SNDRV_PCM_FORMAT_LAST+1] = {
                .width = 18, .phys = 24, .le = 0, .signd = 0,
                .silence = { 0x02, 0x00, 0x00 },
        },
+        [SNDRV_PCM_FORMAT_G723_24_1B] = {
+                .width = 3, .phys = 8, .le = -1, .signd = -1,
+                .silence = {},
+        },
+        [SNDRV_PCM_FORMAT_G723_40_1B] = {
+                .width = 5, .phys = 8, .le = -1, .signd = -1,
+                .silence = {},
+        },
 };
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 303ac04ff6e4..a3b2a6479246 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -451,13 +451,11 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
        snd_pcm_timer_resolution_change(substream);
        runtime->status->state = SNDRV_PCM_STATE_SETUP;
-        if (substream->latency_pm_qos_req) {
+        if (pm_qos_request_active(&substream->latency_pm_qos_req))
-                pm_qos_remove_request(substream->latency_pm_qos_req);
+                pm_qos_remove_request(&substream->latency_pm_qos_req);
-                substream->latency_pm_qos_req = NULL;
-        }
        if ((usecs = period_to_usecs(runtime)) >= 0)
-                substream->latency_pm_qos_req = pm_qos_add_request(
+                pm_qos_add_request(&substream->latency_pm_qos_req,
-                                        PM_QOS_CPU_DMA_LATENCY, usecs);
+                                   PM_QOS_CPU_DMA_LATENCY, usecs);
        return 0;
 _error:
        /* hardware might be unuseable from this time,
@@ -512,8 +510,7 @@ static int snd_pcm_hw_free(struct snd_pcm_substream *substream)
        if (substream->ops->hw_free)
                result = substream->ops->hw_free(substream);
        runtime->status->state = SNDRV_PCM_STATE_OPEN;
-        pm_qos_remove_request(substream->latency_pm_qos_req);
+        pm_qos_remove_request(&substream->latency_pm_qos_req);
-        substream->latency_pm_qos_req = NULL;
        return result;
 }
diff --git a/sound/drivers/Kconfig b/sound/drivers/Kconfig
index 84714a65e5c8..480c38623da8 100644
--- a/sound/drivers/Kconfig
+++ b/sound/drivers/Kconfig
@@ -155,7 +155,7 @@ config SND_ML403_AC97CR
        select SND_AC97_CODEC
        help
          Say Y here to include support for the
-          opb_ac97_controller_ref_v1_00_a ip core found in Xilinx' ML403
+          opb_ac97_controller_ref_v1_00_a ip core found in Xilinx's ML403
          reference design.
          To compile this driver as a module, choose M here: the module
@@ -170,9 +170,25 @@ config SND_AC97_POWER_SAVE
          AC97 codecs.  In this mode, the power-mode is dynamically
          controlled at each open/close.
-          The mode is activated by passing power_save=1 option to
+          The mode is activated by passing 'power_save=X' to the
-          snd-ac97-codec driver.  You can toggle it dynamically over
+          snd-ac97-codec driver module, where 'X' is the time-out
-          sysfs, too.
+          value, a nonnegative integer that specifies how many
+          seconds of idle time the driver must count before it may
+          put the AC97 into power-save mode;  a value of 0 (zero)
+          disables the use of this power-save mode.
+          After the snd-ac97-codec driver module has been loaded,
+          the 'power_save' parameter can be set via sysfs as follows:
+            echo 10 > /sys/module/snd_ac97_codec/parameters/power_save
+          In this case, the time-out is set to 10 seconds; setting
+          the time-out to 1 second (the minimum activation value)
+          isn't recommended because many applications try to reopen
+          the device frequently.  A value of 10 seconds would be a
+          good choice for normal operations.
+          See Documentation/sound/alsa/powersave.txt for more details.
 config SND_AC97_POWER_SAVE_DEFAULT
        int "Default time-out for AC97 power-save mode"
@@ -182,4 +198,6 @@ config SND_AC97_POWER_SAVE_DEFAULT
          The default time-out value in seconds for AC97 automatic
          power-save mode.  0 means to disable the power-save mode.
+          See SND_AC97_POWER_SAVE for more details.
 endif   # SND_DRIVERS
diff --git a/sound/isa/msnd/msnd_pinnacle.c b/sound/isa/msnd/msnd_pinnacle.c
index 60b6abd71612..5f3e68401f90 100644
--- a/sound/isa/msnd/msnd_pinnacle.c
+++ b/sound/isa/msnd/msnd_pinnacle.c
@@ -549,7 +549,10 @@ static int __devinit snd_msnd_attach(struct snd_card *card)
                printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", chip->irq);
                return err;
        }
-        request_region(chip->io, DSP_NUMIO, card->shortname);
+        if (request_region(chip->io, DSP_NUMIO, card->shortname) == NULL) {
+                free_irq(chip->irq, chip);
+                return -EBUSY;
+        }
        if (!request_mem_region(chip->base, BUFFSIZE, card->shortname)) {
                printk(KERN_ERR LOGNAME
diff --git a/sound/isa/sb/emu8000_pcm.c b/sound/isa/sb/emu8000_pcm.c
index ccedbfed061a..2f85c66f8e38 100644
--- a/sound/isa/sb/emu8000_pcm.c
+++ b/sound/isa/sb/emu8000_pcm.c
@@ -433,7 +433,8 @@ static int emu8k_transfer_block(struct snd_emu8000 *emu, int offset, unsigned sh
        while (count > 0) {
                unsigned short sval;
                CHECK_SCHEDULER();
-                get_user(sval, buf);
+                if (get_user(sval, buf))
+                        return -EFAULT;
                EMU8000_SMLD_WRITE(emu, sval);
                buf++;
                count--;
@@ -525,12 +526,14 @@ static int emu8k_pcm_copy(struct snd_pcm_substream *subs,
        while (count-- > 0) {
                unsigned short sval;
                CHECK_SCHEDULER();
-                get_user(sval, buf);
+                if (get_user(sval, buf))
+                        return -EFAULT;
                EMU8000_SMLD_WRITE(emu, sval);
                buf++;
                if (rec->voices > 1) {
                        CHECK_SCHEDULER();
-                        get_user(sval, buf);
+                        if (get_user(sval, buf))
+                                return -EFAULT;
                        EMU8000_SMRD_WRITE(emu, sval);
                        buf++;
                }
diff --git a/sound/oss/ad1848.c b/sound/oss/ad1848.c
index 24793c5b65ac..4d2a6ae978f7 100644
--- a/sound/oss/ad1848.c
+++ b/sound/oss/ad1848.c
@@ -716,7 +716,7 @@ static int ad1848_mixer_ioctl(int dev, unsigned int cmd, void __user *arg)
                                
                                default:
                                        if (get_user(val, (int __user *)arg))
-                                        return -EFAULT;
+                                                return -EFAULT;
                                        val = ad1848_mixer_set(devc, cmd & 0xff, val);
                                        break;
                        } 
diff --git a/sound/oss/au1550_ac97.c b/sound/oss/au1550_ac97.c
index c1070e33b32f..c6f2621221ba 100644
--- a/sound/oss/au1550_ac97.c
+++ b/sound/oss/au1550_ac97.c
@@ -43,13 +43,13 @@
 #include <linux/sound.h>
 #include <linux/slab.h>
 #include <linux/soundcard.h>
+#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
 #include <linux/poll.h>
 #include <linux/bitops.h>
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
 #include <linux/ac97_codec.h>
 #include <linux/mutex.h>
@@ -162,19 +162,10 @@ ld2(unsigned int x)
 static void
 au1550_delay(int msec)
 {
-        unsigned long   tmo;
-        signed long     tmo2;
        if (in_interrupt())
                return;
-        tmo = jiffies + (msec * HZ) / 1000;
+        schedule_timeout_uninterruptible(msecs_to_jiffies(msec));
-        for (;;) {
-                tmo2 = tmo - jiffies;
-                if (tmo2 <= 0)
-                        break;
-                schedule_timeout(tmo2);
-        }
 }
 static u16
@@ -807,7 +798,9 @@ au1550_llseek(struct file *file, loff_t offset, int origin)
 static int
 au1550_open_mixdev(struct inode *inode, struct file *file)
 {
+        lock_kernel();
        file->private_data = &au1550_state;
+        unlock_kernel();
        return 0;
 }
@@ -824,22 +817,26 @@ mixdev_ioctl(struct ac97_codec *codec, unsigned int cmd,
        return codec->mixer_ioctl(codec, cmd, arg);
 }
-static int
+static long
-au1550_ioctl_mixdev(struct inode *inode, struct file *file,
+au1550_ioctl_mixdev(struct file *file, unsigned int cmd, unsigned long arg)
-                               unsigned int cmd, unsigned long arg)
 {
        struct au1550_state *s = (struct au1550_state *)file->private_data;
        struct ac97_codec *codec = s->codec;
+        int ret;
-        return mixdev_ioctl(codec, cmd, arg);
+        lock_kernel();
+        ret = mixdev_ioctl(codec, cmd, arg);
+        unlock_kernel();
+        return ret;
 }
 static /*const */ struct file_operations au1550_mixer_fops = {
-        owner:THIS_MODULE,
+        .owner          = THIS_MODULE,
-        llseek:au1550_llseek,
+        .llseek         = au1550_llseek,
-        ioctl:au1550_ioctl_mixdev,
+        .unlocked_ioctl = au1550_ioctl_mixdev,
-        open:au1550_open_mixdev,
+        .open           = au1550_open_mixdev,
-        release:au1550_release_mixdev,
+        .release        = au1550_release_mixdev,
 };
 static int
@@ -1343,8 +1340,7 @@ dma_count_done(struct dmabuf *db)
 static int
-au1550_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+au1550_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
-                                                        unsigned long arg)
 {
        struct au1550_state *s = (struct au1550_state *)file->private_data;
        unsigned long   flags;
@@ -1780,6 +1776,17 @@ au1550_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
        return mixdev_ioctl(s->codec, cmd, arg);
 }
+static long
+au1550_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        int ret;
+        lock_kernel();
+        ret = au1550_ioctl(file, cmd, arg);
+        unlock_kernel();
+        return ret;
+}
 static int
 au1550_open(struct inode *inode, struct file *file)
@@ -1797,21 +1804,22 @@ au1550_open(struct inode *inode, struct file *file)
 #endif
        file->private_data = s;
+        lock_kernel();
        /* wait for device to become free */
        mutex_lock(&s->open_mutex);
        while (s->open_mode & file->f_mode) {
-                if (file->f_flags & O_NONBLOCK) {
+                ret = -EBUSY;
-                        mutex_unlock(&s->open_mutex);
+                if (file->f_flags & O_NONBLOCK)
-                        return -EBUSY;
+                        goto out;
-                }
                add_wait_queue(&s->open_wait, &wait);
                __set_current_state(TASK_INTERRUPTIBLE);
                mutex_unlock(&s->open_mutex);
                schedule();
                remove_wait_queue(&s->open_wait, &wait);
                set_current_state(TASK_RUNNING);
+                ret = -ERESTARTSYS;
                if (signal_pending(current))
-                        return -ERESTARTSYS;
+                        goto out2;
                mutex_lock(&s->open_mutex);
        }
@@ -1840,17 +1848,21 @@ au1550_open(struct inode *inode, struct file *file)
        if (file->f_mode & FMODE_READ) {
                if ((ret = prog_dmabuf_adc(s)))
-                        return ret;
+                        goto out;
        }
        if (file->f_mode & FMODE_WRITE) {
                if ((ret = prog_dmabuf_dac(s)))
-                        return ret;
+                        goto out;
        }
        s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
-        mutex_unlock(&s->open_mutex);
        mutex_init(&s->sem);
-        return 0;
+        ret = 0;
+out:
+        mutex_unlock(&s->open_mutex);
+out2:
+        unlock_kernel();
+        return ret;
 }
 static int
@@ -1885,15 +1897,15 @@ au1550_release(struct inode *inode, struct file *file)
 }
 static /*const */ struct file_operations au1550_audio_fops = {
-        owner:          THIS_MODULE,
+        .owner          = THIS_MODULE,
-        llseek:         au1550_llseek,
+        .llseek         = au1550_llseek,
-        read:           au1550_read,
+        .read           = au1550_read,
-        write:          au1550_write,
+        .write          = au1550_write,
-        poll:           au1550_poll,
+        .poll           = au1550_poll,
-        ioctl:          au1550_ioctl,
+        .unlocked_ioctl = au1550_unlocked_ioctl,
-        mmap:           au1550_mmap,
+        .mmap           = au1550_mmap,
-        open:           au1550_open,
+        .open           = au1550_open,
-        release:        au1550_release,
+        .release        = au1550_release,
 };
 MODULE_AUTHOR("Advanced Micro Devices (AMD), dan@embeddededge.com");
diff --git a/sound/oss/dmasound/dmasound_core.c b/sound/oss/dmasound/dmasound_core.c
index 3f3c3f71db4b..6ecd41abb066 100644
--- a/sound/oss/dmasound/dmasound_core.c
+++ b/sound/oss/dmasound/dmasound_core.c
@@ -323,9 +323,13 @@ static struct {
 static int mixer_open(struct inode *inode, struct file *file)
 {
-        if (!try_module_get(dmasound.mach.owner))
+        lock_kernel();
+        if (!try_module_get(dmasound.mach.owner)) {
+                unlock_kernel();
                return -ENODEV;
+        }
        mixer.busy = 1;
+        unlock_kernel();
        return 0;
 }
@@ -337,8 +341,8 @@ static int mixer_release(struct inode *inode, struct file *file)
        unlock_kernel();
        return 0;
 }
-static int mixer_ioctl(struct inode *inode, struct file *file, u_int cmd,
-                       u_long arg)
+static int mixer_ioctl(struct file *file, u_int cmd, u_long arg)
 {
        if (_SIOC_DIR(cmd) & _SIOC_WRITE)
            mixer.modify_counter++;
@@ -362,11 +366,22 @@ static int mixer_ioctl(struct inode *inode, struct file *file, u_int cmd,
        return -EINVAL;
 }
+static long mixer_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
+{
+        int ret;
+        lock_kernel();
+        ret = mixer_ioctl(file, cmd, arg);
+        unlock_kernel();
+        return ret;
+}
 static const struct file_operations mixer_fops =
 {
        .owner          = THIS_MODULE,
        .llseek         = no_llseek,
-        .ioctl          = mixer_ioctl,
+        .unlocked_ioctl = mixer_unlocked_ioctl,
        .open           = mixer_open,
        .release        = mixer_release,
 };
@@ -737,8 +752,11 @@ static int sq_open(struct inode *inode, struct file *file)
 {
        int rc;
-        if (!try_module_get(dmasound.mach.owner))
+        lock_kernel();
+        if (!try_module_get(dmasound.mach.owner)) {
+                unlock_kernel();
                return -ENODEV;
+        }
        rc = write_sq_open(file); /* checks the f_mode */
        if (rc)
@@ -781,10 +799,11 @@ static int sq_open(struct inode *inode, struct file *file)
                sound_set_format(AFMT_MU_LAW);
        }
 #endif
+        unlock_kernel();
        return 0;
 out:
        module_put(dmasound.mach.owner);
+        unlock_kernel();
        return rc;
 }
@@ -955,8 +974,7 @@ printk("dmasound_core: tried to set_queue_frags on a locked queue\n") ;
        return 0 ;
 }
-static int sq_ioctl(struct inode *inode, struct file *file, u_int cmd,
+static int sq_ioctl(struct file *file, u_int cmd, u_long arg)
-                    u_long arg)
 {
        int val, result;
        u_long fmt;
@@ -1114,18 +1132,29 @@ static int sq_ioctl(struct inode *inode, struct file *file, u_int cmd,
                return IOCTL_OUT(arg,val);
        default:
-                return mixer_ioctl(inode, file, cmd, arg);
+                return mixer_ioctl(file, cmd, arg);
        }
        return -EINVAL;
 }
+static long sq_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
+{
+        int ret;
+        lock_kernel();
+        ret = sq_ioctl(file, cmd, arg);
+        unlock_kernel();
+        return ret;
+}
 static const struct file_operations sq_fops =
 {
        .owner          = THIS_MODULE,
        .llseek         = no_llseek,
        .write          = sq_write,
        .poll           = sq_poll,
-        .ioctl          = sq_ioctl,
+        .unlocked_ioctl = sq_unlocked_ioctl,
        .open           = sq_open,
        .release        = sq_release,
 };
@@ -1226,12 +1255,17 @@ static int state_open(struct inode *inode, struct file *file)
 {
        char *buffer = state.buf;
        int len = 0;
+        int ret;
+        lock_kernel();
+        ret = -EBUSY;
        if (state.busy)
-                return -EBUSY;
+                goto out;
+        ret = -ENODEV;
        if (!try_module_get(dmasound.mach.owner))
-                return -ENODEV;
+                goto out;
        state.ptr = 0;
        state.busy = 1;
@@ -1293,7 +1327,10 @@ printk("dmasound: stat buffer used %d bytes\n", len) ;
                printk(KERN_ERR "dmasound_core: stat buffer overflowed!\n");
        state.len = len;
-        return 0;
+        ret = 0;
+out:
+        unlock_kernel();
+        return ret;
 }
 static int state_release(struct inode *inode, struct file *file)
diff --git a/sound/oss/midi_synth.c b/sound/oss/midi_synth.c
index 3bc7104c5379..3c09374ea5bf 100644
--- a/sound/oss/midi_synth.c
+++ b/sound/oss/midi_synth.c
@@ -523,7 +523,9 @@ midi_synth_load_patch(int dev, int format, const char __user *addr,
        {
                unsigned char   data;
-                get_user(*(unsigned char *) &data, (unsigned char __user *) &((addr)[hdr_size + i]));
+                if (get_user(data,
+                    (unsigned char __user *)(addr + hdr_size + i)))
+                        return -EFAULT;
                eox_seen = (i > 0 && data & 0x80);      /* End of sysex */
diff --git a/sound/oss/msnd_pinnacle.c b/sound/oss/msnd_pinnacle.c
index a1e3f9671bea..2e48b17667d0 100644
--- a/sound/oss/msnd_pinnacle.c
+++ b/sound/oss/msnd_pinnacle.c
@@ -639,21 +639,26 @@ static int mixer_ioctl(unsigned int cmd, unsigned long arg)
        return -EINVAL;
 }
-static int dev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static long dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        int minor = iminor(inode);
+        int minor = iminor(file->f_path.dentry->d_inode);
+        int ret;
        if (cmd == OSS_GETVERSION) {
                int sound_version = SOUND_VERSION;
                return put_user(sound_version, (int __user *)arg);
        }
+        ret = -EINVAL;
+        lock_kernel();
        if (minor == dev.dsp_minor)
-                return dsp_ioctl(file, cmd, arg);
+                ret = dsp_ioctl(file, cmd, arg);
        else if (minor == dev.mixer_minor)
-                return mixer_ioctl(cmd, arg);
+                ret = mixer_ioctl(cmd, arg);
+        unlock_kernel();
-        return -EINVAL;
+        return ret;
 }
 static void dsp_write_flush(void)
@@ -756,12 +761,15 @@ static int dev_open(struct inode *inode, struct file *file)
        int minor = iminor(inode);
        int err = 0;
+        lock_kernel();
        if (minor == dev.dsp_minor) {
                if ((file->f_mode & FMODE_WRITE &&
                     test_bit(F_AUDIO_WRITE_INUSE, &dev.flags)) ||
                    (file->f_mode & FMODE_READ &&
-                     test_bit(F_AUDIO_READ_INUSE, &dev.flags)))
+                     test_bit(F_AUDIO_READ_INUSE, &dev.flags))) {
-                        return -EBUSY;
+                        err = -EBUSY;
+                        goto out;
+                }
                if ((err = dsp_open(file)) >= 0) {
                        dev.nresets = 0;
@@ -782,7 +790,8 @@ static int dev_open(struct inode *inode, struct file *file)
                /* nothing */
        } else
                err = -EINVAL;
+out:
+        unlock_kernel();
        return err;
 }
@@ -1105,7 +1114,7 @@ static const struct file_operations dev_fileops = {
        .owner          = THIS_MODULE,
        .read           = dev_read,
        .write          = dev_write,
-        .ioctl          = dev_ioctl,
+        .unlocked_ioctl = dev_ioctl,
        .open           = dev_open,
        .release        = dev_release,
 };
@@ -1391,9 +1400,13 @@ static int __init attach_multisound(void)
                printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", dev.irq);
                return err;
        }
-        request_region(dev.io, dev.numio, dev.name);
+        if (request_region(dev.io, dev.numio, dev.name) == NULL) {
+                free_irq(dev.irq, &dev);
+                return -EBUSY;
+        }
-        if ((err = dsp_full_reset()) < 0) {
+        err = dsp_full_reset();
+        if (err < 0) {
                release_region(dev.io, dev.numio);
                free_irq(dev.irq, &dev);
                return err;
diff --git a/sound/oss/sh_dac_audio.c b/sound/oss/sh_dac_audio.c
index 4153752507e3..479e3025a8a3 100644
--- a/sound/oss/sh_dac_audio.c
+++ b/sound/oss/sh_dac_audio.c
@@ -16,6 +16,7 @@
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/sound.h>
+#include <linux/smp_lock.h>
 #include <linux/soundcard.h>
 #include <linux/interrupt.h>
 #include <linux/hrtimer.h>
@@ -92,7 +93,7 @@ static void dac_audio_set_rate(void)
        wakeups_per_second = ktime_set(0, 1000000000 / rate);
 }
-static int dac_audio_ioctl(struct inode *inode, struct file *file,
+static int dac_audio_ioctl(struct file *file,
                           unsigned int cmd, unsigned long arg)
 {
        int val;
@@ -158,6 +159,17 @@ static int dac_audio_ioctl(struct inode *inode, struct file *file,
        return -EINVAL;
 }
+static long dac_audio_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
+{
+        int ret;
+        lock_kernel();
+        ret = dac_audio_ioctl(file, cmd, arg);
+        unlock_kernel();
+        return ret;
+}
 static ssize_t dac_audio_write(struct file *file, const char *buf, size_t count,
                               loff_t * ppos)
 {
@@ -216,13 +228,17 @@ static int dac_audio_open(struct inode *inode, struct file *file)
 {
        if (file->f_mode & FMODE_READ)
                return -ENODEV;
-        if (in_use)
+        lock_kernel();
+        if (in_use) {
+                unlock_kernel();
                return -EBUSY;
+        }
        in_use = 1;
        dac_audio_start();
+        unlock_kernel();
        return 0;
 }
@@ -237,8 +253,8 @@ static int dac_audio_release(struct inode *inode, struct file *file)
 const struct file_operations dac_audio_fops = {
      .read =           dac_audio_read,
-      .write =  dac_audio_write,
+      .write =          dac_audio_write,
-      .ioctl =  dac_audio_ioctl,
+      .unlocked_ioctl = dac_audio_unlocked_ioctl,
      .open =           dac_audio_open,
      .release =        dac_audio_release,
 };
diff --git a/sound/oss/soundcard.c b/sound/oss/soundcard.c
index 2d9c51312622..92aa762ffb7e 100644
--- a/sound/oss/soundcard.c
+++ b/sound/oss/soundcard.c
@@ -210,42 +210,44 @@ static int sound_open(struct inode *inode, struct file *file)
                printk(KERN_ERR "Invalid minor device %d\n", dev);
                return -ENXIO;
        }
+        lock_kernel();
        switch (dev & 0x0f) {
        case SND_DEV_CTL:
                dev >>= 4;
                if (dev >= 0 && dev < MAX_MIXER_DEV && mixer_devs[dev] == NULL) {
                        request_module("mixer%d", dev);
                }
+                retval = -ENXIO;
                if (dev && (dev >= num_mixers || mixer_devs[dev] == NULL))
-                        return -ENXIO;
+                        break;
        
                if (!try_module_get(mixer_devs[dev]->owner))
-                        return -ENXIO;
+                        break;
+                retval = 0;
                break;
        case SND_DEV_SEQ:
        case SND_DEV_SEQ2:
-                if ((retval = sequencer_open(dev, file)) < 0)
+                retval = sequencer_open(dev, file);
-                        return retval;
                break;
        case SND_DEV_MIDIN:
-                if ((retval = MIDIbuf_open(dev, file)) < 0)
+                retval = MIDIbuf_open(dev, file);
-                        return retval;
                break;
        case SND_DEV_DSP:
        case SND_DEV_DSP16:
        case SND_DEV_AUDIO:
-                if ((retval = audio_open(dev, file)) < 0)
+                retval = audio_open(dev, file);
-                        return retval;
                break;
        default:
                printk(KERN_ERR "Invalid minor device %d\n", dev);
-                return -ENXIO;
+                retval = -ENXIO;
        }
+        unlock_kernel();
        return 0;
 }
diff --git a/sound/oss/swarm_cs4297a.c b/sound/oss/swarm_cs4297a.c
index 3136c88eacdf..b15840ad2527 100644
--- a/sound/oss/swarm_cs4297a.c
+++ b/sound/oss/swarm_cs4297a.c
@@ -68,6 +68,7 @@
 #include <linux/delay.h>
 #include <linux/sound.h>
 #include <linux/slab.h>
+#include <linux/smp_lock.h>
 #include <linux/soundcard.h>
 #include <linux/ac97_codec.h>
 #include <linux/pci.h>
@@ -1534,6 +1535,7 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file)
        CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
                  printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()+\n"));
+        lock_kernel();
        list_for_each(entry, &cs4297a_devs)
        {
                s = list_entry(entry, struct cs4297a_state, list);
@@ -1544,6 +1546,8 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file)
        {
                CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
                        printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()- -ENODEV\n"));
+                unlock_kernel();
                return -ENODEV;
        }
        VALIDATE_STATE(s);
@@ -1551,6 +1555,7 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file)
        CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
                  printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()- 0\n"));
+        unlock_kernel();
        return nonseekable_open(inode, file);
 }
@@ -1566,11 +1571,15 @@ static int cs4297a_release_mixdev(struct inode *inode, struct file *file)
 }
-static int cs4297a_ioctl_mixdev(struct inode *inode, struct file *file,
+static int cs4297a_ioctl_mixdev(struct file *file,
                               unsigned int cmd, unsigned long arg)
 {
-        return mixer_ioctl((struct cs4297a_state *) file->private_data, cmd,
+        int ret;
+        lock_kernel();
+        ret = mixer_ioctl((struct cs4297a_state *) file->private_data, cmd,
                           arg);
+        unlock_kernel();
+        return ret;
 }
@@ -1580,7 +1589,7 @@ static int cs4297a_ioctl_mixdev(struct inode *inode, struct file *file,
 static const struct file_operations cs4297a_mixer_fops = {
        .owner          = THIS_MODULE,
        .llseek         = no_llseek,
-        .ioctl          = cs4297a_ioctl_mixdev,
+        .unlocked_ioctl = cs4297a_ioctl_mixdev,
        .open           = cs4297a_open_mixdev,
        .release        = cs4297a_release_mixdev,
 };
@@ -1944,7 +1953,7 @@ static int cs4297a_mmap(struct file *file, struct vm_area_struct *vma)
 }
-static int cs4297a_ioctl(struct inode *inode, struct file *file,
+static int cs4297a_ioctl(struct file *file,
                        unsigned int cmd, unsigned long arg)
 {
        struct cs4297a_state *s =
@@ -2337,6 +2346,16 @@ static int cs4297a_ioctl(struct inode *inode, struct file *file,
        return mixer_ioctl(s, cmd, arg);
 }
+static long cs4297a_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
+{
+        int ret;
+        lock_kernel();
+        ret = cs4297a_ioctl(file, cmd, arg);
+        unlock_kernel();
+        return ret;
+}
 static int cs4297a_release(struct inode *inode, struct file *file)
 {
@@ -2369,7 +2388,7 @@ static int cs4297a_release(struct inode *inode, struct file *file)
        return 0;
 }
-static int cs4297a_open(struct inode *inode, struct file *file)
+static int cs4297a_locked_open(struct inode *inode, struct file *file)
 {
        int minor = iminor(inode);
        struct cs4297a_state *s=NULL;
@@ -2486,6 +2505,16 @@ static int cs4297a_open(struct inode *inode, struct file *file)
        return nonseekable_open(inode, file);
 }
+static int cs4297a_open(struct inode *inode, struct file *file)
+{
+        int ret;
+        lock_kernel();
+        ret = cs4297a_open(inode, file);
+        unlock_kernel();
+        return ret;
+}
 // ******************************************************************************************
 //   Wave (audio) file operations struct.
@@ -2496,7 +2525,7 @@ static const struct file_operations cs4297a_audio_fops = {
        .read           = cs4297a_read,
        .write          = cs4297a_write,
        .poll           = cs4297a_poll,
-        .ioctl          = cs4297a_ioctl,
+        .unlocked_ioctl = cs4297a_unlocked_ioctl,
        .mmap           = cs4297a_mmap,
        .open           = cs4297a_open,
        .release        = cs4297a_release,
diff --git a/sound/oss/vidc.c b/sound/oss/vidc.c
index ac39a531df19..f0e0caa53200 100644
--- a/sound/oss/vidc.c
+++ b/sound/oss/vidc.c
@@ -491,9 +491,6 @@ static void __init attach_vidc(struct address_info *hw_config)
        vidc_adev = adev;
        vidc_mixer_set(SOUND_MIXER_VOLUME, (85 | 85 << 8));
-#if defined(CONFIG_SOUND_SOFTOSS) || defined(CONFIG_SOUND_SOFTOSS_MODULE)
-        softoss_dev = adev;
-#endif
        return;
 irq_failed:
diff --git a/sound/oss/vwsnd.c b/sound/oss/vwsnd.c
index 20b3b325aa80..8cd73cdd88af 100644
--- a/sound/oss/vwsnd.c
+++ b/sound/oss/vwsnd.c
@@ -2429,8 +2429,7 @@ static unsigned int vwsnd_audio_poll(struct file *file,
        return mask;
 }
-static int vwsnd_audio_do_ioctl(struct inode *inode,
+static int vwsnd_audio_do_ioctl(struct file *file,
-                                struct file *file,
                                unsigned int cmd,
                                unsigned long arg)
 {
@@ -2446,8 +2445,8 @@ static int vwsnd_audio_do_ioctl(struct inode *inode,
        int ival;
        
-        DBGEV("(inode=0x%p, file=0x%p, cmd=0x%x, arg=0x%lx)\n",
+        DBGEV("(file=0x%p, cmd=0x%x, arg=0x%lx)\n",
-              inode, file, cmd, arg);
+              file, cmd, arg);
        switch (cmd) {
        case OSS_GETVERSION:            /* _SIOR ('M', 118, int) */
                DBGX("OSS_GETVERSION\n");
@@ -2885,17 +2884,19 @@ static int vwsnd_audio_do_ioctl(struct inode *inode,
        return -EINVAL;
 }
-static int vwsnd_audio_ioctl(struct inode *inode,
+static long vwsnd_audio_ioctl(struct file *file,
-                                struct file *file,
                                unsigned int cmd,
                                unsigned long arg)
 {
        vwsnd_dev_t *devc = (vwsnd_dev_t *) file->private_data;
        int ret;
+        lock_kernel();
        mutex_lock(&devc->io_mutex);
-        ret = vwsnd_audio_do_ioctl(inode, file, cmd, arg);
+        ret = vwsnd_audio_do_ioctl(file, cmd, arg);
        mutex_unlock(&devc->io_mutex);
+        unlock_kernel();
        return ret;
 }
@@ -2921,6 +2922,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
        DBGE("(inode=0x%p, file=0x%p)\n", inode, file);
+        lock_kernel();
        INC_USE_COUNT;
        for (devc = vwsnd_dev_list; devc; devc = devc->next_dev)
                if ((devc->audio_minor & ~0x0F) == (minor & ~0x0F))
@@ -2928,6 +2930,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
        if (devc == NULL) {
                DEC_USE_COUNT;
+                unlock_kernel();
                return -ENODEV;
        }
@@ -2936,11 +2939,13 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
                mutex_unlock(&devc->open_mutex);
                if (file->f_flags & O_NONBLOCK) {
                        DEC_USE_COUNT;
+                        unlock_kernel();
                        return -EBUSY;
                }
                interruptible_sleep_on(&devc->open_wait);
                if (signal_pending(current)) {
                        DEC_USE_COUNT;
+                        unlock_kernel();
                        return -ERESTARTSYS;
                }
                mutex_lock(&devc->open_mutex);
@@ -2993,6 +2998,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
        file->private_data = devc;
        DBGRV();
+        unlock_kernel();
        return 0;
 }
@@ -3044,7 +3050,7 @@ static const struct file_operations vwsnd_audio_fops = {
        .read =         vwsnd_audio_read,
        .write =        vwsnd_audio_write,
        .poll =         vwsnd_audio_poll,
-        .ioctl =        vwsnd_audio_ioctl,
+        .unlocked_ioctl = vwsnd_audio_ioctl,
        .mmap =         vwsnd_audio_mmap,
        .open =         vwsnd_audio_open,
        .release =      vwsnd_audio_release,
@@ -3062,15 +3068,18 @@ static int vwsnd_mixer_open(struct inode *inode, struct file *file)
        DBGEV("(inode=0x%p, file=0x%p)\n", inode, file);
        INC_USE_COUNT;
+        lock_kernel();
        for (devc = vwsnd_dev_list; devc; devc = devc->next_dev)
                if (devc->mixer_minor == iminor(inode))
                        break;
        if (devc == NULL) {
                DEC_USE_COUNT;
+                unlock_kernel();
                return -ENODEV;
        }
        file->private_data = devc;
+        unlock_kernel();
        return 0;
 }
@@ -3203,8 +3212,7 @@ static int mixer_write_ioctl(vwsnd_dev_t *devc, unsigned int nr, void __user *ar
 /* This is the ioctl entry to the mixer driver. */
-static int vwsnd_mixer_ioctl(struct inode *ioctl,
+static long vwsnd_mixer_ioctl(struct file *file,
-                              struct file *file,
                              unsigned int cmd,
                              unsigned long arg)
 {
@@ -3215,6 +3223,7 @@ static int vwsnd_mixer_ioctl(struct inode *ioctl,
        DBGEV("(devc=0x%p, cmd=0x%x, arg=0x%lx)\n", devc, cmd, arg);
+        lock_kernel();
        mutex_lock(&devc->mix_mutex);
        {
                if ((cmd & ~nrmask) == MIXER_READ(0))
@@ -3225,13 +3234,14 @@ static int vwsnd_mixer_ioctl(struct inode *ioctl,
                        retval = -EINVAL;
        }
        mutex_unlock(&devc->mix_mutex);
+        unlock_kernel();
        return retval;
 }
 static const struct file_operations vwsnd_mixer_fops = {
        .owner =        THIS_MODULE,
        .llseek =       no_llseek,
-        .ioctl =        vwsnd_mixer_ioctl,
+        .unlocked_ioctl = vwsnd_mixer_ioctl,
        .open =         vwsnd_mixer_open,
        .release =      vwsnd_mixer_release,
 };
diff --git a/sound/oss/waveartist.c b/sound/oss/waveartist.c
index e688dde6bbde..52468742d9f2 100644
--- a/sound/oss/waveartist.c
+++ b/sound/oss/waveartist.c
@@ -184,14 +184,8 @@ waveartist_iack(wavnc_info *devc)
 static inline int
 waveartist_sleep(int timeout_ms)
 {
-        unsigned int timeout = timeout_ms * 10 * HZ / 100;
+        unsigned int timeout = msecs_to_jiffies(timeout_ms*100);
+        return schedule_timeout_interruptible(timeout);
-        do {
-                set_current_state(TASK_INTERRUPTIBLE);
-                timeout = schedule_timeout(timeout);
-        } while (timeout);
-        return 0;
 }
 static int
diff --git a/sound/pci/als4000.c b/sound/pci/als4000.c
index 6cf1de8042e8..0e247cb90ecc 100644
--- a/sound/pci/als4000.c
+++ b/sound/pci/als4000.c
@@ -763,9 +763,9 @@ static void snd_als4000_configure(struct snd_sb *chip)
        /* SPECS_PAGE: 39 */
        for (i = ALS4K_GCR91_DMA0_ADDR; i <= ALS4K_GCR96_DMA3_MODE_COUNT; ++i)
                snd_als4k_gcr_write(chip, i, 0);
-        
+        /* enable burst mode to prevent dropouts during high PCI bus usage */
        snd_als4k_gcr_write(chip, ALS4K_GCR99_DMA_EMULATION_CTRL,
-                snd_als4k_gcr_read(chip, ALS4K_GCR99_DMA_EMULATION_CTRL));
+                (snd_als4k_gcr_read(chip, ALS4K_GCR99_DMA_EMULATION_CTRL) & ~0x07) | 0x04);
        spin_unlock_irq(&chip->reg_lock);
 }
diff --git a/sound/pci/asihpi/asihpi.c b/sound/pci/asihpi/asihpi.c
index f74c7372b3d1..c80b0b863c54 100644
--- a/sound/pci/asihpi/asihpi.c
+++ b/sound/pci/asihpi/asihpi.c
@@ -460,6 +460,7 @@ static int snd_card_asihpi_pcm_hw_params(struct snd_pcm_substream *substream,
        struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
        int err;
        u16 format;
+        int width;
        unsigned int bytes_per_sec;
        print_hwparams(params);
@@ -512,9 +513,10 @@ static int snd_card_asihpi_pcm_hw_params(struct snd_pcm_substream *substream,
                                dpcm->hpi_buffer_attached);
        }
        bytes_per_sec = params_rate(params) * params_channels(params);
-        bytes_per_sec *= snd_pcm_format_width(params_format(params));
+        width = snd_pcm_format_width(params_format(params));
+        bytes_per_sec *= width;
        bytes_per_sec /= 8;
-        if (bytes_per_sec <= 0)
+        if (width < 0 || bytes_per_sec == 0)
                return -EINVAL;
        dpcm->bytes_per_sec = bytes_per_sec;
@@ -1383,7 +1385,7 @@ static char *asihpi_src_names[] =
 compile_time_assert(
        (ARRAY_SIZE(asihpi_src_names) ==
-                (HPI_SOURCENODE_LAST_INDEX-HPI_SOURCENODE_BASE+1)),
+                (HPI_SOURCENODE_LAST_INDEX-HPI_SOURCENODE_NONE+1)),
        assert_src_names_size);
 #if ASI_STYLE_NAMES
@@ -1414,7 +1416,7 @@ static char *asihpi_dst_names[] =
 compile_time_assert(
        (ARRAY_SIZE(asihpi_dst_names) ==
-                (HPI_DESTNODE_LAST_INDEX-HPI_DESTNODE_BASE+1)),
+                (HPI_DESTNODE_LAST_INDEX-HPI_DESTNODE_NONE+1)),
        assert_dst_names_size);
 static inline int ctl_add(struct snd_card *card, struct snd_kcontrol_new *ctl,
@@ -2171,7 +2173,7 @@ static int snd_asihpi_mux_info(struct snd_kcontrol *kcontrol,
                                        &src_node_type, &src_node_index);
        sprintf(uinfo->value.enumerated.name, "%s %d",
-                asihpi_src_names[src_node_type - HPI_SOURCENODE_BASE],
+                asihpi_src_names[src_node_type - HPI_SOURCENODE_NONE],
                src_node_index);
        return 0;
 }
@@ -2578,6 +2580,9 @@ static int __devinit snd_card_asihpi_mixer_new(struct snd_card_asihpi *asihpi)
        if (err)
                return -err;
+        memset(&prev_ctl, 0, sizeof(prev_ctl));
+        prev_ctl.control_type = -1;
        for (idx = 0; idx < 2000; idx++) {
                err = hpi_mixer_get_control_by_index(
                                ss, asihpi->h_mixer,
@@ -2600,8 +2605,8 @@ static int __devinit snd_card_asihpi_mixer_new(struct snd_card_asihpi *asihpi)
                }
-                hpi_ctl.src_node_type -= HPI_SOURCENODE_BASE;
+                hpi_ctl.src_node_type -= HPI_SOURCENODE_NONE;
-                hpi_ctl.dst_node_type -= HPI_DESTNODE_BASE;
+                hpi_ctl.dst_node_type -= HPI_DESTNODE_NONE;
                /* ASI50xx in SSX mode has multiple meters on the same node.
                   Use subindex to create distinct ALSA controls
diff --git a/sound/pci/asihpi/hpi.h b/sound/pci/asihpi/hpi.h
index 0173bbe62b67..23399d02f666 100644
--- a/sound/pci/asihpi/hpi.h
+++ b/sound/pci/asihpi/hpi.h
@@ -50,7 +50,8 @@ i.e 3.05.02 is a development version
 #define HPI_VER_RELEASE(v) ((int)(v & 0xFF))
 /* Use single digits for versions less that 10 to avoid octal. */
-#define HPI_VER HPI_VERSION_CONSTRUCTOR(4L, 3, 25)
+#define HPI_VER HPI_VERSION_CONSTRUCTOR(4L, 4, 1)
+#define HPI_VER_STRING "4.04.01"
 /* Library version as documented in hpi-api-versions.txt */
 #define HPI_LIB_VER  HPI_VERSION_CONSTRUCTOR(9, 0, 0)
@@ -203,8 +204,6 @@ enum HPI_SOURCENODES {
        exists on a destination node can be searched for using a source
        node value of either 0, or HPI_SOURCENODE_NONE */
        HPI_SOURCENODE_NONE = 100,
-        /** \deprecated Use HPI_SOURCENODE_NONE instead. */
-        HPI_SOURCENODE_BASE = 100,
        /** Out Stream (Play) node. */
        HPI_SOURCENODE_OSTREAM = 101,
        /** Line in node - could be analog, AES/EBU or network. */
@@ -235,8 +234,6 @@ enum HPI_DESTNODES {
        exists on a source node can be searched for using a destination
        node value of either 0, or HPI_DESTNODE_NONE */
        HPI_DESTNODE_NONE = 200,
-        /** \deprecated Use HPI_DESTNODE_NONE instead. */
-        HPI_DESTNODE_BASE = 200,
        /** In Stream (Record) node. */
        HPI_DESTNODE_ISTREAM = 201,
        HPI_DESTNODE_LINEOUT = 202,         /**< line out node. */
@@ -432,7 +429,18 @@ Property 2 - adapter can do stream grouping (supports SSX2)
 Property 1 - adapter can do samplerate conversion (MRX)
 Property 2 - adapter can do timestretch (TSX)
 */
-        HPI_ADAPTER_PROPERTY_CAPS2 = 269
+        HPI_ADAPTER_PROPERTY_CAPS2 = 269,
+/** Readonly adapter sync header connection count.
+*/
+        HPI_ADAPTER_PROPERTY_SYNC_HEADER_CONNECTIONS = 270,
+/** Readonly supports SSX2 property.
+Indicates the adapter supports SSX2 in some mode setting. The
+return value is true (1) or false (0). If the current adapter
+mode is MONO SSX2 is disabled, even though this property will
+return true.
+*/
+        HPI_ADAPTER_PROPERTY_SUPPORTS_SSX2 = 271
 };
 /** Adapter mode commands
@@ -813,8 +821,6 @@ enum HPI_SAMPLECLOCK_SOURCES {
 /** The sampleclock output is derived from its local samplerate generator.
    The local samplerate may be set using HPI_SampleClock_SetLocalRate(). */
        HPI_SAMPLECLOCK_SOURCE_LOCAL = 1,
-/** \deprecated Use HPI_SAMPLECLOCK_SOURCE_LOCAL instead */
-        HPI_SAMPLECLOCK_SOURCE_ADAPTER = 1,
 /** The adapter is clocked from a dedicated AES/EBU SampleClock input.*/
        HPI_SAMPLECLOCK_SOURCE_AESEBU_SYNC = 2,
 /** From external wordclock connector */
@@ -825,10 +831,6 @@ enum HPI_SAMPLECLOCK_SOURCES {
        HPI_SAMPLECLOCK_SOURCE_SMPTE = 5,
 /** One of the aesebu inputs */
        HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT = 6,
-/** \deprecated The first aesebu input with a valid signal
-Superseded by separate Auto enable flag
-*/
-        HPI_SAMPLECLOCK_SOURCE_AESEBU_AUTO = 7,
 /** From a network interface e.g. Cobranet or Livewire at either 48 or 96kHz */
        HPI_SAMPLECLOCK_SOURCE_NETWORK = 8,
 /** From previous adjacent module (ASI2416 only)*/
@@ -1015,8 +1017,6 @@ enum HPI_ERROR_CODES {
        HPI_ERROR_CONTROL_DISABLED = 404,
        /** I2C transaction failed due to a missing ACK. */
        HPI_ERROR_CONTROL_I2C_MISSING_ACK = 405,
-        /** Control attribute is valid, but not supported by this hardware. */
-        HPI_ERROR_UNSUPPORTED_CONTROL_ATTRIBUTE = 406,
        /** Control is busy, or coming out of
        reset and cannot be accessed at this time. */
        HPI_ERROR_CONTROL_NOT_READY = 407,
@@ -1827,13 +1827,41 @@ u16 hpi_parametricEQ__get_coeffs(const struct hpi_hsubsys *ph_subsys,
  Compressor Expander control
 *******************************/
-u16 hpi_compander_set(const struct hpi_hsubsys *ph_subsys, u32 h_control,
+u16 hpi_compander_set_enable(const struct hpi_hsubsys *ph_subsys,
-        u16 attack, u16 decay, short ratio100, short threshold0_01dB,
+        u32 h_control, u32 on);
-        short makeup_gain0_01dB);
+u16 hpi_compander_get_enable(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 *pon);
+u16 hpi_compander_set_makeup_gain(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, short makeup_gain0_01dB);
+u16 hpi_compander_get_makeup_gain(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, short *pn_makeup_gain0_01dB);
+u16 hpi_compander_set_attack_time_constant(const struct hpi_hsubsys
+        *ph_subsys, u32 h_control, u32 index, u32 attack);
+u16 hpi_compander_get_attack_time_constant(const struct hpi_hsubsys
+        *ph_subsys, u32 h_control, u32 index, u32 *pw_attack);
+u16 hpi_compander_set_decay_time_constant(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, u32 decay);
+u16 hpi_compander_get_decay_time_constant(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, u32 *pw_decay);
+u16 hpi_compander_set_threshold(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, short threshold0_01dB);
+u16 hpi_compander_get_threshold(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, short *pn_threshold0_01dB);
+u16 hpi_compander_set_ratio(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, u32 ratio100);
-u16 hpi_compander_get(const struct hpi_hsubsys *ph_subsys, u32 h_control,
+u16 hpi_compander_get_ratio(const struct hpi_hsubsys *ph_subsys,
-        u16 *pw_attack, u16 *pw_decay, short *pw_ratio100,
+        u32 h_control, u32 index, u32 *pw_ratio100);
-        short *pn_threshold0_01dB, short *pn_makeup_gain0_01dB);
 /*******************************
  Cobranet HMI control
diff --git a/sound/pci/asihpi/hpi6000.c b/sound/pci/asihpi/hpi6000.c
index 12dab5e4892c..f7e374ec4414 100644
--- a/sound/pci/asihpi/hpi6000.c
+++ b/sound/pci/asihpi/hpi6000.c
@@ -687,6 +687,7 @@ static short hpi6000_adapter_boot_load_dsp(struct hpi_adapter_obj *pao,
        switch (pao->pci.subsys_device_id) {
        case 0x5100:
        case 0x5110:    /* ASI5100 revB or higher with C6711D */
+        case 0x5200:    /* ASI5200 PC_ie version of ASI5100 */
        case 0x6100:
        case 0x6200:
                boot_load_family = HPI_ADAPTER_FAMILY_ASI(0x6200);
@@ -1133,6 +1134,12 @@ static short hpi6000_adapter_boot_load_dsp(struct hpi_adapter_obj *pao,
                                                subsys_device_id) ==
                                        HPI_ADAPTER_FAMILY_ASI(0x5100))
                                        mask = 0x00000000L;
+                                /* ASI5200 uses AX6 code, */
+                                /* but has no PLD r/w register to test */
+                                if (HPI_ADAPTER_FAMILY_ASI(pao->pci.
+                                                subsys_device_id) ==
+                                        HPI_ADAPTER_FAMILY_ASI(0x5200))
+                                        mask = 0x00000000L;
                                break;
                        case HPI_ADAPTER_FAMILY_ASI(0x8800):
                                /* ASI8800 has 16bit path to FPGA */
diff --git a/sound/pci/asihpi/hpi6205.c b/sound/pci/asihpi/hpi6205.c
index e89991ea3543..3b4413448226 100644
--- a/sound/pci/asihpi/hpi6205.c
+++ b/sound/pci/asihpi/hpi6205.c
@@ -941,11 +941,11 @@ static void outstream_host_buffer_free(struct hpi_adapter_obj *pao,
 }
-static long outstream_get_space_available(struct hpi_hostbuffer_status
+static u32 outstream_get_space_available(struct hpi_hostbuffer_status
        *status)
 {
-        return status->size_in_bytes - ((long)(status->host_index) -
+        return status->size_in_bytes - (status->host_index -
-                (long)(status->dSP_index));
+                status->dSP_index);
 }
 static void outstream_write(struct hpi_adapter_obj *pao,
@@ -954,7 +954,7 @@ static void outstream_write(struct hpi_adapter_obj *pao,
        struct hpi_hw_obj *phw = pao->priv;
        struct bus_master_interface *interface = phw->p_interface_buffer;
        struct hpi_hostbuffer_status *status;
-        long space_available;
+        u32 space_available;
        if (!phw->outstream_host_buffer_size[phm->obj_index]) {
                /* there  is no BBM buffer, write via message */
@@ -1007,7 +1007,7 @@ static void outstream_write(struct hpi_adapter_obj *pao,
        }
        space_available = outstream_get_space_available(status);
-        if (space_available < (long)phm->u.d.u.data.data_size) {
+        if (space_available < phm->u.d.u.data.data_size) {
                phr->error = HPI_ERROR_INVALID_DATASIZE;
                return;
        }
@@ -1018,7 +1018,7 @@ static void outstream_write(struct hpi_adapter_obj *pao,
                && hpios_locked_mem_valid(&phw->outstream_host_buffers[phm->
                                obj_index])) {
                u8 *p_bbm_data;
-                long l_first_write;
+                u32 l_first_write;
                u8 *p_app_data = (u8 *)phm->u.d.u.data.pb_data;
                if (hpios_locked_mem_get_virt_addr(&phw->
@@ -1248,9 +1248,9 @@ static void instream_start(struct hpi_adapter_obj *pao,
        hw_message(pao, phm, phr);
 }
-static long instream_get_bytes_available(struct hpi_hostbuffer_status *status)
+static u32 instream_get_bytes_available(struct hpi_hostbuffer_status *status)
 {
-        return (long)(status->dSP_index) - (long)(status->host_index);
+        return status->dSP_index - status->host_index;
 }
 static void instream_read(struct hpi_adapter_obj *pao,
@@ -1259,9 +1259,9 @@ static void instream_read(struct hpi_adapter_obj *pao,
        struct hpi_hw_obj *phw = pao->priv;
        struct bus_master_interface *interface = phw->p_interface_buffer;
        struct hpi_hostbuffer_status *status;
-        long data_available;
+        u32 data_available;
        u8 *p_bbm_data;
-        long l_first_read;
+        u32 l_first_read;
        u8 *p_app_data = (u8 *)phm->u.d.u.data.pb_data;
        if (!phw->instream_host_buffer_size[phm->obj_index]) {
@@ -1272,7 +1272,7 @@ static void instream_read(struct hpi_adapter_obj *pao,
        status = &interface->instream_host_buffer_status[phm->obj_index];
        data_available = instream_get_bytes_available(status);
-        if (data_available < (long)phm->u.d.u.data.data_size) {
+        if (data_available < phm->u.d.u.data.data_size) {
                phr->error = HPI_ERROR_INVALID_DATASIZE;
                return;
        }
diff --git a/sound/pci/asihpi/hpi_internal.h b/sound/pci/asihpi/hpi_internal.h
index fdd0ce02aa68..16f502d459de 100644
--- a/sound/pci/asihpi/hpi_internal.h
+++ b/sound/pci/asihpi/hpi_internal.h
@@ -104,9 +104,9 @@ typedef void hpi_handler_func(struct hpi_message *, struct hpi_response *);
 #define STR_ROLE_FIELD_MAX 255U
 struct hpi_entity_str {
-        uint16_t size;
+        u16 size;
-        uint8_t type;
+        u8 type;
-        uint8_t role;
+        u8 role;
 };
 #if defined(_MSC_VER)
@@ -119,11 +119,11 @@ struct hpi_entity {
 #if ! defined(HPI_OS_DSP_C6000) || (defined(HPI_OS_DSP_C6000) && (__TI_COMPILER_VERSION__ > 6000008))
        /* DSP C6000 compiler v6.0.8 and lower
           do not support  flexible array member */
-        uint8_t value[];
+        u8 value[];
 #else
        /* NOTE! Using sizeof(struct hpi_entity) will give erroneous results */
 #define HPI_INTERNAL_WARN_ABOUT_ENTITY_VALUE
-        uint8_t value[1];
+        u8 value[1];
 #endif
 };
@@ -142,12 +142,15 @@ enum HPI_BUSES {
 /******************************************* CONTROL ATTRIBUTES ****/
 /* (in order of control type ID */
-        /* This allows for 255 control types, 256 unique attributes each */
+/* This allows for 255 control types, 256 unique attributes each */
 #define HPI_CTL_ATTR(ctl, ai) (HPI_CONTROL_##ctl * 0x100 + ai)
 /* Get the sub-index of the attribute for a control type */
 #define HPI_CTL_ATTR_INDEX(i) (i&0xff)
+/* Extract the control from the control attribute */
+#define HPI_CTL_ATTR_CONTROL(i) (i>>8)
 /* Generic control attributes.  */
 /** Enable a control.
@@ -311,8 +314,7 @@ Used for HPI_ChannelModeSet/Get()
 /* Microphone control attributes */
 #define HPI_MICROPHONE_PHANTOM_POWER HPI_CTL_ATTR(MICROPHONE, 1)
-/** Equalizer control attributes
+/** Equalizer control attributes */
-*/
 /** Used to get number of filters in an EQ. (Can't set) */
 #define HPI_EQUALIZER_NUM_FILTERS HPI_CTL_ATTR(EQUALIZER, 1)
 /** Set/get the filter by type, freq, Q, gain */
@@ -320,13 +322,15 @@ Used for HPI_ChannelModeSet/Get()
 /** Get the biquad coefficients */
 #define HPI_EQUALIZER_COEFFICIENTS HPI_CTL_ATTR(EQUALIZER, 3)
-#define HPI_COMPANDER_PARAMS HPI_CTL_ATTR(COMPANDER, 1)
+/* Note compander also uses HPI_GENERIC_ENABLE */
+#define HPI_COMPANDER_PARAMS     HPI_CTL_ATTR(COMPANDER, 1)
+#define HPI_COMPANDER_MAKEUPGAIN HPI_CTL_ATTR(COMPANDER, 2)
+#define HPI_COMPANDER_THRESHOLD  HPI_CTL_ATTR(COMPANDER, 3)
+#define HPI_COMPANDER_RATIO      HPI_CTL_ATTR(COMPANDER, 4)
+#define HPI_COMPANDER_ATTACK     HPI_CTL_ATTR(COMPANDER, 5)
+#define HPI_COMPANDER_DECAY      HPI_CTL_ATTR(COMPANDER, 6)
-/* Cobranet control attributes.
+/* Cobranet control attributes. */
-   MUST be distinct from all other control attributes.
-   This is so that host side processing can easily identify a Cobranet control
-   and apply additional host side operations (like copying data) as required.
-*/
 #define HPI_COBRANET_SET         HPI_CTL_ATTR(COBRANET, 1)
 #define HPI_COBRANET_GET         HPI_CTL_ATTR(COBRANET, 2)
 #define HPI_COBRANET_SET_DATA    HPI_CTL_ATTR(COBRANET, 3)
@@ -1512,11 +1516,11 @@ struct hpi_control_cache_single {
        struct hpi_control_cache_info i;
        union {
                struct {        /* volume */
-                        u16 an_log[2];
+                        short an_log[2];
                } v;
                struct {        /* peak meter */
-                        u16 an_log_peak[2];
+                        short an_log_peak[2];
-                        u16 an_logRMS[2];
+                        short an_logRMS[2];
                } p;
                struct {        /* channel mode */
                        u16 mode;
@@ -1526,7 +1530,7 @@ struct hpi_control_cache_single {
                        u16 source_node_index;
                } x;
                struct {        /* level/trim */
-                        u16 an_log[2];
+                        short an_log[2];
                } l;
                struct {        /* tuner - partial caching.
                                   some attributes go to the DSP. */
diff --git a/sound/pci/asihpi/hpicmn.c b/sound/pci/asihpi/hpicmn.c
index fcd64539d9ef..dda4f1c6f658 100644
--- a/sound/pci/asihpi/hpicmn.c
+++ b/sound/pci/asihpi/hpicmn.c
@@ -353,7 +353,12 @@ short hpi_check_control_cache(struct hpi_control_cache *p_cache,
                        phr->u.c.param1 = pC->u.t.band;
                else if ((phm->u.c.attribute == HPI_TUNER_LEVEL)
                        && (phm->u.c.param1 == HPI_TUNER_LEVEL_AVERAGE))
-                        phr->u.c.param1 = pC->u.t.level;
+                        if (pC->u.t.level == HPI_ERROR_ILLEGAL_CACHE_VALUE) {
+                                phr->u.c.param1 = 0;
+                                phr->error =
+                                        HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
+                        } else
+                                phr->u.c.param1 = pC->u.t.level;
                else
                        found = 0;
                break;
@@ -397,7 +402,8 @@ short hpi_check_control_cache(struct hpi_control_cache *p_cache,
                        if (pC->u.clk.source_index ==
                                HPI_ERROR_ILLEGAL_CACHE_VALUE) {
                                phr->u.c.param1 = 0;
-                                phr->error = HPI_ERROR_INVALID_OPERATION;
+                                phr->error =
+                                        HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
                        } else
                                phr->u.c.param1 = pC->u.clk.source_index;
                } else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SAMPLERATE)
diff --git a/sound/pci/asihpi/hpidebug.c b/sound/pci/asihpi/hpidebug.c
index 4cd85a401b34..949836ec913a 100644
--- a/sound/pci/asihpi/hpidebug.c
+++ b/sound/pci/asihpi/hpidebug.c
@@ -111,7 +111,7 @@ make_treenode_from_array(hpi_control_type_strings, HPI_CONTROL_TYPE_STRINGS)
  &hpi_profile_strings,\
  &hpi_control_strings, \
  &hpi_asyncevent_strings \
-};
+}
        make_treenode_from_array(hpi_function_strings, HPI_FUNCTION_STRINGS)
        compile_time_assert(HPI_OBJ_MAXINDEX == 14, obj_list_doesnt_match);
diff --git a/sound/pci/asihpi/hpidebug.h b/sound/pci/asihpi/hpidebug.h
index 44dccadcc25b..a2f0952a99f0 100644
--- a/sound/pci/asihpi/hpidebug.h
+++ b/sound/pci/asihpi/hpidebug.h
@@ -356,7 +356,7 @@ compile_time_assert((HPI_CONTROL_LAST_INDEX + 1 == 27),
        "HPI_SOURCENODE_ADAPTER" \
 }
-compile_time_assert((HPI_SOURCENODE_LAST_INDEX - HPI_SOURCENODE_BASE + 1) ==
+compile_time_assert((HPI_SOURCENODE_LAST_INDEX - HPI_SOURCENODE_NONE + 1) ==
        (12), sourcenode_strings_match_defs);
 #define HPI_DESTNODE_STRINGS \
@@ -370,7 +370,7 @@ compile_time_assert((HPI_SOURCENODE_LAST_INDEX - HPI_SOURCENODE_BASE + 1) ==
        "HPI_DESTNODE_COBRANET", \
        "HPI_DESTNODE_ANALOG" \
 }
-compile_time_assert((HPI_DESTNODE_LAST_INDEX - HPI_DESTNODE_BASE + 1) == (8),
+compile_time_assert((HPI_DESTNODE_LAST_INDEX - HPI_DESTNODE_NONE + 1) == (8),
        destnode_strings_match_defs);
 #define HPI_CONTROL_CHANNEL_MODE_STRINGS \
diff --git a/sound/pci/asihpi/hpifunc.c b/sound/pci/asihpi/hpifunc.c
index 298eef3e20e9..1e92eb6dd509 100644
--- a/sound/pci/asihpi/hpifunc.c
+++ b/sound/pci/asihpi/hpifunc.c
@@ -96,8 +96,7 @@ void hpi_stream_response_to_legacy(struct hpi_stream_res *pSR)
 static struct hpi_hsubsys gh_subsys;
-struct hpi_hsubsys *hpi_subsys_create(void
+struct hpi_hsubsys *hpi_subsys_create(void)
-        )
 {
        struct hpi_message hm;
        struct hpi_response hr;
@@ -302,6 +301,7 @@ u16 hpi_adapter_set_mode_ex(const struct hpi_hsubsys *ph_subsys,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
                HPI_ADAPTER_SET_MODE);
        hm.adapter_index = adapter_index;
@@ -510,7 +510,7 @@ u16 hpi_adapter_debug_read(const struct hpi_hsubsys *ph_subsys,
        hm.adapter_index = adapter_index;
        hm.u.ax.debug_read.dsp_address = dsp_address;
-        if (*count_bytes > sizeof(hr.u.bytes))
+        if (*count_bytes > (int)sizeof(hr.u.bytes))
                *count_bytes = sizeof(hr.u.bytes);
        hm.u.ax.debug_read.count_bytes = *count_bytes;
@@ -976,6 +976,7 @@ u16 hpi_outstream_ancillary_read(const struct hpi_hsubsys *ph_subsys,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
                HPI_OSTREAM_ANC_READ);
        u32TOINDEXES(h_outstream, &hm.adapter_index, &hm.obj_index);
@@ -1581,6 +1582,7 @@ u16 hpi_control_param_set(const struct hpi_hsubsys *ph_subsys,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_SET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -1591,6 +1593,22 @@ u16 hpi_control_param_set(const struct hpi_hsubsys *ph_subsys,
        return hr.error;
 }
+static u16 hpi_control_log_set2(u32 h_control, u16 attrib, short sv0,
+        short sv1)
+{
+        struct hpi_message hm;
+        struct hpi_response hr;
+        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
+                HPI_CONTROL_SET_STATE);
+        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
+        hm.u.c.attribute = attrib;
+        hm.u.c.an_log_value[0] = sv0;
+        hm.u.c.an_log_value[1] = sv1;
+        hpi_send_recv(&hm, &hr);
+        return hr.error;
+}
 static
 u16 hpi_control_param_get(const struct hpi_hsubsys *ph_subsys,
        const u32 h_control, const u16 attrib, u32 param1, u32 param2,
@@ -1598,6 +1616,7 @@ u16 hpi_control_param_get(const struct hpi_hsubsys *ph_subsys,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_GET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -1605,8 +1624,8 @@ u16 hpi_control_param_get(const struct hpi_hsubsys *ph_subsys,
        hm.u.c.param1 = param1;
        hm.u.c.param2 = param2;
        hpi_send_recv(&hm, &hr);
-        if (pparam1)
-                *pparam1 = hr.u.c.param1;
+        *pparam1 = hr.u.c.param1;
        if (pparam2)
                *pparam2 = hr.u.c.param2;
@@ -1617,10 +1636,23 @@ u16 hpi_control_param_get(const struct hpi_hsubsys *ph_subsys,
                hpi_control_param_get(s, h, a, 0, 0, p1, NULL)
 #define hpi_control_param2_get(s, h, a, p1, p2) \
                hpi_control_param_get(s, h, a, 0, 0, p1, p2)
-#define hpi_control_ex_param1_get(s, h, a, p1) \
-                hpi_control_ex_param_get(s, h, a, 0, 0, p1, NULL)
+static u16 hpi_control_log_get2(const struct hpi_hsubsys *ph_subsys,
-#define hpi_control_ex_param2_get(s, h, a, p1, p2) \
+        u32 h_control, u16 attrib, short *sv0, short *sv1)
-                hpi_control_ex_param_get(s, h, a, 0, 0, p1, p2)
+{
+        struct hpi_message hm;
+        struct hpi_response hr;
+        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
+                HPI_CONTROL_GET_STATE);
+        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
+        hm.u.c.attribute = attrib;
+        hpi_send_recv(&hm, &hr);
+        *sv0 = hr.u.c.an_log_value[0];
+        if (sv1)
+                *sv1 = hr.u.c.an_log_value[1];
+        return hr.error;
+}
 static
 u16 hpi_control_query(const struct hpi_hsubsys *ph_subsys,
@@ -1629,6 +1661,7 @@ u16 hpi_control_query(const struct hpi_hsubsys *ph_subsys,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_GET_INFO);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -1643,9 +1676,8 @@ u16 hpi_control_query(const struct hpi_hsubsys *ph_subsys,
        return hr.error;
 }
-static u16 hpi_control_get_string(const struct hpi_hsubsys *ph_subsys,
+static u16 hpi_control_get_string(const u32 h_control, const u16 attribute,
-        const u32 h_control, const u16 attribute, char *psz_string,
+        char *psz_string, const u32 string_length)
-        const u32 string_length)
 {
        unsigned int sub_string_index = 0, j = 0;
        char c = 0;
@@ -1916,6 +1948,7 @@ u16 hpi_cobranet_hmi_write(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROLEX,
                HPI_CONTROL_SET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -1941,6 +1974,7 @@ u16 hpi_cobranet_hmi_read(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROLEX,
                HPI_CONTROL_GET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -1980,6 +2014,7 @@ u16 hpi_cobranet_hmi_get_status(const struct hpi_hsubsys *ph_subsys,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROLEX,
                HPI_CONTROL_GET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2006,6 +2041,7 @@ u16 hpi_cobranet_getI_paddress(const struct hpi_hsubsys *ph_subsys,
        u32 byte_count;
        u32 iP;
        u16 error;
        error = hpi_cobranet_hmi_read(ph_subsys, h_control,
                HPI_COBRANET_HMI_cobra_ip_mon_currentIP, 4, &byte_count,
                (u8 *)&iP);
@@ -2082,6 +2118,7 @@ u16 hpi_cobranet_getMA_caddress(const struct hpi_hsubsys *ph_subsys,
        u32 byte_count;
        u16 error;
        u32 mAC;
        error = hpi_cobranet_hmi_read(ph_subsys, h_control,
                HPI_COBRANET_HMI_cobra_if_phy_address, 4, &byte_count,
                (u8 *)&mAC);
@@ -2103,53 +2140,111 @@ u16 hpi_cobranet_getMA_caddress(const struct hpi_hsubsys *ph_subsys,
        return error;
 }
-u16 hpi_compander_set(const struct hpi_hsubsys *ph_subsys, u32 h_control,
+u16 hpi_compander_set_enable(const struct hpi_hsubsys *ph_subsys,
-        u16 attack, u16 decay, short ratio100, short threshold0_01dB,
+        u32 h_control, u32 enable)
-        short makeup_gain0_01dB)
+{
+        return hpi_control_param_set(ph_subsys, h_control, HPI_GENERIC_ENABLE,
+                enable, 0);
+}
+u16 hpi_compander_get_enable(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 *enable)
+{
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_GENERIC_ENABLE, enable);
+}
+u16 hpi_compander_set_makeup_gain(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, short makeup_gain0_01dB)
+{
+        return hpi_control_log_set2(h_control, HPI_COMPANDER_MAKEUPGAIN,
+                makeup_gain0_01dB, 0);
+}
+u16 hpi_compander_get_makeup_gain(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, short *makeup_gain0_01dB)
+{
+        return hpi_control_log_get2(ph_subsys, h_control,
+                HPI_COMPANDER_MAKEUPGAIN, makeup_gain0_01dB, NULL);
+}
+u16 hpi_compander_set_attack_time_constant(const struct hpi_hsubsys
+        *ph_subsys, u32 h_control, unsigned int index, u32 attack)
+{
+        return hpi_control_param_set(ph_subsys, h_control,
+                HPI_COMPANDER_ATTACK, attack, index);
+}
+u16 hpi_compander_get_attack_time_constant(const struct hpi_hsubsys
+        *ph_subsys, u32 h_control, unsigned int index, u32 *attack)
+{
+        return hpi_control_param_get(ph_subsys, h_control,
+                HPI_COMPANDER_ATTACK, 0, index, attack, NULL);
+}
+u16 hpi_compander_set_decay_time_constant(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, unsigned int index, u32 decay)
+{
+        return hpi_control_param_set(ph_subsys, h_control,
+                HPI_COMPANDER_DECAY, decay, index);
+}
+u16 hpi_compander_get_decay_time_constant(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, unsigned int index, u32 *decay)
+{
+        return hpi_control_param_get(ph_subsys, h_control,
+                HPI_COMPANDER_DECAY, 0, index, decay, NULL);
+}
+u16 hpi_compander_set_threshold(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, unsigned int index, short threshold0_01dB)
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_SET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
+        hm.u.c.attribute = HPI_COMPANDER_THRESHOLD;
-        hm.u.c.param1 = attack + ((u32)ratio100 << 16);
+        hm.u.c.param2 = index;
-        hm.u.c.param2 = (decay & 0xFFFFL);
        hm.u.c.an_log_value[0] = threshold0_01dB;
-        hm.u.c.an_log_value[1] = makeup_gain0_01dB;
-        hm.u.c.attribute = HPI_COMPANDER_PARAMS;
        hpi_send_recv(&hm, &hr);
        return hr.error;
 }
-u16 hpi_compander_get(const struct hpi_hsubsys *ph_subsys, u32 h_control,
+u16 hpi_compander_get_threshold(const struct hpi_hsubsys *ph_subsys,
-        u16 *pw_attack, u16 *pw_decay, short *pw_ratio100,
+        u32 h_control, unsigned int index, short *threshold0_01dB)
-        short *pn_threshold0_01dB, short *pn_makeup_gain0_01dB)
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_GET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
-        hm.u.c.attribute = HPI_COMPANDER_PARAMS;
+        hm.u.c.attribute = HPI_COMPANDER_THRESHOLD;
+        hm.u.c.param2 = index;
        hpi_send_recv(&hm, &hr);
+        *threshold0_01dB = hr.u.c.an_log_value[0];
-        if (pw_attack)
+        return hr.error;
-                *pw_attack = (short)(hr.u.c.param1 & 0xFFFF);
+}
-        if (pw_decay)
-                *pw_decay = (short)(hr.u.c.param2 & 0xFFFF);
-        if (pw_ratio100)
-                *pw_ratio100 = (short)(hr.u.c.param1 >> 16);
-        if (pn_threshold0_01dB)
+u16 hpi_compander_set_ratio(const struct hpi_hsubsys *ph_subsys,
-                *pn_threshold0_01dB = hr.u.c.an_log_value[0];
+        u32 h_control, u32 index, u32 ratio100)
-        if (pn_makeup_gain0_01dB)
+{
-                *pn_makeup_gain0_01dB = hr.u.c.an_log_value[1];
+        return hpi_control_param_set(ph_subsys, h_control,
+                HPI_COMPANDER_RATIO, ratio100, index);
+}
-        return hr.error;
+u16 hpi_compander_get_ratio(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, u32 *ratio100)
+{
+        return hpi_control_param_get(ph_subsys, h_control,
+                HPI_COMPANDER_RATIO, 0, index, ratio100, NULL);
 }
 u16 hpi_level_query_range(const struct hpi_hsubsys *ph_subsys, u32 h_control,
@@ -2157,6 +2252,7 @@ u16 hpi_level_query_range(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_GET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2181,37 +2277,16 @@ u16 hpi_level_set_gain(const struct hpi_hsubsys *ph_subsys, u32 h_control,
        short an_gain0_01dB[HPI_MAX_CHANNELS]
        )
 {
-        struct hpi_message hm;
+        return hpi_control_log_set2(h_control, HPI_LEVEL_GAIN,
-        struct hpi_response hr;
+                an_gain0_01dB[0], an_gain0_01dB[1]);
-        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
-                HPI_CONTROL_SET_STATE);
-        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
-        memcpy(hm.u.c.an_log_value, an_gain0_01dB,
-                sizeof(short) * HPI_MAX_CHANNELS);
-        hm.u.c.attribute = HPI_LEVEL_GAIN;
-        hpi_send_recv(&hm, &hr);
-        return hr.error;
 }
 u16 hpi_level_get_gain(const struct hpi_hsubsys *ph_subsys, u32 h_control,
        short an_gain0_01dB[HPI_MAX_CHANNELS]
        )
 {
-        struct hpi_message hm;
+        return hpi_control_log_get2(ph_subsys, h_control, HPI_LEVEL_GAIN,
-        struct hpi_response hr;
+                &an_gain0_01dB[0], &an_gain0_01dB[1]);
-        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
-                HPI_CONTROL_GET_STATE);
-        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
-        hm.u.c.attribute = HPI_LEVEL_GAIN;
-        hpi_send_recv(&hm, &hr);
-        memcpy(an_gain0_01dB, hr.u.c.an_log_value,
-                sizeof(short) * HPI_MAX_CHANNELS);
-        return hr.error;
 }
 u16 hpi_meter_query_channels(const struct hpi_hsubsys *ph_subsys,
@@ -2413,6 +2488,7 @@ u16 hpi_parametricEQ__get_band(const struct hpi_hsubsys *ph_subsys,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_GET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2439,6 +2515,7 @@ u16 hpi_parametricEQ__set_band(const struct hpi_hsubsys *ph_subsys,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_SET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2460,6 +2537,7 @@ u16 hpi_parametricEQ__get_coeffs(const struct hpi_hsubsys *ph_subsys,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_GET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2623,8 +2701,8 @@ u16 hpi_tone_detector_get_frequency(const struct hpi_hsubsys *ph_subsys,
 u16 hpi_tone_detector_get_state(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 *state)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                HPI_TONEDETECTOR_STATE, 0, 0, (u32 *)state, NULL);
+                HPI_TONEDETECTOR_STATE, state);
 }
 u16 hpi_tone_detector_set_enable(const struct hpi_hsubsys *ph_subsys,
@@ -2637,8 +2715,8 @@ u16 hpi_tone_detector_set_enable(const struct hpi_hsubsys *ph_subsys,
 u16 hpi_tone_detector_get_enable(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 *enable)
 {
-        return hpi_control_param_get(ph_subsys, h_control, HPI_GENERIC_ENABLE,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                0, 0, (u32 *)enable, NULL);
+                HPI_GENERIC_ENABLE, enable);
 }
 u16 hpi_tone_detector_set_event_enable(const struct hpi_hsubsys *ph_subsys,
@@ -2651,8 +2729,8 @@ u16 hpi_tone_detector_set_event_enable(const struct hpi_hsubsys *ph_subsys,
 u16 hpi_tone_detector_get_event_enable(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 *event_enable)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                HPI_GENERIC_EVENT_ENABLE, 0, 0, (u32 *)event_enable, NULL);
+                HPI_GENERIC_EVENT_ENABLE, event_enable);
 }
 u16 hpi_tone_detector_set_threshold(const struct hpi_hsubsys *ph_subsys,
@@ -2665,15 +2743,15 @@ u16 hpi_tone_detector_set_threshold(const struct hpi_hsubsys *ph_subsys,
 u16 hpi_tone_detector_get_threshold(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, int *threshold)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                HPI_TONEDETECTOR_THRESHOLD, 0, 0, (u32 *)threshold, NULL);
+                HPI_TONEDETECTOR_THRESHOLD, (u32 *)threshold);
 }
 u16 hpi_silence_detector_get_state(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 *state)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                HPI_SILENCEDETECTOR_STATE, 0, 0, (u32 *)state, NULL);
+                HPI_SILENCEDETECTOR_STATE, state);
 }
 u16 hpi_silence_detector_set_enable(const struct hpi_hsubsys *ph_subsys,
@@ -2686,50 +2764,50 @@ u16 hpi_silence_detector_set_enable(const struct hpi_hsubsys *ph_subsys,
 u16 hpi_silence_detector_get_enable(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 *enable)
 {
-        return hpi_control_param_get(ph_subsys, h_control, HPI_GENERIC_ENABLE,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                0, 0, (u32 *)enable, NULL);
+                HPI_GENERIC_ENABLE, enable);
 }
 u16 hpi_silence_detector_set_event_enable(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 event_enable)
 {
        return hpi_control_param_set(ph_subsys, h_control,
-                HPI_GENERIC_EVENT_ENABLE, (u32)event_enable, 0);
+                HPI_GENERIC_EVENT_ENABLE, event_enable, 0);
 }
 u16 hpi_silence_detector_get_event_enable(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 *event_enable)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                HPI_GENERIC_EVENT_ENABLE, 0, 0, (u32 *)event_enable, NULL);
+                HPI_GENERIC_EVENT_ENABLE, event_enable);
 }
 u16 hpi_silence_detector_set_delay(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 delay)
 {
        return hpi_control_param_set(ph_subsys, h_control,
-                HPI_SILENCEDETECTOR_DELAY, (u32)delay, 0);
+                HPI_SILENCEDETECTOR_DELAY, delay, 0);
 }
 u16 hpi_silence_detector_get_delay(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 *delay)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                HPI_SILENCEDETECTOR_DELAY, 0, 0, (u32 *)delay, NULL);
+                HPI_SILENCEDETECTOR_DELAY, delay);
 }
 u16 hpi_silence_detector_set_threshold(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, int threshold)
 {
        return hpi_control_param_set(ph_subsys, h_control,
-                HPI_SILENCEDETECTOR_THRESHOLD, (u32)threshold, 0);
+                HPI_SILENCEDETECTOR_THRESHOLD, threshold, 0);
 }
 u16 hpi_silence_detector_get_threshold(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, int *threshold)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                HPI_SILENCEDETECTOR_THRESHOLD, 0, 0, (u32 *)threshold, NULL);
+                HPI_SILENCEDETECTOR_THRESHOLD, (u32 *)threshold);
 }
 u16 hpi_tuner_query_band(const struct hpi_hsubsys *ph_subsys,
@@ -2822,6 +2900,7 @@ u16 hpi_tuner_getRF_level(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_GET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2838,6 +2917,7 @@ u16 hpi_tuner_get_rawRF_level(const struct hpi_hsubsys *ph_subsys,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_GET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2894,14 +2974,14 @@ u16 hpi_tuner_get_program(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 u16 hpi_tuner_get_hd_radio_dsp_version(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, char *psz_dsp_version, const u32 string_size)
 {
-        return hpi_control_get_string(ph_subsys, h_control,
+        return hpi_control_get_string(h_control,
                HPI_TUNER_HDRADIO_DSP_VERSION, psz_dsp_version, string_size);
 }
 u16 hpi_tuner_get_hd_radio_sdk_version(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, char *psz_sdk_version, const u32 string_size)
 {
-        return hpi_control_get_string(ph_subsys, h_control,
+        return hpi_control_get_string(h_control,
                HPI_TUNER_HDRADIO_SDK_VERSION, psz_sdk_version, string_size);
 }
@@ -2942,15 +3022,15 @@ u16 hpi_tuner_get_mode(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 u16 hpi_tuner_get_hd_radio_signal_quality(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 *pquality)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                HPI_TUNER_HDRADIO_SIGNAL_QUALITY, 0, 0, pquality, NULL);
+                HPI_TUNER_HDRADIO_SIGNAL_QUALITY, pquality);
 }
 u16 hpi_tuner_get_hd_radio_signal_blend(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 *pblend)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                HPI_TUNER_HDRADIO_BLEND, 0, 0, pblend, NULL);
+                HPI_TUNER_HDRADIO_BLEND, pblend);
 }
 u16 hpi_tuner_set_hd_radio_signal_blend(const struct hpi_hsubsys *ph_subsys,
@@ -2965,6 +3045,7 @@ u16 hpi_tuner_getRDS(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_GET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2981,43 +3062,43 @@ u16 hpi_tuner_getRDS(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 u16 HPI_PAD__get_channel_name(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, char *psz_string, const u32 data_length)
 {
-        return hpi_control_get_string(ph_subsys, h_control,
+        return hpi_control_get_string(h_control, HPI_PAD_CHANNEL_NAME,
-                HPI_PAD_CHANNEL_NAME, psz_string, data_length);
+                psz_string, data_length);
 }
 u16 HPI_PAD__get_artist(const struct hpi_hsubsys *ph_subsys, u32 h_control,
        char *psz_string, const u32 data_length)
 {
-        return hpi_control_get_string(ph_subsys, h_control, HPI_PAD_ARTIST,
+        return hpi_control_get_string(h_control, HPI_PAD_ARTIST, psz_string,
-                psz_string, data_length);
+                data_length);
 }
 u16 HPI_PAD__get_title(const struct hpi_hsubsys *ph_subsys, u32 h_control,
        char *psz_string, const u32 data_length)
 {
-        return hpi_control_get_string(ph_subsys, h_control, HPI_PAD_TITLE,
+        return hpi_control_get_string(h_control, HPI_PAD_TITLE, psz_string,
-                psz_string, data_length);
+                data_length);
 }
 u16 HPI_PAD__get_comment(const struct hpi_hsubsys *ph_subsys, u32 h_control,
        char *psz_string, const u32 data_length)
 {
-        return hpi_control_get_string(ph_subsys, h_control, HPI_PAD_COMMENT,
+        return hpi_control_get_string(h_control, HPI_PAD_COMMENT, psz_string,
-                psz_string, data_length);
+                data_length);
 }
 u16 HPI_PAD__get_program_type(const struct hpi_hsubsys *ph_subsys,
        u32 h_control, u32 *ppTY)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                HPI_PAD_PROGRAM_TYPE, 0, 0, ppTY, NULL);
+                HPI_PAD_PROGRAM_TYPE, ppTY);
 }
 u16 HPI_PAD__get_rdsPI(const struct hpi_hsubsys *ph_subsys, u32 h_control,
        u32 *ppI)
 {
-        return hpi_control_param_get(ph_subsys, h_control, HPI_PAD_PROGRAM_ID,
+        return hpi_control_param1_get(ph_subsys, h_control,
-                0, 0, ppI, NULL);
+                HPI_PAD_PROGRAM_ID, ppI);
 }
 u16 hpi_volume_query_channels(const struct hpi_hsubsys *ph_subsys,
@@ -3031,36 +3112,16 @@ u16 hpi_volume_set_gain(const struct hpi_hsubsys *ph_subsys, u32 h_control,
        short an_log_gain[HPI_MAX_CHANNELS]
        )
 {
-        struct hpi_message hm;
+        return hpi_control_log_set2(h_control, HPI_VOLUME_GAIN,
-        struct hpi_response hr;
+                an_log_gain[0], an_log_gain[1]);
-        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
-                HPI_CONTROL_SET_STATE);
-        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
-        memcpy(hm.u.c.an_log_value, an_log_gain,
-                sizeof(short) * HPI_MAX_CHANNELS);
-        hm.u.c.attribute = HPI_VOLUME_GAIN;
-        hpi_send_recv(&hm, &hr);
-        return hr.error;
 }
 u16 hpi_volume_get_gain(const struct hpi_hsubsys *ph_subsys, u32 h_control,
        short an_log_gain[HPI_MAX_CHANNELS]
        )
 {
-        struct hpi_message hm;
+        return hpi_control_log_get2(ph_subsys, h_control, HPI_VOLUME_GAIN,
-        struct hpi_response hr;
+                &an_log_gain[0], &an_log_gain[1]);
-        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
-                HPI_CONTROL_GET_STATE);
-        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
-        hm.u.c.attribute = HPI_VOLUME_GAIN;
-        hpi_send_recv(&hm, &hr);
-        memcpy(an_log_gain, hr.u.c.an_log_value,
-                sizeof(short) * HPI_MAX_CHANNELS);
-        return hr.error;
 }
 u16 hpi_volume_query_range(const struct hpi_hsubsys *ph_subsys, u32 h_control,
@@ -3068,6 +3129,7 @@ u16 hpi_volume_query_range(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_GET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -3094,6 +3156,7 @@ u16 hpi_volume_auto_fade_profile(const struct hpi_hsubsys *ph_subsys,
 {
        struct hpi_message hm;
        struct hpi_response hr;
        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                HPI_CONTROL_SET_STATE);
        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -3170,43 +3233,42 @@ static size_t entity_type_to_size[LAST_ENTITY_TYPE] = {
        6 * sizeof(char),
 };
-inline size_t hpi_entity_size(struct hpi_entity *entity_ptr)
+static inline size_t hpi_entity_size(struct hpi_entity *entity_ptr)
 {
        return entity_ptr->header.size;
 }
-inline size_t hpi_entity_header_size(struct hpi_entity *entity_ptr)
+static inline size_t hpi_entity_header_size(struct hpi_entity *entity_ptr)
 {
        return sizeof(entity_ptr->header);
 }
-inline size_t hpi_entity_value_size(struct hpi_entity *entity_ptr)
+static inline size_t hpi_entity_value_size(struct hpi_entity *entity_ptr)
 {
        return hpi_entity_size(entity_ptr) -
                hpi_entity_header_size(entity_ptr);
 }
-inline size_t hpi_entity_item_count(struct hpi_entity *entity_ptr)
+static inline size_t hpi_entity_item_count(struct hpi_entity *entity_ptr)
 {
        return hpi_entity_value_size(entity_ptr) /
                entity_type_to_size[entity_ptr->header.type];
 }
-inline struct hpi_entity *hpi_entity_ptr_to_next(struct hpi_entity
+static inline struct hpi_entity *hpi_entity_ptr_to_next(struct hpi_entity
        *entity_ptr)
 {
-        return (void *)(((uint8_t *) entity_ptr) +
+        return (void *)(((u8 *)entity_ptr) + hpi_entity_size(entity_ptr));
-                hpi_entity_size(entity_ptr));
 }
-inline u16 hpi_entity_check_type(const enum e_entity_type t)
+static inline u16 hpi_entity_check_type(const enum e_entity_type t)
 {
        if (t >= 0 && t < STR_TYPE_FIELD_MAX)
                return 0;
        return HPI_ERROR_ENTITY_TYPE_INVALID;
 }
-inline u16 hpi_entity_check_role(const enum e_entity_role r)
+static inline u16 hpi_entity_check_role(const enum e_entity_role r)
 {
        if (r >= 0 && r < STR_ROLE_FIELD_MAX)
                return 0;
@@ -3624,6 +3686,7 @@ u16 hpi_async_event_wait(const struct hpi_hsubsys *ph_subsys, u32 h_async,
        u16 maximum_events, struct hpi_async_event *p_events,
        u16 *pw_number_returned)
 {
        return 0;
 }
diff --git a/sound/pci/asihpi/hpimsgx.c b/sound/pci/asihpi/hpimsgx.c
index 2ee90dc3d897..f01ab964f602 100644
--- a/sound/pci/asihpi/hpimsgx.c
+++ b/sound/pci/asihpi/hpimsgx.c
@@ -741,7 +741,7 @@ static void HPIMSGX__reset(u16 adapter_index)
                hpi_init_response(&hr, HPI_OBJ_SUBSYSTEM,
                        HPI_SUBSYS_FIND_ADAPTERS, 0);
                memcpy(&gRESP_HPI_SUBSYS_FIND_ADAPTERS, &hr,
-                        sizeof(&gRESP_HPI_SUBSYS_FIND_ADAPTERS));
+                        sizeof(gRESP_HPI_SUBSYS_FIND_ADAPTERS));
                for (adapter = 0; adapter < HPI_MAX_ADAPTERS; adapter++) {
diff --git a/sound/pci/asihpi/hpioctl.c b/sound/pci/asihpi/hpioctl.c
index 7396ac54e99f..62895a719fcb 100644
--- a/sound/pci/asihpi/hpioctl.c
+++ b/sound/pci/asihpi/hpioctl.c
@@ -121,11 +121,17 @@ long asihpi_hpi_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
        phpi_ioctl_data = (struct hpi_ioctl_linux __user *)arg;
        /* Read the message and response pointers from user space.  */
-        get_user(puhm, &phpi_ioctl_data->phm);
+        if (get_user(puhm, &phpi_ioctl_data->phm) ||
-        get_user(puhr, &phpi_ioctl_data->phr);
+            get_user(puhr, &phpi_ioctl_data->phr)) {
+                err = -EFAULT;
+                goto out;
+        }
        /* Now read the message size and data from user space.  */
-        get_user(hm->h.size, (u16 __user *)puhm);
+        if (get_user(hm->h.size, (u16 __user *)puhm)) {
+                err = -EFAULT;
+                goto out;
+        }
        if (hm->h.size > sizeof(*hm))
                hm->h.size = sizeof(*hm);
@@ -138,7 +144,10 @@ long asihpi_hpi_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                goto out;
        }
-        get_user(res_max_size, (u16 __user *)puhr);
+        if (get_user(res_max_size, (u16 __user *)puhr)) {
+                err = -EFAULT;
+                goto out;
+        }
        /* printk(KERN_INFO "user response size %d\n", res_max_size); */
        if (res_max_size < sizeof(struct hpi_response_header)) {
                HPI_DEBUG_LOG(WARNING, "small res size %d\n", res_max_size);
@@ -464,9 +473,7 @@ void __init asihpi_init(void)
        memset(adapters, 0, sizeof(adapters));
-        printk(KERN_INFO "ASIHPI driver %d.%02d.%02d\n",
+        printk(KERN_INFO "ASIHPI driver " HPI_VER_STRING "\n");
-                HPI_VER_MAJOR(HPI_VER), HPI_VER_MINOR(HPI_VER),
-                HPI_VER_RELEASE(HPI_VER));
        hpi_init_message_response(&hm, &hr, HPI_OBJ_SUBSYSTEM,
                HPI_SUBSYS_DRIVER_LOAD);
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index 668a5ec04499..20763dd03fa0 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -2250,6 +2250,8 @@ static int snd_echo_resume(struct pci_dev *pci)
        DE_INIT(("resume start\n"));
        pci_restore_state(pci);
        commpage_bak = kmalloc(sizeof(struct echoaudio), GFP_KERNEL);
+        if (commpage_bak == NULL)
+                return -ENOMEM;
        commpage = chip->comm_page;
        memcpy(commpage_bak, commpage, sizeof(struct comm_page));
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index a3d638c8c1fd..dd8fb86c842b 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -396,15 +396,18 @@ int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
                        }
                        for (n = prev_nid + 1; n <= val; n++) {
                                if (conns >= max_conns) {
-                                        snd_printk(KERN_ERR
+                                        snd_printk(KERN_ERR "hda_codec: "
-                                                   "Too many connections\n");
+                                                   "Too many connections %d for NID 0x%x\n",
+                                                   conns, nid);
                                        return -EINVAL;
                                }
                                conn_list[conns++] = n;
                        }
                } else {
                        if (conns >= max_conns) {
-                                snd_printk(KERN_ERR "Too many connections\n");
+                                snd_printk(KERN_ERR "hda_codec: "
+                                           "Too many connections %d for NID 0x%x\n",
+                                           conns, nid);
                                return -EINVAL;
                        }
                        conn_list[conns++] = val;
@@ -730,15 +733,17 @@ static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
        total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
        for (i = 0; i < total_nodes; i++, nid++) {
                function_id = snd_hda_param_read(codec, nid,
-                                                AC_PAR_FUNCTION_TYPE) & 0xff;
+                                                AC_PAR_FUNCTION_TYPE);
-                switch (function_id) {
+                switch (function_id & 0xff) {
                case AC_GRP_AUDIO_FUNCTION:
                        codec->afg = nid;
-                        codec->function_id = function_id;
+                        codec->afg_function_id = function_id & 0xff;
+                        codec->afg_unsol = (function_id >> 8) & 1;
                        break;
                case AC_GRP_MODEM_FUNCTION:
                        codec->mfg = nid;
-                        codec->function_id = function_id;
+                        codec->mfg_function_id = function_id & 0xff;
+                        codec->mfg_unsol = (function_id >> 8) & 1;
                        break;
                default:
                        break;
@@ -784,6 +789,9 @@ static int read_pin_defaults(struct hda_codec *codec)
                pin->nid = nid;
                pin->cfg = snd_hda_codec_read(codec, nid, 0,
                                              AC_VERB_GET_CONFIG_DEFAULT, 0);
+                pin->ctrl = snd_hda_codec_read(codec, nid, 0,
+                                               AC_VERB_GET_PIN_WIDGET_CONTROL,
+                                               0);
        }
        return 0;
 }
@@ -912,15 +920,38 @@ static void restore_pincfgs(struct hda_codec *codec)
 void snd_hda_shutup_pins(struct hda_codec *codec)
 {
        int i;
+        /* don't shut up pins when unloading the driver; otherwise it breaks
+         * the default pin setup at the next load of the driver
+         */
+        if (codec->bus->shutdown)
+                return;
        for (i = 0; i < codec->init_pins.used; i++) {
                struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
                /* use read here for syncing after issuing each verb */
                snd_hda_codec_read(codec, pin->nid, 0,
                                   AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
        }
+        codec->pins_shutup = 1;
 }
 EXPORT_SYMBOL_HDA(snd_hda_shutup_pins);
+/* Restore the pin controls cleared previously via snd_hda_shutup_pins() */
+static void restore_shutup_pins(struct hda_codec *codec)
+{
+        int i;
+        if (!codec->pins_shutup)
+                return;
+        if (codec->bus->shutdown)
+                return;
+        for (i = 0; i < codec->init_pins.used; i++) {
+                struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
+                snd_hda_codec_write(codec, pin->nid, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                    pin->ctrl);
+        }
+        codec->pins_shutup = 0;
+}
 static void init_hda_cache(struct hda_cache_rec *cache,
                           unsigned int record_size);
 static void free_hda_cache(struct hda_cache_rec *cache);
@@ -940,6 +971,36 @@ static void restore_init_pincfgs(struct hda_codec *codec)
 }
 /*
+ * audio-converter setup caches
+ */
+struct hda_cvt_setup {
+        hda_nid_t nid;
+        u8 stream_tag;
+        u8 channel_id;
+        u16 format_id;
+        unsigned char active;   /* cvt is currently used */
+        unsigned char dirty;    /* setups should be cleared */
+};
+/* get or create a cache entry for the given audio converter NID */
+static struct hda_cvt_setup *
+get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
+{
+        struct hda_cvt_setup *p;
+        int i;
+        for (i = 0; i < codec->cvt_setups.used; i++) {
+                p = snd_array_elem(&codec->cvt_setups, i);
+                if (p->nid == nid)
+                        return p;
+        }
+        p = snd_array_new(&codec->cvt_setups);
+        if (p)
+                p->nid = nid;
+        return p;
+}
+/*
 * codec destructor
 */
 static void snd_hda_codec_free(struct hda_codec *codec)
@@ -1007,12 +1068,14 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
        codec->addr = codec_addr;
        mutex_init(&codec->spdif_mutex);
        mutex_init(&codec->control_mutex);
+        mutex_init(&codec->prepare_mutex);
        init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info));
        init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head));
        snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32);
        snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
        snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
        snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
+        snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
        if (codec->bus->modelname) {
                codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
                if (!codec->modelname) {
@@ -1150,37 +1213,119 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
                                u32 stream_tag,
                                int channel_id, int format)
 {
+        struct hda_cvt_setup *p;
+        unsigned int oldval, newval;
+        int i;
        if (!nid)
                return;
        snd_printdd("hda_codec_setup_stream: "
                    "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
                    nid, stream_tag, channel_id, format);
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
+        p = get_hda_cvt_setup(codec, nid);
-                            (stream_tag << 4) | channel_id);
+        if (!p)
-        msleep(1);
+                return;
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
+        /* update the stream-id if changed */
+        if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
+                oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
+                newval = (stream_tag << 4) | channel_id;
+                if (oldval != newval)
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_CHANNEL_STREAMID,
+                                            newval);
+                p->stream_tag = stream_tag;
+                p->channel_id = channel_id;
+        }
+        /* update the format-id if changed */
+        if (p->format_id != format) {
+                oldval = snd_hda_codec_read(codec, nid, 0,
+                                            AC_VERB_GET_STREAM_FORMAT, 0);
+                if (oldval != format) {
+                        msleep(1);
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_STREAM_FORMAT,
+                                            format);
+                }
+                p->format_id = format;
+        }
+        p->active = 1;
+        p->dirty = 0;
+        /* make other inactive cvts with the same stream-tag dirty */
+        for (i = 0; i < codec->cvt_setups.used; i++) {
+                p = snd_array_elem(&codec->cvt_setups, i);
+                if (!p->active && p->stream_tag == stream_tag)
+                        p->dirty = 1;
+        }
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
+static void really_cleanup_stream(struct hda_codec *codec,
+                                  struct hda_cvt_setup *q);
 /**
- * snd_hda_codec_cleanup_stream - clean up the codec for closing
+ * __snd_hda_codec_cleanup_stream - clean up the codec for closing
 * @codec: the CODEC to clean up
 * @nid: the NID to clean up
+ * @do_now: really clean up the stream instead of clearing the active flag
 */
-void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
+void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
+                                    int do_now)
 {
+        struct hda_cvt_setup *p;
        if (!nid)
                return;
        snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
+        p = get_hda_cvt_setup(codec, nid);
+        if (p) {
+                /* here we just clear the active flag when do_now isn't set;
+                 * actual clean-ups will be done later in
+                 * purify_inactive_streams() called from snd_hda_codec_prpapre()
+                 */
+                if (do_now)
+                        really_cleanup_stream(codec, p);
+                else
+                        p->active = 0;
+        }
+}
+EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
+static void really_cleanup_stream(struct hda_codec *codec,
+                                  struct hda_cvt_setup *q)
+{
+        hda_nid_t nid = q->nid;
        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
-#if 0 /* keep the format */
-        msleep(1);
        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
-#endif
+        memset(q, 0, sizeof(*q));
+        q->nid = nid;
+}
+/* clean up the all conflicting obsolete streams */
+static void purify_inactive_streams(struct hda_codec *codec)
+{
+        int i;
+        for (i = 0; i < codec->cvt_setups.used; i++) {
+                struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
+                if (p->dirty)
+                        really_cleanup_stream(codec, p);
+        }
+}
+/* clean up all streams; called from suspend */
+static void hda_cleanup_all_streams(struct hda_codec *codec)
+{
+        int i;
+        for (i = 0; i < codec->cvt_setups.used; i++) {
+                struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
+                if (p->stream_tag)
+                        really_cleanup_stream(codec, p);
+        }
 }
-EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
 /*
 * amp access functions
@@ -1539,6 +1684,17 @@ void snd_hda_codec_resume_amp(struct hda_codec *codec)
 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
 #endif /* SND_HDA_NEEDS_RESUME */
+static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
+                             unsigned int ofs)
+{
+        u32 caps = query_amp_caps(codec, nid, dir);
+        /* get num steps */
+        caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
+        if (ofs < caps)
+                caps -= ofs;
+        return caps;
+}
 /**
 * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
 *
@@ -1553,23 +1709,17 @@ int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
        u8 chs = get_amp_channels(kcontrol);
        int dir = get_amp_direction(kcontrol);
        unsigned int ofs = get_amp_offset(kcontrol);
-        u32 caps;
-        caps = query_amp_caps(codec, nid, dir);
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        /* num steps */
+        uinfo->count = chs == 3 ? 2 : 1;
-        caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
+        uinfo->value.integer.min = 0;
-        if (!caps) {
+        uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
+        if (!uinfo->value.integer.max) {
                printk(KERN_WARNING "hda_codec: "
                       "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
                       kcontrol->id.name);
                return -EINVAL;
        }
-        if (ofs < caps)
-                caps -= ofs;
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = chs == 3 ? 2 : 1;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = caps;
        return 0;
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
@@ -1594,8 +1744,14 @@ update_amp_value(struct hda_codec *codec, hda_nid_t nid,
                 int ch, int dir, int idx, unsigned int ofs,
                 unsigned int val)
 {
+        unsigned int maxval;
        if (val > 0)
                val += ofs;
+        /* ofs = 0: raw max value */
+        maxval = get_amp_max_value(codec, nid, dir, 0);
+        if (val > maxval)
+                val = maxval;
        return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
                                        HDA_AMP_VOLMASK, val);
 }
@@ -2886,6 +3042,7 @@ static void hda_call_codec_suspend(struct hda_codec *codec)
 {
        if (codec->patch_ops.suspend)
                codec->patch_ops.suspend(codec, PMSG_SUSPEND);
+        hda_cleanup_all_streams(codec);
        hda_set_power_state(codec,
                            codec->afg ? codec->afg : codec->mfg,
                            AC_PWRST_D3);
@@ -2907,6 +3064,7 @@ static void hda_call_codec_resume(struct hda_codec *codec)
                            codec->afg ? codec->afg : codec->mfg,
                            AC_PWRST_D0);
        restore_pincfgs(codec); /* restore all current pin configs */
+        restore_shutup_pins(codec);
        hda_exec_init_verbs(codec);
        if (codec->patch_ops.resume)
                codec->patch_ops.resume(codec);
@@ -2972,26 +3130,31 @@ struct hda_rate_tbl {
        unsigned int hda_fmt;
 };
+/* rate = base * mult / div */
+#define HDA_RATE(base, mult, div) \
+        (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
+         (((div) - 1) << AC_FMT_DIV_SHIFT))
 static struct hda_rate_tbl rate_bits[] = {
        /* rate in Hz, ALSA rate bitmask, HDA format value */
        /* autodetected value used in snd_hda_query_supported_pcm */
-        { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
+        { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
-        { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
+        { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
-        { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
+        { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
-        { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
+        { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
-        { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
+        { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
-        { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
+        { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
-        { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
+        { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
-        { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
+        { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
-        { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
+        { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
-        { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
+        { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
-        { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
+        { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
 #define AC_PAR_PCM_RATE_BITS    11
        /* up to bits 10, 384kHZ isn't supported properly */
        /* not autodetected value */
-        { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
+        { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
        { 0 } /* terminator */
 };
@@ -3010,7 +3173,8 @@ static struct hda_rate_tbl rate_bits[] = {
 unsigned int snd_hda_calc_stream_format(unsigned int rate,
                                        unsigned int channels,
                                        unsigned int format,
-                                        unsigned int maxbps)
+                                        unsigned int maxbps,
+                                        unsigned short spdif_ctls)
 {
        int i;
        unsigned int val = 0;
@@ -3033,20 +3197,20 @@ unsigned int snd_hda_calc_stream_format(unsigned int rate,
        switch (snd_pcm_format_width(format)) {
        case 8:
-                val |= 0x00;
+                val |= AC_FMT_BITS_8;
                break;
        case 16:
-                val |= 0x10;
+                val |= AC_FMT_BITS_16;
                break;
        case 20:
        case 24:
        case 32:
                if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
-                        val |= 0x40;
+                        val |= AC_FMT_BITS_32;
                else if (maxbps >= 24)
-                        val |= 0x30;
+                        val |= AC_FMT_BITS_24;
                else
-                        val |= 0x20;
+                        val |= AC_FMT_BITS_20;
                break;
        default:
                snd_printdd("invalid format width %d\n",
@@ -3054,6 +3218,9 @@ unsigned int snd_hda_calc_stream_format(unsigned int rate,
                return 0;
        }
+        if (spdif_ctls & AC_DIG1_NONAUDIO)
+                val |= AC_FMT_TYPE_NON_PCM;
        return val;
 }
 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
@@ -3325,6 +3492,35 @@ static int set_pcm_default_values(struct hda_codec *codec,
        return 0;
 }
+/*
+ * codec prepare/cleanup entries
+ */
+int snd_hda_codec_prepare(struct hda_codec *codec,
+                          struct hda_pcm_stream *hinfo,
+                          unsigned int stream,
+                          unsigned int format,
+                          struct snd_pcm_substream *substream)
+{
+        int ret;
+        mutex_lock(&codec->prepare_mutex);
+        ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
+        if (ret >= 0)
+                purify_inactive_streams(codec);
+        mutex_unlock(&codec->prepare_mutex);
+        return ret;
+}
+EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
+void snd_hda_codec_cleanup(struct hda_codec *codec,
+                           struct hda_pcm_stream *hinfo,
+                           struct snd_pcm_substream *substream)
+{
+        mutex_lock(&codec->prepare_mutex);
+        hinfo->ops.cleanup(hinfo, codec, substream);
+        mutex_unlock(&codec->prepare_mutex);
+}
+EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
 /* global */
 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
        "Audio", "SPDIF", "HDMI", "Modem"
diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h
index 49e939e7e5cd..4303353feda9 100644
--- a/sound/pci/hda/hda_codec.h
+++ b/sound/pci/hda/hda_codec.h
@@ -224,6 +224,27 @@ enum {
 /* Input converter SDI select */
 #define AC_SDI_SELECT                   (0xf<<0)
+/* stream format id */
+#define AC_FMT_CHAN_SHIFT               0
+#define AC_FMT_CHAN_MASK                (0x0f << 0)
+#define AC_FMT_BITS_SHIFT               4
+#define AC_FMT_BITS_MASK                (7 << 4)
+#define AC_FMT_BITS_8                   (0 << 4)
+#define AC_FMT_BITS_16                  (1 << 4)
+#define AC_FMT_BITS_20                  (2 << 4)
+#define AC_FMT_BITS_24                  (3 << 4)
+#define AC_FMT_BITS_32                  (4 << 4)
+#define AC_FMT_DIV_SHIFT                8
+#define AC_FMT_DIV_MASK                 (7 << 8)
+#define AC_FMT_MULT_SHIFT               11
+#define AC_FMT_MULT_MASK                (7 << 11)
+#define AC_FMT_BASE_SHIFT               14
+#define AC_FMT_BASE_48K                 (0 << 14)
+#define AC_FMT_BASE_44K                 (1 << 14)
+#define AC_FMT_TYPE_SHIFT               15
+#define AC_FMT_TYPE_PCM                 (0 << 15)
+#define AC_FMT_TYPE_NON_PCM             (1 << 15)
 /* Unsolicited response control */
 #define AC_UNSOL_TAG                    (0x3f<<0)
 #define AC_UNSOL_ENABLED                (1<<7)
@@ -364,6 +385,9 @@ enum {
 #define AC_DIG2_CC                      (0x7f<<0)
 /* Pin widget control - 8bit */
+#define AC_PINCTL_EPT                   (0x3<<0)
+#define AC_PINCTL_EPT_NATIVE            0
+#define AC_PINCTL_EPT_HBR               3
 #define AC_PINCTL_VREFEN                (0x7<<0)
 #define AC_PINCTL_VREF_HIZ              0       /* Hi-Z */
 #define AC_PINCTL_VREF_50               1       /* 50% */
@@ -760,7 +784,10 @@ struct hda_codec {
        hda_nid_t mfg;  /* MFG node id */
        /* ids */
-        u32 function_id;
+        u8 afg_function_id;
+        u8 mfg_function_id;
+        u8 afg_unsol;
+        u8 mfg_unsol;
        u32 vendor_id;
        u32 subsystem_id;
        u32 revision_id;
@@ -799,12 +826,14 @@ struct hda_codec {
        struct mutex spdif_mutex;
        struct mutex control_mutex;
+        struct mutex prepare_mutex;
        unsigned int spdif_status;      /* IEC958 status bits */
        unsigned short spdif_ctls;      /* SPDIF control bits */
        unsigned int spdif_in_enable;   /* SPDIF input enable? */
        hda_nid_t *slave_dig_outs; /* optional digital out slave widgets */
        struct snd_array init_pins;     /* initial (BIOS) pin configurations */
        struct snd_array driver_pins;   /* pin configs set by codec parser */
+        struct snd_array cvt_setups;    /* audio convert setups */
 #ifdef CONFIG_SND_HDA_HWDEP
        struct snd_hwdep *hwdep;        /* assigned hwdep device */
@@ -821,6 +850,7 @@ struct hda_codec {
        unsigned int pin_amp_workaround:1; /* pin out-amp takes index
                                            * (e.g. Conexant codecs)
                                            */
+        unsigned int pins_shutup:1;     /* pins are shut up */
        unsigned int no_trigger_sense:1; /* don't trigger at pin-sensing */
 #ifdef CONFIG_SND_HDA_POWER_SAVE
        unsigned int power_on :1;       /* current (global) power-state */
@@ -897,7 +927,9 @@ void snd_hda_codec_resume_cache(struct hda_codec *codec);
 /* the struct for codec->pin_configs */
 struct hda_pincfg {
        hda_nid_t nid;
-        unsigned int cfg;
+        unsigned char ctrl;     /* current pin control value */
+        unsigned char pad;      /* reserved */
+        unsigned int cfg;       /* default configuration */
 };
 unsigned int snd_hda_codec_get_pincfg(struct hda_codec *codec, hda_nid_t nid);
@@ -918,14 +950,28 @@ int snd_hda_codec_build_controls(struct hda_codec *codec);
 */
 int snd_hda_build_pcms(struct hda_bus *bus);
 int snd_hda_codec_build_pcms(struct hda_codec *codec);
+int snd_hda_codec_prepare(struct hda_codec *codec,
+                          struct hda_pcm_stream *hinfo,
+                          unsigned int stream,
+                          unsigned int format,
+                          struct snd_pcm_substream *substream);
+void snd_hda_codec_cleanup(struct hda_codec *codec,
+                           struct hda_pcm_stream *hinfo,
+                           struct snd_pcm_substream *substream);
 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
                                u32 stream_tag,
                                int channel_id, int format);
-void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid);
+void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
+                                    int do_now);
+#define snd_hda_codec_cleanup_stream(codec, nid) \
+        __snd_hda_codec_cleanup_stream(codec, nid, 0)
 unsigned int snd_hda_calc_stream_format(unsigned int rate,
                                        unsigned int channels,
                                        unsigned int format,
-                                        unsigned int maxbps);
+                                        unsigned int maxbps,
+                                        unsigned short spdif_ctls);
 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
                                unsigned int format);
diff --git a/sound/pci/hda/hda_eld.c b/sound/pci/hda/hda_eld.c
index d8da18a9e98b..803b298f7411 100644
--- a/sound/pci/hda/hda_eld.c
+++ b/sound/pci/hda/hda_eld.c
@@ -596,4 +596,53 @@ void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld)
 }
 EXPORT_SYMBOL_HDA(snd_hda_eld_proc_free);
+/* update PCM info based on ELD */
+void hdmi_eld_update_pcm_info(struct hdmi_eld *eld, struct hda_pcm_stream *pcm,
+                              struct hda_pcm_stream *codec_pars)
+{
+        int i;
+        pcm->rates = 0;
+        pcm->formats = 0;
+        pcm->maxbps = 0;
+        pcm->channels_min = -1;
+        pcm->channels_max = 0;
+        for (i = 0; i < eld->sad_count; i++) {
+                struct cea_sad *a = &eld->sad[i];
+                pcm->rates |= a->rates;
+                if (a->channels < pcm->channels_min)
+                        pcm->channels_min = a->channels;
+                if (a->channels > pcm->channels_max)
+                        pcm->channels_max = a->channels;
+                if (a->format == AUDIO_CODING_TYPE_LPCM) {
+                        if (a->sample_bits & AC_SUPPCM_BITS_16) {
+                                pcm->formats |= SNDRV_PCM_FMTBIT_S16_LE;
+                                if (pcm->maxbps < 16)
+                                        pcm->maxbps = 16;
+                        }
+                        if (a->sample_bits & AC_SUPPCM_BITS_20) {
+                                pcm->formats |= SNDRV_PCM_FMTBIT_S32_LE;
+                                if (pcm->maxbps < 20)
+                                        pcm->maxbps = 20;
+                        }
+                        if (a->sample_bits & AC_SUPPCM_BITS_24) {
+                                pcm->formats |= SNDRV_PCM_FMTBIT_S32_LE;
+                                if (pcm->maxbps < 24)
+                                        pcm->maxbps = 24;
+                        }
+                }
+        }
+        if (!codec_pars)
+                return;
+        /* restrict the parameters by the values the codec provides */
+        pcm->rates &= codec_pars->rates;
+        pcm->formats &= codec_pars->formats;
+        pcm->channels_min = max(pcm->channels_min, codec_pars->channels_min);
+        pcm->channels_max = min(pcm->channels_max, codec_pars->channels_max);
+        pcm->maxbps = min(pcm->maxbps, codec_pars->maxbps);
+}
+EXPORT_SYMBOL_HDA(hdmi_eld_update_pcm_info);
 #endif /* CONFIG_PROC_FS */
diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c
index a1fc83753cc6..bf3ced51e0f8 100644
--- a/sound/pci/hda/hda_hwdep.c
+++ b/sound/pci/hda/hda_hwdep.c
@@ -649,7 +649,9 @@ static void parse_codec_mode(char *buf, struct hda_bus *bus,
        *codecp = NULL;
        if (sscanf(buf, "%i %i %i", &vendorid, &subid, &caddr) == 3) {
                list_for_each_entry(codec, &bus->codec_list, list) {
-                        if (codec->addr == caddr) {
+                        if (codec->vendor_id == vendorid &&
+                            codec->subsystem_id == subid &&
+                            codec->addr == caddr) {
                                *codecp = codec;
                                break;
                        }
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index dc79564fea30..1053fff4bd0a 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -1634,7 +1634,7 @@ static int azx_pcm_hw_free(struct snd_pcm_substream *substream)
        azx_dev->period_bytes = 0;
        azx_dev->format_val = 0;
-        hinfo->ops.cleanup(hinfo, apcm->codec, substream);
+        snd_hda_codec_cleanup(apcm->codec, hinfo, substream);
        return snd_pcm_lib_free_pages(substream);
 }
@@ -1653,7 +1653,8 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream)
        format_val = snd_hda_calc_stream_format(runtime->rate,
                                                runtime->channels,
                                                runtime->format,
-                                                hinfo->maxbps);
+                                                hinfo->maxbps,
+                                                apcm->codec->spdif_ctls);
        if (!format_val) {
                snd_printk(KERN_ERR SFX
                           "invalid format_val, rate=%d, ch=%d, format=%d\n",
@@ -1687,8 +1688,8 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream)
        else
                azx_dev->fifo_size = 0;
-        return hinfo->ops.prepare(hinfo, apcm->codec, azx_dev->stream_tag,
+        return snd_hda_codec_prepare(apcm->codec, hinfo, azx_dev->stream_tag,
-                                  azx_dev->format_val, substream);
+                                     azx_dev->format_val, substream);
 }
 static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
@@ -1913,11 +1914,11 @@ static int azx_position_ok(struct azx *chip, struct azx_dev *azx_dev)
        if (WARN_ONCE(!azx_dev->period_bytes,
                      "hda-intel: zero azx_dev->period_bytes"))
                return -1; /* this shouldn't happen! */
-        if (wallclk <= azx_dev->period_wallclk &&
+        if (wallclk < (azx_dev->period_wallclk * 5) / 4 &&
            pos % azx_dev->period_bytes > azx_dev->period_bytes / 2)
                /* NG - it's below the first next period boundary */
                return bdl_pos_adj[chip->dev_index] ? 0 : -1;
-        azx_dev->start_wallclk = wallclk;
+        azx_dev->start_wallclk += wallclk;
        return 1; /* OK, it's fine */
 }
@@ -1960,7 +1961,7 @@ static void azx_irq_pending_work(struct work_struct *work)
                spin_unlock_irq(&chip->reg_lock);
                if (!pending)
                        return;
-                cond_resched();
+                msleep(1);
        }
 }
@@ -2288,6 +2289,8 @@ static struct snd_pci_quirk position_fix_list[] __devinitdata = {
        SND_PCI_QUIRK(0x1028, 0x01f6, "Dell Latitude 131L", POS_FIX_LPIB),
        SND_PCI_QUIRK(0x103c, 0x306d, "HP dv3", POS_FIX_LPIB),
        SND_PCI_QUIRK(0x1043, 0x813d, "ASUS P5AD2", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS M2V", POS_FIX_LPIB),
        SND_PCI_QUIRK(0x104d, 0x9069, "Sony VPCS11V9E", POS_FIX_LPIB),
        SND_PCI_QUIRK(0x1106, 0x3288, "ASUS M2V-MX SE", POS_FIX_LPIB),
        SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba A100-259", POS_FIX_LPIB),
@@ -2296,6 +2299,7 @@ static struct snd_pci_quirk position_fix_list[] __devinitdata = {
        SND_PCI_QUIRK(0x1462, 0x1002, "MSI Wind U115", POS_FIX_LPIB),
        SND_PCI_QUIRK(0x1565, 0x820f, "Biostar Microtech", POS_FIX_LPIB),
        SND_PCI_QUIRK(0x1565, 0x8218, "Biostar Microtech", POS_FIX_LPIB),
+        SND_PCI_QUIRK(0x1849, 0x0888, "775Dual-VSTA", POS_FIX_LPIB),
        SND_PCI_QUIRK(0x8086, 0x2503, "DG965OT AAD63733-203", POS_FIX_LPIB),
        SND_PCI_QUIRK(0x8086, 0xd601, "eMachines T5212", POS_FIX_LPIB),
        {}
diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h
index 7a97f126f6f7..28ab4aead48f 100644
--- a/sound/pci/hda/hda_local.h
+++ b/sound/pci/hda/hda_local.h
@@ -604,6 +604,8 @@ struct hdmi_eld {
 int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid);
 int snd_hdmi_get_eld(struct hdmi_eld *, struct hda_codec *, hda_nid_t);
 void snd_hdmi_show_eld(struct hdmi_eld *eld);
+void hdmi_eld_update_pcm_info(struct hdmi_eld *eld, struct hda_pcm_stream *pcm,
+                              struct hda_pcm_stream *codec_pars);
 #ifdef CONFIG_PROC_FS
 int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld,
diff --git a/sound/pci/hda/hda_proc.c b/sound/pci/hda/hda_proc.c
index f97d35de66c4..f025200f2a62 100644
--- a/sound/pci/hda/hda_proc.c
+++ b/sound/pci/hda/hda_proc.c
@@ -557,7 +557,12 @@ static void print_codec_info(struct snd_info_entry *entry,
        else
                snd_iprintf(buffer, "Not Set\n");
        snd_iprintf(buffer, "Address: %d\n", codec->addr);
-        snd_iprintf(buffer, "Function Id: 0x%x\n", codec->function_id);
+        if (codec->afg)
+                snd_iprintf(buffer, "AFG Function Id: 0x%x (unsol %u)\n",
+                        codec->afg_function_id, codec->afg_unsol);
+        if (codec->mfg)
+                snd_iprintf(buffer, "MFG Function Id: 0x%x (unsol %u)\n",
+                        codec->mfg_function_id, codec->mfg_unsol);
        snd_iprintf(buffer, "Vendor Id: 0x%08x\n", codec->vendor_id);
        snd_iprintf(buffer, "Subsystem Id: 0x%08x\n", codec->subsystem_id);
        snd_iprintf(buffer, "Revision Id: 0x%x\n", codec->revision_id);
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index afbe314a5bf3..b697fd2a6f8b 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -3662,7 +3662,12 @@ static int patch_ad1984(struct hda_codec *codec)
                codec->patch_ops.build_pcms = ad1984_build_pcms;
                break;
        case AD1984_THINKPAD:
-                spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
+                if (codec->subsystem_id == 0x17aa20fb) {
+                        /* Thinpad X300 does not have the ability to do SPDIF,
+                           or attach to docking station to use SPDIF */
+                        spec->multiout.dig_out_nid = 0;
+                } else
+                        spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
                spec->input_mux = &ad1984_thinkpad_capture_source;
                spec->mixers[0] = ad1984_thinkpad_mixers;
                spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c
index 350ee8ac4153..4ef5efaaaef1 100644
--- a/sound/pci/hda/patch_cirrus.c
+++ b/sound/pci/hda/patch_cirrus.c
@@ -656,7 +656,7 @@ static int change_cur_input(struct hda_codec *codec, unsigned int idx,
                return 0;
        if (spec->cur_adc && spec->cur_adc != spec->adc_nid[idx]) {
                /* stream is running, let's swap the current ADC */
-                snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
+                __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
                spec->cur_adc = spec->adc_nid[idx];
                snd_hda_codec_setup_stream(codec, spec->cur_adc,
                                           spec->cur_adc_stream_tag, 0,
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
index 2bf2cb5da956..31b5d9eeba68 100644
--- a/sound/pci/hda/patch_conexant.c
+++ b/sound/pci/hda/patch_conexant.c
@@ -131,6 +131,8 @@ struct conexant_spec {
        unsigned int dc_enable;
        unsigned int dc_input_bias; /* offset into cxt5066_olpc_dc_bias */
        unsigned int mic_boost; /* offset into cxt5066_analog_mic_boost */
+        unsigned int beep_amp;
 };
 static int conexant_playback_pcm_open(struct hda_pcm_stream *hinfo,
@@ -515,6 +517,15 @@ static struct snd_kcontrol_new cxt_capture_mixers[] = {
        {}
 };
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+/* additional beep mixers; the actual parameters are overwritten at build */
+static struct snd_kcontrol_new cxt_beep_mixer[] = {
+        HDA_CODEC_VOLUME_MONO("Beep Playback Volume", 0, 1, 0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_BEEP_MONO("Beep Playback Switch", 0, 1, 0, HDA_OUTPUT),
+        { } /* end */
+};
+#endif
 static const char *slave_vols[] = {
        "Headphone Playback Volume",
        "Speaker Playback Volume",
@@ -580,16 +591,52 @@ static int conexant_build_controls(struct hda_codec *codec)
                        return err;
        }
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+        /* create beep controls if needed */
+        if (spec->beep_amp) {
+                struct snd_kcontrol_new *knew;
+                for (knew = cxt_beep_mixer; knew->name; knew++) {
+                        struct snd_kcontrol *kctl;
+                        kctl = snd_ctl_new1(knew, codec);
+                        if (!kctl)
+                                return -ENOMEM;
+                        kctl->private_value = spec->beep_amp;
+                        err = snd_hda_ctl_add(codec, 0, kctl);
+                        if (err < 0)
+                                return err;
+                }
+        }
+#endif
+        return 0;
+}
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+static int conexant_suspend(struct hda_codec *codec, pm_message_t state)
+{
+        snd_hda_shutup_pins(codec);
        return 0;
 }
+#endif
 static struct hda_codec_ops conexant_patch_ops = {
        .build_controls = conexant_build_controls,
        .build_pcms = conexant_build_pcms,
        .init = conexant_init,
        .free = conexant_free,
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        .suspend = conexant_suspend,
+#endif
+        .reboot_notify = snd_hda_shutup_pins,
 };
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+#define set_beep_amp(spec, nid, idx, dir) \
+        ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir))
+#else
+#define set_beep_amp(spec, nid, idx, dir) /* NOP */
+#endif
 /*
 * EAPD control
 * the private value = nid | (invert << 8)
@@ -1130,9 +1177,10 @@ static int patch_cxt5045(struct hda_codec *codec)
        spec->num_init_verbs = 1;
        spec->init_verbs[0] = cxt5045_init_verbs;
        spec->spdif_route = 0;
-        spec->num_channel_mode = ARRAY_SIZE(cxt5045_modes),
+        spec->num_channel_mode = ARRAY_SIZE(cxt5045_modes);
-        spec->channel_mode = cxt5045_modes,
+        spec->channel_mode = cxt5045_modes;
+        set_beep_amp(spec, 0x16, 0, 1);
        codec->patch_ops = conexant_patch_ops;
@@ -1211,6 +1259,9 @@ static int patch_cxt5045(struct hda_codec *codec)
                break;
        }
+        if (spec->beep_amp)
+                snd_hda_attach_beep_device(codec, spec->beep_amp);
        return 0;
 }
@@ -1632,6 +1683,11 @@ static void cxt5051_update_speaker(struct hda_codec *codec)
        pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0;
        snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
                            pinctl);
+        /* on ideapad there is an aditional speaker (subwoofer) to mute */
+        if (spec->ideapad)
+                snd_hda_codec_write(codec, 0x1b, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                    pinctl);
 }
 /* turn on/off EAPD (+ mute HP) as a master switch */
@@ -1677,7 +1733,7 @@ static void cxt5051_portc_automic(struct hda_codec *codec)
        new_adc = spec->adc_nids[spec->cur_adc_idx];
        if (spec->cur_adc && spec->cur_adc != new_adc) {
                /* stream is running, let's swap the current ADC */
-                snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
+                __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
                spec->cur_adc = new_adc;
                snd_hda_codec_setup_stream(codec, new_adc,
                                           spec->cur_adc_stream_tag, 0,
@@ -1888,6 +1944,13 @@ static void cxt5051_init_mic_port(struct hda_codec *codec, hda_nid_t nid,
 #endif
 }
+static struct hda_verb cxt5051_ideapad_init_verbs[] = {
+        /* Subwoofer */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
+        { } /* end */
+};
 /* initialize jack-sensing, too */
 static int cxt5051_init(struct hda_codec *codec)
 {
@@ -1917,6 +1980,7 @@ enum {
        CXT5051_LENOVO_X200,    /* Lenovo X200 laptop, also used for Advanced Mini Dock 250410 */
        CXT5051_F700,       /* HP Compaq Presario F700 */
        CXT5051_TOSHIBA,        /* Toshiba M300 & co */
+        CXT5051_IDEAPAD,        /* Lenovo IdeaPad Y430 */
        CXT5051_MODELS
 };
@@ -1927,6 +1991,7 @@ static const char *cxt5051_models[CXT5051_MODELS] = {
        [CXT5051_LENOVO_X200]   = "lenovo-x200",
        [CXT5051_F700]          = "hp-700",
        [CXT5051_TOSHIBA]       = "toshiba",
+        [CXT5051_IDEAPAD]       = "ideapad",
 };
 static struct snd_pci_quirk cxt5051_cfg_tbl[] = {
@@ -1938,6 +2003,7 @@ static struct snd_pci_quirk cxt5051_cfg_tbl[] = {
                      CXT5051_LAPTOP),
        SND_PCI_QUIRK(0x14f1, 0x5051, "HP Spartan 1.1", CXT5051_HP),
        SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo X200", CXT5051_LENOVO_X200),
+        SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo IdeaPad", CXT5051_IDEAPAD),
        {}
 };
@@ -1972,6 +2038,8 @@ static int patch_cxt5051(struct hda_codec *codec)
        spec->cur_adc = 0;
        spec->cur_adc_idx = 0;
+        set_beep_amp(spec, 0x13, 0, HDA_OUTPUT);
        codec->patch_ops.unsol_event = cxt5051_hp_unsol_event;
        board_config = snd_hda_check_board_config(codec, CXT5051_MODELS,
@@ -1989,6 +2057,10 @@ static int patch_cxt5051(struct hda_codec *codec)
                break;
        case CXT5051_LENOVO_X200:
                spec->init_verbs[0] = cxt5051_lenovo_x200_init_verbs;
+                /* Thinkpad X301 does not have S/PDIF wired and no ability
+                   to use a docking station. */
+                if (codec->subsystem_id == 0x17aa211f)
+                        spec->multiout.dig_out_nid = 0;
                break;
        case CXT5051_F700:
                spec->init_verbs[0] = cxt5051_f700_init_verbs;
@@ -1999,8 +2071,16 @@ static int patch_cxt5051(struct hda_codec *codec)
                spec->mixers[0] = cxt5051_toshiba_mixers;
                spec->auto_mic = AUTO_MIC_PORTB;
                break;
+        case CXT5051_IDEAPAD:
+                spec->init_verbs[spec->num_init_verbs++] =
+                        cxt5051_ideapad_init_verbs;
+                spec->ideapad = 1;
+                break;
        }
+        if (spec->beep_amp)
+                snd_hda_attach_beep_device(codec, spec->beep_amp);
        return 0;
 }
@@ -2616,7 +2696,6 @@ static struct snd_kcontrol_new cxt5066_vostro_mixers[] = {
                .put = cxt5066_mic_boost_mux_enum_put,
                .private_value = 0x23 | 0x100,
        },
-        HDA_CODEC_VOLUME_MONO("Beep Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
        {}
 };
@@ -2977,8 +3056,10 @@ static struct snd_pci_quirk cxt5066_cfg_tbl[] = {
        SND_PCI_QUIRK(0x17aa, 0x21b2, "Thinkpad X100e", CXT5066_IDEAPAD),
        SND_PCI_QUIRK(0x17aa, 0x21b3, "Thinkpad Edge 13 (197)", CXT5066_IDEAPAD),
        SND_PCI_QUIRK(0x17aa, 0x21b4, "Thinkpad Edge", CXT5066_IDEAPAD),
+        SND_PCI_QUIRK(0x17aa, 0x215e, "Lenovo Thinkpad", CXT5066_THINKPAD),
+        SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo G series", CXT5066_IDEAPAD),
+        SND_PCI_QUIRK(0x17aa, 0x3938, "Lenovo G series (AMD)", CXT5066_IDEAPAD),
        SND_PCI_QUIRK(0x17aa, 0x3a0d, "ideapad", CXT5066_IDEAPAD),
-        SND_PCI_QUIRK(0x17aa, 0x215e, "Lenovo Thinkpad", CXT5066_THINKPAD),
        {}
 };
@@ -3014,6 +3095,8 @@ static int patch_cxt5066(struct hda_codec *codec)
        spec->cur_adc = 0;
        spec->cur_adc_idx = 0;
+        set_beep_amp(spec, 0x13, 0, HDA_OUTPUT);
        board_config = snd_hda_check_board_config(codec, CXT5066_MODELS,
                                                  cxt5066_models, cxt5066_cfg_tbl);
        switch (board_config) {
@@ -3062,7 +3145,6 @@ static int patch_cxt5066(struct hda_codec *codec)
                spec->port_d_mode = 0;
                spec->dell_vostro = 1;
                spec->mic_boost = 3; /* default 30dB gain */
-                snd_hda_attach_beep_device(codec, 0x13);
                /* no S/PDIF out */
                spec->multiout.dig_out_nid = 0;
@@ -3104,6 +3186,9 @@ static int patch_cxt5066(struct hda_codec *codec)
                break;
        }
+        if (spec->beep_amp)
+                snd_hda_attach_beep_device(codec, spec->beep_amp);
        return 0;
 }
@@ -3121,6 +3206,8 @@ static struct hda_codec_preset snd_hda_preset_conexant[] = {
          .patch = patch_cxt5066 },
        { .id = 0x14f15067, .name = "CX20583 (Pebble HSF)",
          .patch = patch_cxt5066 },
+        { .id = 0x14f15068, .name = "CX20584",
+          .patch = patch_cxt5066 },
        { .id = 0x14f15069, .name = "CX20585",
          .patch = patch_cxt5066 },
        {} /* terminator */
@@ -3131,6 +3218,7 @@ MODULE_ALIAS("snd-hda-codec-id:14f15047");
 MODULE_ALIAS("snd-hda-codec-id:14f15051");
 MODULE_ALIAS("snd-hda-codec-id:14f15066");
 MODULE_ALIAS("snd-hda-codec-id:14f15067");
+MODULE_ALIAS("snd-hda-codec-id:14f15068");
 MODULE_ALIAS("snd-hda-codec-id:14f15069");
 MODULE_LICENSE("GPL");
diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
index 86067ee78632..2bc0f07cf33f 100644
--- a/sound/pci/hda/patch_hdmi.c
+++ b/sound/pci/hda/patch_hdmi.c
@@ -46,12 +46,17 @@ struct hdmi_spec {
         * export one pcm per pipe
         */
        struct hda_pcm  pcm_rec[MAX_HDMI_CVTS];
+        struct hda_pcm_stream codec_pcm_pars[MAX_HDMI_CVTS];
        /*
         * nvhdmi specific
         */
        struct hda_multi_out multiout;
        unsigned int codec_type;
+        /* misc flags */
+        /* PD bit indicates only the update, not the current state */
+        unsigned int old_pin_detect:1;
 };
@@ -616,6 +621,9 @@ static void hdmi_setup_audio_infoframe(struct hda_codec *codec, hda_nid_t nid,
 * Unsolicited events
 */
+static void hdmi_present_sense(struct hda_codec *codec, hda_nid_t pin_nid,
+                               struct hdmi_eld *eld);
 static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
 {
        struct hdmi_spec *spec = codec->spec;
@@ -632,6 +640,12 @@ static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
        if (index < 0)
                return;
+        if (spec->old_pin_detect) {
+                if (pind)
+                        hdmi_present_sense(codec, tag, &spec->sink_eld[index]);
+                pind = spec->sink_eld[index].monitor_present;
+        }
        spec->sink_eld[index].monitor_present = pind;
        spec->sink_eld[index].eld_valid = eldv;
@@ -685,11 +699,51 @@ static void hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
 * Callbacks
 */
-static void hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid,
+/* HBR should be Non-PCM, 8 channels */
+#define is_hbr_format(format) \
+        ((format & AC_FMT_TYPE_NON_PCM) && (format & AC_FMT_CHAN_MASK) == 7)
+static int hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid,
                              u32 stream_tag, int format)
 {
+        struct hdmi_spec *spec = codec->spec;
        int tag;
        int fmt;
+        int pinctl;
+        int new_pinctl = 0;
+        int i;
+        for (i = 0; i < spec->num_pins; i++) {
+                if (spec->pin_cvt[i] != nid)
+                        continue;
+                if (!(snd_hda_query_pin_caps(codec, spec->pin[i]) & AC_PINCAP_HBR))
+                        continue;
+                pinctl = snd_hda_codec_read(codec, spec->pin[i], 0,
+                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
+                new_pinctl = pinctl & ~AC_PINCTL_EPT;
+                if (is_hbr_format(format))
+                        new_pinctl |= AC_PINCTL_EPT_HBR;
+                else
+                        new_pinctl |= AC_PINCTL_EPT_NATIVE;
+                snd_printdd("hdmi_setup_stream: "
+                            "NID=0x%x, %spinctl=0x%x\n",
+                            spec->pin[i],
+                            pinctl == new_pinctl ? "" : "new-",
+                            new_pinctl);
+                if (pinctl != new_pinctl)
+                        snd_hda_codec_write(codec, spec->pin[i], 0,
+                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                            new_pinctl);
+        }
+        if (is_hbr_format(format) && !new_pinctl) {
+                snd_printdd("hdmi_setup_stream: HBR is not supported\n");
+                return -EINVAL;
+        }
        tag = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0) >> 4;
        fmt = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_STREAM_FORMAT, 0);
@@ -709,6 +763,48 @@ static void hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid,
        if (fmt != format)
                snd_hda_codec_write(codec, nid, 0,
                                    AC_VERB_SET_STREAM_FORMAT, format);
+        return 0;
+}
+/*
+ * HDA PCM callbacks
+ */
+static int hdmi_pcm_open(struct hda_pcm_stream *hinfo,
+                         struct hda_codec *codec,
+                         struct snd_pcm_substream *substream)
+{
+        struct hdmi_spec *spec = codec->spec;
+        struct hdmi_eld *eld;
+        struct hda_pcm_stream *codec_pars;
+        unsigned int idx;
+        for (idx = 0; idx < spec->num_cvts; idx++)
+                if (hinfo->nid == spec->cvt[idx])
+                        break;
+        if (snd_BUG_ON(idx >= spec->num_cvts) ||
+            snd_BUG_ON(idx >= spec->num_pins))
+                return -EINVAL;
+        /* save the PCM info the codec provides */
+        codec_pars = &spec->codec_pcm_pars[idx];
+        if (!codec_pars->rates)
+                *codec_pars = *hinfo;
+        eld = &spec->sink_eld[idx];
+        if (eld->sad_count > 0) {
+                hdmi_eld_update_pcm_info(eld, hinfo, codec_pars);
+                if (hinfo->channels_min > hinfo->channels_max ||
+                    !hinfo->rates || !hinfo->formats)
+                        return -ENODEV;
+        } else {
+                /* fallback to the codec default */
+                hinfo->channels_min = codec_pars->channels_min;
+                hinfo->channels_max = codec_pars->channels_max;
+                hinfo->rates = codec_pars->rates;
+                hinfo->formats = codec_pars->formats;
+                hinfo->maxbps = codec_pars->maxbps;
+        }
+        return 0;
 }
 /*
diff --git a/sound/pci/hda/patch_intelhdmi.c b/sound/pci/hda/patch_intelhdmi.c
index b81d23e42ace..d382d3c81c0f 100644
--- a/sound/pci/hda/patch_intelhdmi.c
+++ b/sound/pci/hda/patch_intelhdmi.c
@@ -66,8 +66,7 @@ static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
        hdmi_setup_audio_infoframe(codec, hinfo->nid, substream);
-        hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
+        return hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
-        return 0;
 }
 static int intel_hdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
@@ -81,6 +80,7 @@ static struct hda_pcm_stream intel_hdmi_pcm_playback = {
        .substreams = 1,
        .channels_min = 2,
        .ops = {
+                .open = hdmi_pcm_open,
                .prepare = intel_hdmi_playback_pcm_prepare,
                .cleanup = intel_hdmi_playback_pcm_cleanup,
        },
diff --git a/sound/pci/hda/patch_nvhdmi.c b/sound/pci/hda/patch_nvhdmi.c
index 3c10c0b149f4..f636870dc718 100644
--- a/sound/pci/hda/patch_nvhdmi.c
+++ b/sound/pci/hda/patch_nvhdmi.c
@@ -202,8 +202,7 @@ static int nvhdmi_dig_playback_pcm_prepare_8ch_89(struct hda_pcm_stream *hinfo,
        hdmi_setup_audio_infoframe(codec, hinfo->nid, substream);
-        hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
+        return hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
-        return 0;
 }
 static int nvhdmi_dig_playback_pcm_prepare_8ch(struct hda_pcm_stream *hinfo,
@@ -348,10 +347,8 @@ static int nvhdmi_dig_playback_pcm_prepare_2ch(struct hda_pcm_stream *hinfo,
 static struct hda_pcm_stream nvhdmi_pcm_digital_playback_8ch_89 = {
        .substreams = 1,
        .channels_min = 2,
-        .rates = SUPPORTED_RATES,
-        .maxbps = SUPPORTED_MAXBPS,
-        .formats = SUPPORTED_FORMATS,
        .ops = {
+                .open = hdmi_pcm_open,
                .prepare = nvhdmi_dig_playback_pcm_prepare_8ch_89,
                .cleanup = nvhdmi_playback_pcm_cleanup,
        },
@@ -478,6 +475,7 @@ static int patch_nvhdmi_8ch_89(struct hda_codec *codec)
        codec->spec = spec;
        spec->codec_type = HDA_CODEC_NVIDIA_MCP89;
+        spec->old_pin_detect = 1;
        if (hdmi_parse_codec(codec) < 0) {
                codec->spec = NULL;
@@ -508,6 +506,7 @@ static int patch_nvhdmi_8ch_7x(struct hda_codec *codec)
        spec->multiout.max_channels = 8;
        spec->multiout.dig_out_nid = nvhdmi_master_con_nid_7x;
        spec->codec_type = HDA_CODEC_NVIDIA_MCP7X;
+        spec->old_pin_detect = 1;
        codec->patch_ops = nvhdmi_patch_ops_8ch_7x;
@@ -528,6 +527,7 @@ static int patch_nvhdmi_2ch(struct hda_codec *codec)
        spec->multiout.max_channels = 2;
        spec->multiout.dig_out_nid = nvhdmi_master_con_nid_7x;
        spec->codec_type = HDA_CODEC_NVIDIA_MCP7X;
+        spec->old_pin_detect = 1;
        codec->patch_ops = nvhdmi_patch_ops_2ch;
@@ -538,26 +538,32 @@ static int patch_nvhdmi_2ch(struct hda_codec *codec)
 * patch entries
 */
 static struct hda_codec_preset snd_hda_preset_nvhdmi[] = {
-        { .id = 0x10de0002, .name = "MCP77/78 HDMI",
+        { .id = 0x10de0002, .name = "MCP77/78 HDMI",  .patch = patch_nvhdmi_8ch_7x },
-          .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de0003, .name = "MCP77/78 HDMI",  .patch = patch_nvhdmi_8ch_7x },
-        { .id = 0x10de0003, .name = "MCP77/78 HDMI",
+        { .id = 0x10de0005, .name = "MCP77/78 HDMI",  .patch = patch_nvhdmi_8ch_7x },
-          .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de0006, .name = "MCP77/78 HDMI",  .patch = patch_nvhdmi_8ch_7x },
-        { .id = 0x10de0005, .name = "MCP77/78 HDMI",
+        { .id = 0x10de0007, .name = "MCP79/7A HDMI",  .patch = patch_nvhdmi_8ch_7x },
-          .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de000a, .name = "GPU 0a HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de0006, .name = "MCP77/78 HDMI",
+        { .id = 0x10de000b, .name = "GPU 0b HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-          .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de000c, .name = "MCP89 HDMI",     .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de0007, .name = "MCP79/7A HDMI",
+        { .id = 0x10de000d, .name = "GPU 0d HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-          .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de0010, .name = "GPU 10 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de000a, .name = "GT220 HDMI",
+        { .id = 0x10de0011, .name = "GPU 11 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-          .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0012, .name = "GPU 12 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de000b, .name = "GT21x HDMI",
+        { .id = 0x10de0013, .name = "GPU 13 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-          .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0014, .name = "GPU 14 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de000c, .name = "MCP89 HDMI",
+        { .id = 0x10de0018, .name = "GPU 18 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-          .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0019, .name = "GPU 19 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de000d, .name = "GT240 HDMI",
+        { .id = 0x10de001a, .name = "GPU 1a HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-          .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de001b, .name = "GPU 1b HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de0067, .name = "MCP67 HDMI", .patch = patch_nvhdmi_2ch },
+        { .id = 0x10de001c, .name = "GPU 1c HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de8001, .name = "MCP73 HDMI", .patch = patch_nvhdmi_2ch },
+        { .id = 0x10de0040, .name = "GPU 40 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0041, .name = "GPU 41 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0042, .name = "GPU 42 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0043, .name = "GPU 43 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0044, .name = "GPU 44 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0067, .name = "MCP67 HDMI",     .patch = patch_nvhdmi_2ch },
+        { .id = 0x10de8001, .name = "MCP73 HDMI",     .patch = patch_nvhdmi_2ch },
        {} /* terminator */
 };
@@ -570,6 +576,21 @@ MODULE_ALIAS("snd-hda-codec-id:10de000a");
 MODULE_ALIAS("snd-hda-codec-id:10de000b");
 MODULE_ALIAS("snd-hda-codec-id:10de000c");
 MODULE_ALIAS("snd-hda-codec-id:10de000d");
+MODULE_ALIAS("snd-hda-codec-id:10de0010");
+MODULE_ALIAS("snd-hda-codec-id:10de0011");
+MODULE_ALIAS("snd-hda-codec-id:10de0012");
+MODULE_ALIAS("snd-hda-codec-id:10de0013");
+MODULE_ALIAS("snd-hda-codec-id:10de0014");
+MODULE_ALIAS("snd-hda-codec-id:10de0018");
+MODULE_ALIAS("snd-hda-codec-id:10de0019");
+MODULE_ALIAS("snd-hda-codec-id:10de001a");
+MODULE_ALIAS("snd-hda-codec-id:10de001b");
+MODULE_ALIAS("snd-hda-codec-id:10de001c");
+MODULE_ALIAS("snd-hda-codec-id:10de0040");
+MODULE_ALIAS("snd-hda-codec-id:10de0041");
+MODULE_ALIAS("snd-hda-codec-id:10de0042");
+MODULE_ALIAS("snd-hda-codec-id:10de0043");
+MODULE_ALIAS("snd-hda-codec-id:10de0044");
 MODULE_ALIAS("snd-hda-codec-id:10de0067");
 MODULE_ALIAS("snd-hda-codec-id:10de8001");
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 17d4548cc353..2cd1ae809e46 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -137,6 +137,7 @@ enum {
        ALC269VB_DMIC,
        ALC269_FUJITSU,
        ALC269_LIFEBOOK,
+        ALC271_ACER,
        ALC269_AUTO,
        ALC269_MODEL_LAST /* last tag */
 };
@@ -256,6 +257,13 @@ enum {
        ALC882_MODEL_LAST,
 };
+/* ALC680 models */
+enum {
+        ALC680_BASE,
+        ALC680_AUTO,
+        ALC680_MODEL_LAST,
+};
 /* for GPIO Poll */
 #define GPIO_MASK       0x03
@@ -326,6 +334,12 @@ struct alc_spec {
        hda_nid_t *capsrc_nids;
        hda_nid_t dig_in_nid;           /* digital-in NID; optional */
+        /* capture setup for dynamic dual-adc switch */
+        unsigned int cur_adc_idx;
+        hda_nid_t cur_adc;
+        unsigned int cur_adc_stream_tag;
+        unsigned int cur_adc_format;
        /* capture source */
        unsigned int num_mux_defs;
        const struct hda_input_mux *input_mux;
@@ -367,6 +381,7 @@ struct alc_spec {
        /* other flags */
        unsigned int no_analog :1; /* digital I/O only */
+        unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
        int init_amp;
        /* for virtual master */
@@ -833,9 +848,13 @@ static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
        if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
                unsigned int pincap;
+                unsigned int oldval;
+                oldval = snd_hda_codec_read(codec, nid, 0,
+                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
                pincap = snd_hda_query_pin_caps(codec, nid);
                pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
-                if (pincap & AC_PINCAP_VREF_80)
+                /* if the default pin setup is vref50, we give it priority */
+                if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
                        val = PIN_VREF80;
                else if (pincap & AC_PINCAP_VREF_50)
                        val = PIN_VREF50;
@@ -1003,6 +1022,29 @@ static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
        return -1;
 }
+/* switch the current ADC according to the jack state */
+static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        unsigned int present;
+        hda_nid_t new_adc;
+        present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
+        if (present)
+                spec->cur_adc_idx = 1;
+        else
+                spec->cur_adc_idx = 0;
+        new_adc = spec->adc_nids[spec->cur_adc_idx];
+        if (spec->cur_adc && spec->cur_adc != new_adc) {
+                /* stream is running, let's swap the current ADC */
+                __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
+                spec->cur_adc = new_adc;
+                snd_hda_codec_setup_stream(codec, new_adc,
+                                           spec->cur_adc_stream_tag, 0,
+                                           spec->cur_adc_format);
+        }
+}
 static void alc_mic_automute(struct hda_codec *codec)
 {
        struct alc_spec *spec = codec->spec;
@@ -1017,6 +1059,11 @@ static void alc_mic_automute(struct hda_codec *codec)
        if (snd_BUG_ON(!spec->adc_nids))
                return;
+        if (spec->dual_adc_switch) {
+                alc_dual_mic_adc_auto_switch(codec);
+                return;
+        }
        cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
        present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
@@ -1267,6 +1314,8 @@ static int alc_auto_parse_customize_define(struct hda_codec *codec)
        unsigned nid = 0;
        struct alc_spec *spec = codec->spec;
+        spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
        ass = codec->subsystem_id & 0xffff;
        if (ass != codec->bus->pci->subsystem_device && (ass & 1))
                goto do_sku;
@@ -1497,6 +1546,63 @@ static int alc_read_coef_idx(struct hda_codec *codec,
        return val;
 }
+/* set right pin controls for digital I/O */
+static void alc_auto_init_digital(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        int i;
+        hda_nid_t pin;
+        for (i = 0; i < spec->autocfg.dig_outs; i++) {
+                pin = spec->autocfg.dig_out_pins[i];
+                if (pin) {
+                        snd_hda_codec_write(codec, pin, 0,
+                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                            PIN_OUT);
+                }
+        }
+        pin = spec->autocfg.dig_in_pin;
+        if (pin)
+                snd_hda_codec_write(codec, pin, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                    PIN_IN);
+}
+/* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
+static void alc_auto_parse_digital(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        int i, err;
+        hda_nid_t dig_nid;
+        /* support multiple SPDIFs; the secondary is set up as a slave */
+        for (i = 0; i < spec->autocfg.dig_outs; i++) {
+                err = snd_hda_get_connections(codec,
+                                              spec->autocfg.dig_out_pins[i],
+                                              &dig_nid, 1);
+                if (err < 0)
+                        continue;
+                if (!i) {
+                        spec->multiout.dig_out_nid = dig_nid;
+                        spec->dig_out_type = spec->autocfg.dig_out_type[0];
+                } else {
+                        spec->multiout.slave_dig_outs = spec->slave_dig_outs;
+                        if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
+                                break;
+                        spec->slave_dig_outs[i - 1] = dig_nid;
+                }
+        }
+        if (spec->autocfg.dig_in_pin) {
+                hda_nid_t dig_nid;
+                err = snd_hda_get_connections(codec,
+                                              spec->autocfg.dig_in_pin,
+                                              &dig_nid, 1);
+                if (err > 0)
+                        spec->dig_in_nid = dig_nid;
+        }
+}
 /*
 * ALC888
 */
@@ -2547,7 +2653,7 @@ static struct snd_kcontrol_new alc_beep_mixer[] = {
 static int alc_build_controls(struct hda_codec *codec)
 {
        struct alc_spec *spec = codec->spec;
-        struct snd_kcontrol *kctl;
+        struct snd_kcontrol *kctl = NULL;
        struct snd_kcontrol_new *knew;
        int i, j, err;
        unsigned int u;
@@ -2619,16 +2725,18 @@ static int alc_build_controls(struct hda_codec *codec)
        }
        /* assign Capture Source enums to NID */
-        kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
+        if (spec->capsrc_nids || spec->adc_nids) {
-        if (!kctl)
+                kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
-                kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
+                if (!kctl)
-        for (i = 0; kctl && i < kctl->count; i++) {
+                        kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
-                hda_nid_t *nids = spec->capsrc_nids;
+                for (i = 0; kctl && i < kctl->count; i++) {
-                if (!nids)
+                        hda_nid_t *nids = spec->capsrc_nids;
-                        nids = spec->adc_nids;
+                        if (!nids)
-                err = snd_hda_add_nid(codec, kctl, i, nids[i]);
+                                nids = spec->adc_nids;
-                if (err < 0)
+                        err = snd_hda_add_nid(codec, kctl, i, nids[i]);
-                        return err;
+                        if (err < 0)
+                                return err;
+                }
        }
        if (spec->cap_mixer) {
                const char *kname = kctl ? kctl->id.name : NULL;
@@ -3603,6 +3711,41 @@ static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
        return 0;
 }
+/* analog capture with dynamic dual-adc changes */
+static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
+                                       struct hda_codec *codec,
+                                       unsigned int stream_tag,
+                                       unsigned int format,
+                                       struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+        spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
+        spec->cur_adc_stream_tag = stream_tag;
+        spec->cur_adc_format = format;
+        snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
+        return 0;
+}
+static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                       struct hda_codec *codec,
+                                       struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+        snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
+        spec->cur_adc = 0;
+        return 0;
+}
+static struct hda_pcm_stream dualmic_pcm_analog_capture = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = 0, /* fill later */
+        .ops = {
+                .prepare = dualmic_capture_pcm_prepare,
+                .cleanup = dualmic_capture_pcm_cleanup
+        },
+};
 /*
 */
@@ -4932,7 +5075,7 @@ static void alc880_auto_init_input_src(struct hda_codec *codec)
 static int alc880_parse_auto_config(struct hda_codec *codec)
 {
        struct alc_spec *spec = codec->spec;
-        int i, err;
+        int err;
        static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
@@ -4963,25 +5106,7 @@ static int alc880_parse_auto_config(struct hda_codec *codec)
        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
-        /* check multiple SPDIF-out (for recent codecs) */
+        alc_auto_parse_digital(codec);
-        for (i = 0; i < spec->autocfg.dig_outs; i++) {
-                hda_nid_t dig_nid;
-                err = snd_hda_get_connections(codec,
-                                              spec->autocfg.dig_out_pins[i],
-                                              &dig_nid, 1);
-                if (err < 0)
-                        continue;
-                if (!i)
-                        spec->multiout.dig_out_nid = dig_nid;
-                else {
-                        spec->multiout.slave_dig_outs = spec->slave_dig_outs;
-                        if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
-                                break;
-                        spec->slave_dig_outs[i - 1] = dig_nid;
-                }
-        }
-        if (spec->autocfg.dig_in_pin)
-                spec->dig_in_nid = ALC880_DIGIN_NID;
        if (spec->kctls.list)
                add_mixer(spec, spec->kctls.list);
@@ -5004,6 +5129,7 @@ static void alc880_auto_init(struct hda_codec *codec)
        alc880_auto_init_extra_out(codec);
        alc880_auto_init_analog_input(codec);
        alc880_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
        if (spec->unsol_event)
                alc_inithook(codec);
 }
@@ -5041,6 +5167,39 @@ static void fixup_automic_adc(struct hda_codec *codec)
        spec->auto_mic = 0; /* disable auto-mic to be sure */
 }
+/* select or unmute the given capsrc route */
+static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
+                                    int idx)
+{
+        if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
+                snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
+                                         HDA_AMP_MUTE, 0);
+        } else {
+                snd_hda_codec_write_cache(codec, cap, 0,
+                                          AC_VERB_SET_CONNECT_SEL, idx);
+        }
+}
+/* set the default connection to that pin */
+static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
+{
+        struct alc_spec *spec = codec->spec;
+        int i;
+        for (i = 0; i < spec->num_adc_nids; i++) {
+                hda_nid_t cap = spec->capsrc_nids ?
+                        spec->capsrc_nids[i] : spec->adc_nids[i];
+                int idx;
+                idx = get_connection_index(codec, cap, pin);
+                if (idx < 0)
+                        continue;
+                select_or_unmute_capsrc(codec, cap, idx);
+                return i; /* return the found index */
+        }
+        return -1; /* not found */
+}
 /* choose the ADC/MUX containing the input pin and initialize the setup */
 static void fixup_single_adc(struct hda_codec *codec)
 {
@@ -5057,33 +5216,24 @@ static void fixup_single_adc(struct hda_codec *codec)
        }
        if (!pin)
                return;
+        i = init_capsrc_for_pin(codec, pin);
-        /* set the default connection to that pin */
+        if (i >= 0) {
-        for (i = 0; i < spec->num_adc_nids; i++) {
-                hda_nid_t cap = spec->capsrc_nids ?
-                        spec->capsrc_nids[i] : spec->adc_nids[i];
-                int idx;
-                idx = get_connection_index(codec, cap, pin);
-                if (idx < 0)
-                        continue;
                /* use only this ADC */
                if (spec->capsrc_nids)
                        spec->capsrc_nids += i;
                spec->adc_nids += i;
                spec->num_adc_nids = 1;
-                /* select or unmute this route */
-                if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
-                        snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
-                                                 HDA_AMP_MUTE, 0);
-                } else {
-                        snd_hda_codec_write_cache(codec, cap, 0,
-                                          AC_VERB_SET_CONNECT_SEL, idx);
-                }
-                return;
        }
 }
+/* initialize dual adcs */
+static void fixup_dual_adc_switch(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        init_capsrc_for_pin(codec, spec->ext_mic.pin);
+        init_capsrc_for_pin(codec, spec->int_mic.pin);
+}
 static void set_capture_mixer(struct hda_codec *codec)
 {
        struct alc_spec *spec = codec->spec;
@@ -5097,7 +5247,10 @@ static void set_capture_mixer(struct hda_codec *codec)
        };
        if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
                int mux = 0;
-                if (spec->auto_mic)
+                int num_adcs = spec->num_adc_nids;
+                if (spec->dual_adc_switch)
+                        fixup_dual_adc_switch(codec);
+                else if (spec->auto_mic)
                        fixup_automic_adc(codec);
                else if (spec->input_mux) {
                        if (spec->input_mux->num_items > 1)
@@ -5105,7 +5258,9 @@ static void set_capture_mixer(struct hda_codec *codec)
                        else if (spec->input_mux->num_items == 1)
                                fixup_single_adc(codec);
                }
-                spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
+                if (spec->dual_adc_switch)
+                        num_adcs = 1;
+                spec->cap_mixer = caps[mux][num_adcs - 1];
        }
 }
@@ -5176,8 +5331,25 @@ static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
 #ifdef CONFIG_SND_HDA_INPUT_BEEP
 #define set_beep_amp(spec, nid, idx, dir) \
        ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
+static struct snd_pci_quirk beep_white_list[] = {
+        SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
+        SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
+        {}
+};
+static inline int has_cdefine_beep(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        const struct snd_pci_quirk *q;
+        q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
+        if (q)
+                return q->value;
+        return spec->cdefine.enable_pcbeep;
+}
 #else
 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
+#define has_cdefine_beep(codec)         0
 #endif
 /*
@@ -6604,6 +6776,7 @@ static void alc260_auto_init(struct hda_codec *codec)
        alc260_auto_init_multi_out(codec);
        alc260_auto_init_analog_input(codec);
        alc260_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
        if (spec->unsol_event)
                alc_inithook(codec);
 }
@@ -6620,6 +6793,29 @@ static struct hda_amp_list alc260_loopbacks[] = {
 #endif
 /*
+ * Pin config fixes
+ */
+enum {
+        PINFIX_HP_DC5750,
+};
+static struct alc_pincfg alc260_hp_dc5750_pinfix[] = {
+        { 0x11, 0x90130110 }, /* speaker */
+        { }
+};
+static const struct alc_fixup alc260_fixups[] = {
+        [PINFIX_HP_DC5750] = {
+                .pins = alc260_hp_dc5750_pinfix
+        },
+};
+static struct snd_pci_quirk alc260_fixup_tbl[] = {
+        SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
+        {}
+};
+/*
 * ALC260 configurations
 */
 static const char *alc260_models[ALC260_MODEL_LAST] = {
@@ -6818,6 +7014,9 @@ static int patch_alc260(struct hda_codec *codec)
                board_config = ALC260_AUTO;
        }
+        if (board_config == ALC260_AUTO)
+                alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 1);
        if (board_config == ALC260_AUTO) {
                /* automatic parse from the BIOS config */
                err = alc260_parse_auto_config(codec);
@@ -6843,6 +7042,7 @@ static int patch_alc260(struct hda_codec *codec)
        spec->stream_analog_playback = &alc260_pcm_analog_playback;
        spec->stream_analog_capture = &alc260_pcm_analog_capture;
+        spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
        spec->stream_digital_playback = &alc260_pcm_digital_playback;
        spec->stream_digital_capture = &alc260_pcm_digital_capture;
@@ -6863,6 +7063,9 @@ static int patch_alc260(struct hda_codec *codec)
        set_capture_mixer(codec);
        set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
+        if (board_config == ALC260_AUTO)
+                alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 0);
        spec->vmaster_nid = 0x08;
        codec->patch_ops = alc_patch_ops;
@@ -6948,7 +7151,7 @@ static struct hda_input_mux mb5_capture_source = {
        .num_items = 3,
        .items = {
                { "Mic", 0x1 },
-                { "Line", 0x2 },
+                { "Line", 0x7 },
                { "CD", 0x4 },
        },
 };
@@ -6983,7 +7186,7 @@ static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
        .num_items = 4,
        .items = {
                { "Mic", 0x0 },
-                { "iMic", 0x1 },
+                { "Int Mic", 0x1 },
                { "Line", 0x2 },
                { "CD", 0x4 },
        },
@@ -7469,8 +7672,8 @@ static struct snd_kcontrol_new alc885_mb5_mixer[] = {
        HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
        HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
-        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
-        HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
+        HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
        HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
        HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
@@ -7853,10 +8056,9 @@ static struct hda_verb alc885_mb5_init_verbs[] = {
        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
+        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
-        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
        { }
 };
@@ -8554,8 +8756,8 @@ static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-        HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
        { } /* end */
 };
@@ -9476,11 +9678,16 @@ static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
        SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
        SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
        SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
+        SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
+        SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
+        SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
+        SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
        SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
        SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
        SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
        SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
        SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
+        SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
        /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
         * so apparently no perfect solution yet
         */
@@ -10241,7 +10448,8 @@ static struct alc_config_preset alc882_presets[] = {
 * Pin config fixes
 */
 enum {
-        PINFIX_ABIT_AW9D_MAX
+        PINFIX_ABIT_AW9D_MAX,
+        PINFIX_PB_M5210,
 };
 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
@@ -10251,13 +10459,22 @@ static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
        { }
 };
+static const struct hda_verb pb_m5210_verbs[] = {
+        { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
+        {}
+};
 static const struct alc_fixup alc882_fixups[] = {
        [PINFIX_ABIT_AW9D_MAX] = {
                .pins = alc882_abit_aw9d_pinfix
        },
+        [PINFIX_PB_M5210] = {
+                .verbs = pb_m5210_verbs
+        },
 };
 static struct snd_pci_quirk alc882_fixup_tbl[] = {
+        SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
        SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
        {}
 };
@@ -10422,7 +10639,7 @@ static int alc882_parse_auto_config(struct hda_codec *codec)
 {
        struct alc_spec *spec = codec->spec;
        static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
-        int i, err;
+        int err;
        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
                                           alc882_ignore);
@@ -10452,25 +10669,7 @@ static int alc882_parse_auto_config(struct hda_codec *codec)
        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
-        /* check multiple SPDIF-out (for recent codecs) */
+        alc_auto_parse_digital(codec);
-        for (i = 0; i < spec->autocfg.dig_outs; i++) {
-                hda_nid_t dig_nid;
-                err = snd_hda_get_connections(codec,
-                                              spec->autocfg.dig_out_pins[i],
-                                              &dig_nid, 1);
-                if (err < 0)
-                        continue;
-                if (!i)
-                        spec->multiout.dig_out_nid = dig_nid;
-                else {
-                        spec->multiout.slave_dig_outs = spec->slave_dig_outs;
-                        if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
-                                break;
-                        spec->slave_dig_outs[i - 1] = dig_nid;
-                }
-        }
-        if (spec->autocfg.dig_in_pin)
-                spec->dig_in_nid = ALC880_DIGIN_NID;
        if (spec->kctls.list)
                add_mixer(spec, spec->kctls.list);
@@ -10500,6 +10699,7 @@ static void alc882_auto_init(struct hda_codec *codec)
        alc882_auto_init_hp_out(codec);
        alc882_auto_init_analog_input(codec);
        alc882_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
        if (spec->unsol_event)
                alc_inithook(codec);
 }
@@ -10558,10 +10758,12 @@ static int patch_alc882(struct hda_codec *codec)
                }
        }
-        err = snd_hda_attach_beep_device(codec, 0x1);
+        if (has_cdefine_beep(codec)) {
-        if (err < 0) {
+                err = snd_hda_attach_beep_device(codec, 0x1);
-                alc_free(codec);
+                if (err < 0) {
-                return err;
+                        alc_free(codec);
+                        return err;
+                }
        }
        if (board_config != ALC882_AUTO)
@@ -10611,7 +10813,7 @@ static int patch_alc882(struct hda_codec *codec)
        set_capture_mixer(codec);
-        if (spec->cdefine.enable_pcbeep)
+        if (has_cdefine_beep(codec))
                set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
        if (board_config == ALC882_AUTO)
@@ -12028,12 +12230,7 @@ static int alc262_parse_auto_config(struct hda_codec *codec)
        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 dig_only:
-        if (spec->autocfg.dig_outs) {
+        alc_auto_parse_digital(codec);
-                spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
-                spec->dig_out_type = spec->autocfg.dig_out_type[0];
-        }
-        if (spec->autocfg.dig_in_pin)
-                spec->dig_in_nid = ALC262_DIGIN_NID;
        if (spec->kctls.list)
                add_mixer(spec, spec->kctls.list);
@@ -12065,6 +12262,7 @@ static void alc262_auto_init(struct hda_codec *codec)
        alc262_auto_init_hp_out(codec);
        alc262_auto_init_analog_input(codec);
        alc262_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
        if (spec->unsol_event)
                alc_inithook(codec);
 }
@@ -12427,7 +12625,7 @@ static int patch_alc262(struct hda_codec *codec)
                }
        }
-        if (!spec->no_analog) {
+        if (!spec->no_analog && has_cdefine_beep(codec)) {
                err = snd_hda_attach_beep_device(codec, 0x1);
                if (err < 0) {
                        alc_free(codec);
@@ -12478,7 +12676,7 @@ static int patch_alc262(struct hda_codec *codec)
        }
        if (!spec->cap_mixer && !spec->no_analog)
                set_capture_mixer(codec);
-        if (!spec->no_analog && spec->cdefine.enable_pcbeep)
+        if (!spec->no_analog && has_cdefine_beep(codec))
                set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
        spec->vmaster_nid = 0x0c;
@@ -12998,10 +13196,14 @@ static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
                dac = 0x02;
                break;
        case 0x15:
+        case 0x1a: /* ALC259/269 only */
+        case 0x1b: /* ALC259/269 only */
        case 0x21: /* ALC269vb has this pin, too */
                dac = 0x03;
                break;
        default:
+                snd_printd(KERN_WARNING "hda_codec: "
+                           "ignoring pin 0x%x as unknown\n", nid);
                return 0;
        }
        if (spec->multiout.dac_nids[0] != dac &&
@@ -13052,7 +13254,7 @@ static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
                                  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
                if (err < 0)
                        return err;
-        } else {
+        } else if (nid) {
                err = alc268_new_analog_output(spec, nid, "Speaker", 0);
                if (err < 0)
                        return err;
@@ -13201,10 +13403,7 @@ static int alc268_parse_auto_config(struct hda_codec *codec)
 dig_only:
        /* digital only support output */
-        if (spec->autocfg.dig_outs) {
+        alc_auto_parse_digital(codec);
-                spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
-                spec->dig_out_type = spec->autocfg.dig_out_type[0];
-        }
        if (spec->kctls.list)
                add_mixer(spec, spec->kctls.list);
@@ -13234,6 +13433,7 @@ static void alc268_auto_init(struct hda_codec *codec)
        alc268_auto_init_hp_out(codec);
        alc268_auto_init_mono_speaker_out(codec);
        alc268_auto_init_analog_input(codec);
+        alc_auto_init_digital(codec);
        if (spec->unsol_event)
                alc_inithook(codec);
 }
@@ -13277,7 +13477,6 @@ static struct snd_pci_quirk alc268_cfg_tbl[] = {
        SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
        SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
        SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
-        SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
        {}
 };
@@ -13668,6 +13867,12 @@ static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
        { } /* end */
 };
+static struct snd_kcontrol_new alc269_asus_mixer[] = {
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
+        { } /* end */
+};
 /* capture mixer elements */
 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
@@ -13888,6 +14093,20 @@ static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
        {}
 };
+static struct hda_verb alc271_acer_dmic_verbs[] = {
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
+        {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
+        {0x22, AC_VERB_SET_CONNECT_SEL, 6},
+        { }
+};
 /* toggle speaker-output according to the hp-jack state */
 static void alc269_speaker_automute(struct hda_codec *codec)
 {
@@ -14126,6 +14345,36 @@ static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
 }
 #endif /* CONFIG_SND_HDA_POWER_SAVE */
+static int alc275_setup_dual_adc(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
+                return 0;
+        if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
+            (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
+                if (spec->ext_mic.pin <= 0x12) {
+                        spec->private_adc_nids[0] = 0x08;
+                        spec->private_adc_nids[1] = 0x11;
+                        spec->private_capsrc_nids[0] = 0x23;
+                        spec->private_capsrc_nids[1] = 0x22;
+                } else {
+                        spec->private_adc_nids[0] = 0x11;
+                        spec->private_adc_nids[1] = 0x08;
+                        spec->private_capsrc_nids[0] = 0x22;
+                        spec->private_capsrc_nids[1] = 0x23;
+                }
+                spec->adc_nids = spec->private_adc_nids;
+                spec->capsrc_nids = spec->private_capsrc_nids;
+                spec->num_adc_nids = 2;
+                spec->dual_adc_switch = 1;
+                snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
+                            spec->adc_nids[0], spec->adc_nids[1]);
+                return 1;
+        }
+        return 0;
+}
 /*
 * BIOS auto configuration
 */
@@ -14149,8 +14398,7 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
-        if (spec->autocfg.dig_outs)
+        alc_auto_parse_digital(codec);
-                spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
        if (spec->kctls.list)
                add_mixer(spec, spec->kctls.list);
@@ -14165,13 +14413,15 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
        spec->num_mux_defs = 1;
        spec->input_mux = &spec->private_imux[0];
-        fillup_priv_adc_nids(codec, alc269_adc_candidates,
-                             sizeof(alc269_adc_candidates));
+        if (!alc275_setup_dual_adc(codec))
+                fillup_priv_adc_nids(codec, alc269_adc_candidates,
+                                     sizeof(alc269_adc_candidates));
        /* set default input source */
-        snd_hda_codec_write_cache(codec, spec->capsrc_nids[0],
+        if (!spec->dual_adc_switch)
-                                  0, AC_VERB_SET_CONNECT_SEL,
+                select_or_unmute_capsrc(codec, spec->capsrc_nids[0],
-                                  spec->input_mux->items[0].index);
+                                        spec->input_mux->items[0].index);
        err = alc_auto_add_mic_boost(codec);
        if (err < 0)
@@ -14195,6 +14445,7 @@ static void alc269_auto_init(struct hda_codec *codec)
        alc269_auto_init_multi_out(codec);
        alc269_auto_init_hp_out(codec);
        alc269_auto_init_analog_input(codec);
+        alc_auto_init_digital(codec);
        if (spec->unsol_event)
                alc_inithook(codec);
 }
@@ -14235,6 +14486,7 @@ static const char *alc269_models[ALC269_MODEL_LAST] = {
 static struct snd_pci_quirk alc269_cfg_tbl[] = {
        SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
+        SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
        SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
                      ALC269_AMIC),
        SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
@@ -14396,6 +14648,23 @@ static struct alc_config_preset alc269_presets[] = {
                .unsol_event = alc269_lifebook_unsol_event,
                .init_hook = alc269_lifebook_init_hook,
        },
+        [ALC271_ACER] = {
+                .mixers = { alc269_asus_mixer },
+                .cap_mixer = alc269vb_laptop_digital_capture_mixer,
+                .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
+                .num_dacs = ARRAY_SIZE(alc269_dac_nids),
+                .dac_nids = alc269_dac_nids,
+                .adc_nids = alc262_dmic_adc_nids,
+                .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
+                .capsrc_nids = alc262_dmic_capsrc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc269_modes),
+                .channel_mode = alc269_modes,
+                .input_mux = &alc269_capture_source,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .unsol_event = alc_sku_unsol_event,
+                .setup = alc269vb_laptop_dmic_setup,
+                .init_hook = alc_inithook,
+        },
 };
 static int patch_alc269(struct hda_codec *codec)
@@ -14450,10 +14719,12 @@ static int patch_alc269(struct hda_codec *codec)
                }
        }
-        err = snd_hda_attach_beep_device(codec, 0x1);
+        if (has_cdefine_beep(codec)) {
-        if (err < 0) {
+                err = snd_hda_attach_beep_device(codec, 0x1);
-                alc_free(codec);
+                if (err < 0) {
-                return err;
+                        alc_free(codec);
+                        return err;
+                }
        }
        if (board_config != ALC269_AUTO)
@@ -14465,6 +14736,10 @@ static int patch_alc269(struct hda_codec *codec)
                 */
                spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
                spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
+        } else if (spec->dual_adc_switch) {
+                spec->stream_analog_playback = &alc269_pcm_analog_playback;
+                /* switch ADC dynamically */
+                spec->stream_analog_capture = &dualmic_pcm_analog_capture;
        } else {
                spec->stream_analog_playback = &alc269_pcm_analog_playback;
                spec->stream_analog_capture = &alc269_pcm_analog_capture;
@@ -14486,7 +14761,7 @@ static int patch_alc269(struct hda_codec *codec)
        if (!spec->cap_mixer)
                set_capture_mixer(codec);
-        if (spec->cdefine.enable_pcbeep)
+        if (has_cdefine_beep(codec))
                set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
        if (board_config == ALC269_AUTO)
@@ -15350,8 +15625,7 @@ static int alc861_parse_auto_config(struct hda_codec *codec)
        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
-        if (spec->autocfg.dig_outs)
+        alc_auto_parse_digital(codec);
-                spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
        if (spec->kctls.list)
                add_mixer(spec, spec->kctls.list);
@@ -15377,6 +15651,7 @@ static void alc861_auto_init(struct hda_codec *codec)
        alc861_auto_init_multi_out(codec);
        alc861_auto_init_hp_out(codec);
        alc861_auto_init_analog_input(codec);
+        alc_auto_init_digital(codec);
        if (spec->unsol_event)
                alc_inithook(codec);
 }
@@ -16481,8 +16756,7 @@ static int alc861vd_parse_auto_config(struct hda_codec *codec)
        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
-        if (spec->autocfg.dig_outs)
+        alc_auto_parse_digital(codec);
-                spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
        if (spec->kctls.list)
                add_mixer(spec, spec->kctls.list);
@@ -16509,6 +16783,7 @@ static void alc861vd_auto_init(struct hda_codec *codec)
        alc861vd_auto_init_hp_out(codec);
        alc861vd_auto_init_analog_input(codec);
        alc861vd_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
        if (spec->unsol_event)
                alc_inithook(codec);
 }
@@ -18492,7 +18767,7 @@ static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
                                              hda_nid_t dac)
 {
        int i, num;
-        hda_nid_t srcs[4];
+        hda_nid_t srcs[HDA_MAX_CONNECTIONS];
        alc_set_pin_output(codec, nid, pin_type);
        /* need the manual connection? */
@@ -18596,8 +18871,7 @@ static int alc662_parse_auto_config(struct hda_codec *codec)
        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
-        if (spec->autocfg.dig_outs)
+        alc_auto_parse_digital(codec);
-                spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
        if (spec->kctls.list)
                add_mixer(spec, spec->kctls.list);
@@ -18607,7 +18881,7 @@ static int alc662_parse_auto_config(struct hda_codec *codec)
        add_verb(spec, alc662_init_verbs);
        if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
-            codec->vendor_id == 0x10ec0665)
+            codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
                add_verb(spec, alc663_init_verbs);
        if (codec->vendor_id == 0x10ec0272)
@@ -18634,6 +18908,7 @@ static void alc662_auto_init(struct hda_codec *codec)
        alc662_auto_init_hp_out(codec);
        alc662_auto_init_analog_input(codec);
        alc662_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
        if (spec->unsol_event)
                alc_inithook(codec);
 }
@@ -18683,10 +18958,12 @@ static int patch_alc662(struct hda_codec *codec)
                }
        }
-        err = snd_hda_attach_beep_device(codec, 0x1);
+        if (has_cdefine_beep(codec)) {
-        if (err < 0) {
+                err = snd_hda_attach_beep_device(codec, 0x1);
-                alc_free(codec);
+                if (err < 0) {
-                return err;
+                        alc_free(codec);
+                        return err;
+                }
        }
        if (board_config != ALC662_AUTO)
@@ -18708,7 +18985,7 @@ static int patch_alc662(struct hda_codec *codec)
        if (!spec->cap_mixer)
                set_capture_mixer(codec);
-        if (spec->cdefine.enable_pcbeep) {
+        if (has_cdefine_beep(codec)) {
                switch (codec->vendor_id) {
                case 0x10ec0662:
                        set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
@@ -18751,6 +19028,333 @@ static int patch_alc888(struct hda_codec *codec)
 }
 /*
+ * ALC680 support
+ */
+#define ALC680_DIGOUT_NID       ALC880_DIGOUT_NID
+#define alc680_modes            alc260_modes
+static hda_nid_t alc680_dac_nids[3] = {
+        /* Lout1, Lout2, hp */
+        0x02, 0x03, 0x04
+};
+static hda_nid_t alc680_adc_nids[3] = {
+        /* ADC0-2 */
+        /* DMIC, MIC, Line-in*/
+        0x07, 0x08, 0x09
+};
+static struct snd_kcontrol_new alc680_base_mixer[] = {
+        /* output mixer control */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        { }
+};
+static struct snd_kcontrol_new alc680_capture_mixer[] = {
+        HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
+        HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
+        { } /* end */
+};
+/*
+ * generic initialization of ADC, input mixers and output mixers
+ */
+static struct hda_verb alc680_init_verbs[] = {
+        /* Unmute DAC0-1 and set vol = 0 */
+        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        { }
+};
+/* create input playback/capture controls for the given pin */
+static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
+                                    const char *ctlname, int idx)
+{
+        hda_nid_t dac;
+        int err;
+        switch (nid) {
+        case 0x14:
+                dac = 0x02;
+                break;
+        case 0x15:
+                dac = 0x03;
+                break;
+        case 0x16:
+                dac = 0x04;
+                break;
+        default:
+                return 0;
+        }
+        if (spec->multiout.dac_nids[0] != dac &&
+            spec->multiout.dac_nids[1] != dac) {
+                err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
+                                  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
+                                                      HDA_OUTPUT));
+                if (err < 0)
+                        return err;
+                err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
+                          HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
+                if (err < 0)
+                        return err;
+                spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
+        }
+        return 0;
+}
+/* add playback controls from the parsed DAC table */
+static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
+                                             const struct auto_pin_cfg *cfg)
+{
+        hda_nid_t nid;
+        int err;
+        spec->multiout.dac_nids = spec->private_dac_nids;
+        nid = cfg->line_out_pins[0];
+        if (nid) {
+                const char *name;
+                if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
+                        name = "Speaker";
+                else
+                        name = "Front";
+                err = alc680_new_analog_output(spec, nid, name, 0);
+                if (err < 0)
+                        return err;
+        }
+        nid = cfg->speaker_pins[0];
+        if (nid) {
+                err = alc680_new_analog_output(spec, nid, "Speaker", 0);
+                if (err < 0)
+                        return err;
+        }
+        nid = cfg->hp_pins[0];
+        if (nid) {
+                err = alc680_new_analog_output(spec, nid, "Headphone", 0);
+                if (err < 0)
+                        return err;
+        }
+        return 0;
+}
+static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
+                                              hda_nid_t nid, int pin_type)
+{
+        alc_set_pin_output(codec, nid, pin_type);
+}
+static void alc680_auto_init_multi_out(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t nid = spec->autocfg.line_out_pins[0];
+        if (nid) {
+                int pin_type = get_pin_type(spec->autocfg.line_out_type);
+                alc680_auto_set_output_and_unmute(codec, nid, pin_type);
+        }
+}
+static void alc680_auto_init_hp_out(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t pin;
+        pin = spec->autocfg.hp_pins[0];
+        if (pin)
+                alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
+        pin = spec->autocfg.speaker_pins[0];
+        if (pin)
+                alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
+}
+/* pcm configuration: identical with ALC880 */
+#define alc680_pcm_analog_playback      alc880_pcm_analog_playback
+#define alc680_pcm_analog_capture       alc880_pcm_analog_capture
+#define alc680_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
+#define alc680_pcm_digital_playback     alc880_pcm_digital_playback
+static struct hda_input_mux alc680_capture_source = {
+        .num_items = 1,
+        .items = {
+                { "Mic", 0x0 },
+        },
+};
+/*
+ * BIOS auto configuration
+ */
+static int alc680_parse_auto_config(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        int err;
+        static hda_nid_t alc680_ignore[] = { 0 };
+        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
+                                           alc680_ignore);
+        if (err < 0)
+                return err;
+        if (!spec->autocfg.line_outs) {
+                if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
+                        spec->multiout.max_channels = 2;
+                        spec->no_analog = 1;
+                        goto dig_only;
+                }
+                return 0; /* can't find valid BIOS pin config */
+        }
+        err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+        spec->multiout.max_channels = 2;
+ dig_only:
+        /* digital only support output */
+        alc_auto_parse_digital(codec);
+        if (spec->kctls.list)
+                add_mixer(spec, spec->kctls.list);
+        add_verb(spec, alc680_init_verbs);
+        spec->num_mux_defs = 1;
+        spec->input_mux = &alc680_capture_source;
+        err = alc_auto_add_mic_boost(codec);
+        if (err < 0)
+                return err;
+        return 1;
+}
+#define alc680_auto_init_analog_input   alc882_auto_init_analog_input
+/* init callback for auto-configuration model -- overriding the default init */
+static void alc680_auto_init(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        alc680_auto_init_multi_out(codec);
+        alc680_auto_init_hp_out(codec);
+        alc680_auto_init_analog_input(codec);
+        alc_auto_init_digital(codec);
+        if (spec->unsol_event)
+                alc_inithook(codec);
+}
+/*
+ * configuration and preset
+ */
+static const char *alc680_models[ALC680_MODEL_LAST] = {
+        [ALC680_BASE]           = "base",
+        [ALC680_AUTO]           = "auto",
+};
+static struct snd_pci_quirk alc680_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
+        {}
+};
+static struct alc_config_preset alc680_presets[] = {
+        [ALC680_BASE] = {
+                .mixers = { alc680_base_mixer },
+                .cap_mixer =  alc680_capture_mixer,
+                .init_verbs = { alc680_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc680_dac_nids),
+                .dac_nids = alc680_dac_nids,
+                .num_adc_nids = ARRAY_SIZE(alc680_adc_nids),
+                .adc_nids = alc680_adc_nids,
+                .hp_nid = 0x04,
+                .dig_out_nid = ALC680_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc680_modes),
+                .channel_mode = alc680_modes,
+                .input_mux = &alc680_capture_source,
+        },
+};
+static int patch_alc680(struct hda_codec *codec)
+{
+        struct alc_spec *spec;
+        int board_config;
+        int err;
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+        codec->spec = spec;
+        board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
+                                                  alc680_models,
+                                                  alc680_cfg_tbl);
+        if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
+                board_config = ALC680_AUTO;
+        }
+        if (board_config == ALC680_AUTO) {
+                /* automatic parse from the BIOS config */
+                err = alc680_parse_auto_config(codec);
+                if (err < 0) {
+                        alc_free(codec);
+                        return err;
+                } else if (!err) {
+                        printk(KERN_INFO
+                               "hda_codec: Cannot set up configuration "
+                               "from BIOS.  Using base mode...\n");
+                        board_config = ALC680_BASE;
+                }
+        }
+        if (board_config != ALC680_AUTO)
+                setup_preset(codec, &alc680_presets[board_config]);
+        spec->stream_analog_playback = &alc680_pcm_analog_playback;
+        spec->stream_analog_capture = &alc680_pcm_analog_capture;
+        spec->stream_analog_alt_capture = &alc680_pcm_analog_alt_capture;
+        spec->stream_digital_playback = &alc680_pcm_digital_playback;
+        if (!spec->adc_nids) {
+                spec->adc_nids = alc680_adc_nids;
+                spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
+        }
+        if (!spec->cap_mixer)
+                set_capture_mixer(codec);
+        spec->vmaster_nid = 0x02;
+        codec->patch_ops = alc_patch_ops;
+        if (board_config == ALC680_AUTO)
+                spec->init_hook = alc680_auto_init;
+        return 0;
+}
+/*
 * patch entries
 */
 static struct hda_codec_preset snd_hda_preset_realtek[] = {
@@ -18774,6 +19378,7 @@ static struct hda_codec_preset snd_hda_preset_realtek[] = {
        { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
        { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
        { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
+        { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
        { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
        { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
        { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index f1e7babd6920..f3f861bd1bf8 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -94,6 +94,7 @@ enum {
        STAC_92HD83XXX_PWR_REF,
        STAC_DELL_S14,
        STAC_92HD83XXX_HP,
+        STAC_HP_DV7_4000,
        STAC_92HD83XXX_MODELS
 };
@@ -202,6 +203,7 @@ struct sigmatel_spec {
        unsigned int spdif_mute: 1;
        unsigned int check_volume_offset:1;
        unsigned int auto_mic:1;
+        unsigned int linear_tone_beep:1;
        /* gpio lines */
        unsigned int eapd_mask;
@@ -1631,10 +1633,17 @@ static unsigned int dell_s14_pin_configs[10] = {
        0x40f000f0, 0x40f000f0,
 };
+static unsigned int hp_dv7_4000_pin_configs[10] = {
+        0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110,
+        0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140,
+        0x40f000f0, 0x40f000f0,
+};
 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
        [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
        [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
        [STAC_DELL_S14] = dell_s14_pin_configs,
+        [STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs,
 };
 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
@@ -1643,6 +1652,7 @@ static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
        [STAC_92HD83XXX_PWR_REF] = "mic-ref",
        [STAC_DELL_S14] = "dell-s14",
        [STAC_92HD83XXX_HP] = "hp",
+        [STAC_HP_DV7_4000] = "hp-dv7-4000",
 };
 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
@@ -3802,7 +3812,7 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                        return err;
                if (codec->beep) {
                        /* IDT/STAC codecs have linear beep tone parameter */
-                        codec->beep->linear_tone = 1;
+                        codec->beep->linear_tone = spec->linear_tone_beep;
                        /* if no beep switch is available, make its own one */
                        caps = query_amp_caps(codec, nid, HDA_OUTPUT);
                        if (!(caps & AC_AMPCAP_MUTE)) {
@@ -5005,6 +5015,7 @@ static int patch_stac9200(struct hda_codec *codec)
        codec->no_trigger_sense = 1;
        codec->spec = spec;
+        spec->linear_tone_beep = 1;
        spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
        spec->pin_nids = stac9200_pin_nids;
        spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
@@ -5068,6 +5079,7 @@ static int patch_stac925x(struct hda_codec *codec)
        codec->no_trigger_sense = 1;
        codec->spec = spec;
+        spec->linear_tone_beep = 1;
        spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
        spec->pin_nids = stac925x_pin_nids;
@@ -5153,6 +5165,7 @@ static int patch_stac92hd73xx(struct hda_codec *codec)
        codec->no_trigger_sense = 1;
        codec->spec = spec;
+        spec->linear_tone_beep = 0;
        codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
        spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
        spec->pin_nids = stac92hd73xx_pin_nids;
@@ -5300,6 +5313,7 @@ static int patch_stac92hd83xxx(struct hda_codec *codec)
        codec->no_trigger_sense = 1;
        codec->spec = spec;
+        spec->linear_tone_beep = 1;
        codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
        spec->digbeep_nid = 0x21;
        spec->mux_nids = stac92hd83xxx_mux_nids;
@@ -5335,6 +5349,8 @@ again:
        case 0x111d7667:
        case 0x111d7668:
        case 0x111d7669:
+        case 0x111d76d1:
+        case 0x111d76d9:
                spec->num_pins = ARRAY_SIZE(stac92hd88xxx_pin_nids);
                spec->pin_nids = stac92hd88xxx_pin_nids;
                spec->mono_nid = 0;
@@ -5522,6 +5538,7 @@ static int patch_stac92hd71bxx(struct hda_codec *codec)
        codec->no_trigger_sense = 1;
        codec->spec = spec;
+        spec->linear_tone_beep = 0;
        codec->patch_ops = stac92xx_patch_ops;
        spec->num_pins = STAC92HD71BXX_NUM_PINS;
        switch (codec->vendor_id) {
@@ -5779,6 +5796,7 @@ static int patch_stac922x(struct hda_codec *codec)
        codec->no_trigger_sense = 1;
        codec->spec = spec;
+        spec->linear_tone_beep = 1;
        spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
        spec->pin_nids = stac922x_pin_nids;
        spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
@@ -5883,6 +5901,7 @@ static int patch_stac927x(struct hda_codec *codec)
        codec->no_trigger_sense = 1;
        codec->spec = spec;
+        spec->linear_tone_beep = 1;
        codec->slave_dig_outs = stac927x_slave_dig_outs;
        spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
        spec->pin_nids = stac927x_pin_nids;
@@ -6018,6 +6037,7 @@ static int patch_stac9205(struct hda_codec *codec)
        codec->no_trigger_sense = 1;
        codec->spec = spec;
+        spec->linear_tone_beep = 1;
        spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
        spec->pin_nids = stac9205_pin_nids;
        spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
@@ -6174,6 +6194,7 @@ static int patch_stac9872(struct hda_codec *codec)
                return -ENOMEM;
        codec->no_trigger_sense = 1;
        codec->spec = spec;
+        spec->linear_tone_beep = 1;
        spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
        spec->pin_nids = stac9872_pin_nids;
@@ -6264,6 +6285,8 @@ static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
        { .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx},
        { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
        { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
+        { .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx},
+        { .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx},
        { .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx},
        { .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx},
        { .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx},
diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c
index 73453814e098..ae3acb2b42d1 100644
--- a/sound/pci/hda/patch_via.c
+++ b/sound/pci/hda/patch_via.c
@@ -552,24 +552,30 @@ static void via_auto_init_hp_out(struct hda_codec *codec)
        }
 }
+static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin);
 static void via_auto_init_analog_input(struct hda_codec *codec)
 {
        struct via_spec *spec = codec->spec;
+        unsigned int ctl;
        int i;
        for (i = 0; i < AUTO_PIN_LAST; i++) {
                hda_nid_t nid = spec->autocfg.input_pins[i];
+                if (!nid)
+                        continue;
+                if (spec->smart51_enabled && is_smart51_pins(spec, nid))
+                        ctl = PIN_OUT;
+                else if (i <= AUTO_PIN_FRONT_MIC)
+                        ctl = PIN_VREF50;
+                else
+                        ctl = PIN_IN;
                snd_hda_codec_write(codec, nid, 0,
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
-                                    (i <= AUTO_PIN_FRONT_MIC ?
-                                     PIN_VREF50 : PIN_IN));
        }
 }
-static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin);
 static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
                                unsigned int *affected_parm)
 {
@@ -658,6 +664,8 @@ static void set_jack_power_state(struct hda_codec *codec)
                /* PW0 (19h), SW1 (18h), AOW1 (11h) */
                parm = AC_PWRST_D3;
                set_pin_power_state(codec, 0x19, &parm);
+                if (spec->smart51_enabled)
+                        parm = AC_PWRST_D0;
                snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE,
                                    parm);
                snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE,
@@ -667,6 +675,8 @@ static void set_jack_power_state(struct hda_codec *codec)
                if (is_8ch) {
                        parm = AC_PWRST_D3;
                        set_pin_power_state(codec, 0x22, &parm);
+                        if (spec->smart51_enabled)
+                                parm = AC_PWRST_D0;
                        snd_hda_codec_write(codec, 0x26, 0,
                                            AC_VERB_SET_POWER_STATE, parm);
                        snd_hda_codec_write(codec, 0x24, 0,
@@ -3915,6 +3925,13 @@ static int vt1708S_auto_fill_dac_nids(struct via_spec *spec,
                }
        }
+        /* for Smart 5.1, line/mic inputs double as output pins */
+        if (cfg->line_outs == 1) {
+                spec->multiout.num_dacs = 3;
+                spec->multiout.dac_nids[AUTO_SEQ_SURROUND] = 0x11;
+                spec->multiout.dac_nids[AUTO_SEQ_CENLFE] = 0x24;
+        }
        return 0;
 }
@@ -3932,7 +3949,8 @@ static int vt1708S_auto_create_multi_out_ctls(struct via_spec *spec,
        for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
                nid = cfg->line_out_pins[i];
-                if (!nid)
+                /* for Smart 5.1, there are always at least six channels */
+                if (!nid && i > AUTO_SEQ_CENLFE)
                        continue;
                nid_vol = nid_vols[i];
diff --git a/sound/pci/riptide/riptide.c b/sound/pci/riptide/riptide.c
index ad4462677615..f64fb7d988cb 100644
--- a/sound/pci/riptide/riptide.c
+++ b/sound/pci/riptide/riptide.c
@@ -97,6 +97,7 @@
 #include <linux/gameport.h>
 #include <linux/device.h>
 #include <linux/firmware.h>
+#include <linux/kernel.h>
 #include <asm/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
@@ -667,13 +668,12 @@ static u32 atoh(const unsigned char *in, unsigned int len)
        unsigned char c;
        while (len) {
+                int value;
                c = in[len - 1];
-                if ((c >= '0') && (c <= '9'))
+                value = hex_to_bin(c);
-                        sum += mult * (c - '0');
+                if (value >= 0)
-                else if ((c >= 'A') && (c <= 'F'))
+                        sum += mult * value;
-                        sum += mult * (c - ('A' - 10));
-                else if ((c >= 'a') && (c <= 'f'))
-                        sum += mult * (c - ('a' - 10));
                mult *= 16;
                --len;
        }
@@ -1615,7 +1615,10 @@ static int snd_riptide_playback_open(struct snd_pcm_substream *substream)
        chip->playback_substream[sub_num] = substream;
        runtime->hw = snd_riptide_playback;
        data = kzalloc(sizeof(struct pcmhw), GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
        data->paths = lbus_play_paths[sub_num];
        data->id = play_ids[sub_num];
        data->source = play_sources[sub_num];
@@ -1635,7 +1638,10 @@ static int snd_riptide_capture_open(struct snd_pcm_substream *substream)
        chip->capture_substream = substream;
        runtime->hw = snd_riptide_capture;
        data = kzalloc(sizeof(struct pcmhw), GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
        data->paths = lbus_rec_path;
        data->id = PADC;
        data->source = ACLNK2PADC;
diff --git a/sound/pci/sis7019.c b/sound/pci/sis7019.c
index 9cc1b5aa0148..1b8f6742b5fa 100644
--- a/sound/pci/sis7019.c
+++ b/sound/pci/sis7019.c
@@ -264,11 +264,13 @@ static void sis_update_voice(struct voice *voice)
                 * if using small periods.
                 *
                 * If we're less than 9 samples behind, we're on target.
+                 * Otherwise, shorten the next vperiod by the amount we've
+                 * been delayed.
                 */
                if (sync > -9)
                        voice->vperiod = voice->sync_period_size + 1;
                else
-                        voice->vperiod = voice->sync_period_size - 4;
+                        voice->vperiod = voice->sync_period_size + sync + 10;
                if (voice->vperiod < voice->buffer_size) {
                        sis_update_sso(voice, voice->vperiod);
@@ -736,7 +738,7 @@ static void sis_prepare_timing_voice(struct voice *voice,
        period_size = buffer_size;
        /* Initially, we want to interrupt just a bit behind the end of
-         * the period we're clocking out. 10 samples seems to give a good
+         * the period we're clocking out. 12 samples seems to give a good
         * delay.
         *
         * We want to spread our interrupts throughout the virtual period,
@@ -747,7 +749,7 @@ static void sis_prepare_timing_voice(struct voice *voice,
         *
         * This is all moot if we don't need to use virtual periods.
         */
-        vperiod = runtime->period_size + 10;
+        vperiod = runtime->period_size + 12;
        if (vperiod > period_size) {
                u16 tail = vperiod % period_size;
                u16 quarter_period = period_size / 4;
@@ -776,7 +778,7 @@ static void sis_prepare_timing_voice(struct voice *voice,
         */
        timing->flags |= VOICE_SYNC_TIMING;
        timing->sync_base = voice->ctrl_base;
-        timing->sync_cso = runtime->period_size - 1;
+        timing->sync_cso = runtime->period_size;
        timing->sync_period_size = runtime->period_size;
        timing->sync_buffer_size = runtime->buffer_size;
        timing->period_size = period_size;
@@ -1047,7 +1049,7 @@ static int sis_chip_free(struct sis7019 *sis)
        /* Reset the chip, and disable all interrputs.
         */
        outl(SIS_GCR_SOFTWARE_RESET, sis->ioport + SIS_GCR);
-        udelay(10);
+        udelay(25);
        outl(0, sis->ioport + SIS_GCR);
        outl(0, sis->ioport + SIS_GIER);
@@ -1083,7 +1085,7 @@ static int sis_chip_init(struct sis7019 *sis)
        /* Reset the audio controller
         */
        outl(SIS_GCR_SOFTWARE_RESET, io + SIS_GCR);
-        udelay(10);
+        udelay(25);
        outl(0, io + SIS_GCR);
        /* Get the AC-link semaphore, and reset the codecs
@@ -1096,7 +1098,7 @@ static int sis_chip_init(struct sis7019 *sis)
                return -EIO;
        outl(SIS_AC97_CMD_CODEC_COLD_RESET, io + SIS_AC97_CMD);
-        udelay(10);
+        udelay(250);
        count = 0xffff;
        while ((inw(io + SIS_AC97_STATUS) & SIS_AC97_STATUS_BUSY) && --count)
diff --git a/sound/pci/trident/trident_main.c b/sound/pci/trident/trident_main.c
index 6d943f6f6b70..2870a4fdc130 100644
--- a/sound/pci/trident/trident_main.c
+++ b/sound/pci/trident/trident_main.c
@@ -1055,7 +1055,7 @@ static int snd_trident_capture_prepare(struct snd_pcm_substream *substream)
        spin_lock_irq(&trident->reg_lock);
-        // Initilize the channel and set channel Mode
+        // Initialize the channel and set channel Mode
        outb(0, TRID_REG(trident, LEGACY_DMAR15));
        // Set DMA channel operation mode register
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index 7e494b6a1d0e..8c5f8b5a59f0 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -85,6 +85,7 @@ static int joystick;
 static int ac97_clock = 48000;
 static char *ac97_quirk;
 static int dxs_support;
+static int dxs_init_volume = 31;
 static int nodelay;
 module_param(index, int, 0444);
@@ -103,6 +104,8 @@ module_param(ac97_quirk, charp, 0444);
 MODULE_PARM_DESC(ac97_quirk, "AC'97 workaround for strange hardware.");
 module_param(dxs_support, int, 0444);
 MODULE_PARM_DESC(dxs_support, "Support for DXS channels (0 = auto, 1 = enable, 2 = disable, 3 = 48k only, 4 = no VRA, 5 = enable any sample rate)");
+module_param(dxs_init_volume, int, 0644);
+MODULE_PARM_DESC(dxs_init_volume, "initial DXS volume (0-31)");
 module_param(nodelay, int, 0444);
 MODULE_PARM_DESC(nodelay, "Disable 500ms init delay");
@@ -1245,8 +1248,10 @@ static int snd_via8233_playback_open(struct snd_pcm_substream *substream)
                return err;
        stream = viadev->reg_offset / 0x10;
        if (chip->dxs_controls[stream]) {
-                chip->playback_volume[stream][0] = 0;
+                chip->playback_volume[stream][0] =
-                chip->playback_volume[stream][1] = 0;
+                                VIA_DXS_MAX_VOLUME - (dxs_init_volume & 31);
+                chip->playback_volume[stream][1] =
+                                VIA_DXS_MAX_VOLUME - (dxs_init_volume & 31);
                chip->dxs_controls[stream]->vd[0].access &=
                        ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
                snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE |
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf.c b/sound/pcmcia/pdaudiocf/pdaudiocf.c
index df110df52a8b..7ab9174a8a84 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf.c
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf.c
@@ -139,8 +139,8 @@ static int snd_pdacf_probe(struct pcmcia_device *link)
        pdacf->p_dev = link;
        link->priv = pdacf;
-        link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
+        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-        link->io.NumPorts1 = 16;
+        link->resource[0]->end = 16;
        link->conf.Attributes = CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ;
        link->conf.IntType = INT_MEMORY_AND_IO;
@@ -219,7 +219,7 @@ static int pdacf_config(struct pcmcia_device *link)
        snd_printdd(KERN_DEBUG "pdacf_config called\n");
        link->conf.ConfigIndex = 0x5;
-        ret = pcmcia_request_io(link, &link->io);
+        ret = pcmcia_request_io(link);
        if (ret)
                goto failed;
@@ -231,7 +231,8 @@ static int pdacf_config(struct pcmcia_device *link)
        if (ret)
                goto failed;
-        if (snd_pdacf_assign_resources(pdacf, link->io.BasePort1, link->irq) < 0)
+        if (snd_pdacf_assign_resources(pdacf, link->resource[0]->start,
+                                        link->irq) < 0)
                goto failed;
        return 0;
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf.h b/sound/pcmcia/pdaudiocf/pdaudiocf.h
index a0a7ec64222a..5cc3e4573074 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf.h
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf.h
@@ -24,7 +24,6 @@
 #include <sound/pcm.h>
 #include <asm/io.h>
 #include <linux/interrupt.h>
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
diff --git a/sound/pcmcia/vx/vxpocket.c b/sound/pcmcia/vx/vxpocket.c
index 624b47a85f0a..a6edfc3be29a 100644
--- a/sound/pcmcia/vx/vxpocket.c
+++ b/sound/pcmcia/vx/vxpocket.c
@@ -159,8 +159,8 @@ static int snd_vxpocket_new(struct snd_card *card, int ibl,
        vxp->p_dev = link;
        link->priv = chip;
-        link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
+        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-        link->io.NumPorts1 = 16;
+        link->resource[0]->end = 16;
        link->conf.Attributes = CONF_ENABLE_IRQ;
        link->conf.IntType = INT_MEMORY_AND_IO;
@@ -226,7 +226,7 @@ static int vxpocket_config(struct pcmcia_device *link)
                strcpy(chip->card->driver, vxp440_hw.name);
        }
-        ret = pcmcia_request_io(link, &link->io);
+        ret = pcmcia_request_io(link);
        if (ret)
                goto failed;
@@ -241,7 +241,8 @@ static int vxpocket_config(struct pcmcia_device *link)
        chip->dev = &link->dev;
        snd_card_set_dev(chip->card, chip->dev);
-        if (snd_vxpocket_assign_resources(chip, link->io.BasePort1, link->irq) < 0)
+        if (snd_vxpocket_assign_resources(chip, link->resource[0]->start,
+                                                link->irq) < 0)
                goto failed;
        return 0;
diff --git a/sound/pcmcia/vx/vxpocket.h b/sound/pcmcia/vx/vxpocket.h
index ea4df16a28ef..d9110669d042 100644
--- a/sound/pcmcia/vx/vxpocket.h
+++ b/sound/pcmcia/vx/vxpocket.h
@@ -23,7 +23,6 @@
 #include <sound/vx_core.h>
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
diff --git a/sound/soc/codecs/wm8776.c b/sound/soc/codecs/wm8776.c
index 053030679c1a..05d98dd26072 100644
--- a/sound/soc/codecs/wm8776.c
+++ b/sound/soc/codecs/wm8776.c
@@ -171,13 +171,6 @@ static int wm8776_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
        case SND_SOC_DAIFMT_LEFT_J:
                iface |= 0x0001;
                break;
-                /* FIXME: CHECK A/B */
-        case SND_SOC_DAIFMT_DSP_A:
-                iface |= 0x0003;
-                break;
-        case SND_SOC_DAIFMT_DSP_B:
-                iface |= 0x0007;
-                break;
        default:
                return -EINVAL;
        }
diff --git a/sound/soc/fsl/mpc5200_dma.h b/sound/soc/fsl/mpc5200_dma.h
index 7472531bc2a4..a3c0cd5382fb 100644
--- a/sound/soc/fsl/mpc5200_dma.h
+++ b/sound/soc/fsl/mpc5200_dma.h
@@ -73,7 +73,7 @@ struct psc_dma {
 };
 /* Utility for retrieving psc_dma_stream structure from a substream */
-inline struct psc_dma_stream *
+static inline struct psc_dma_stream *
 to_psc_dma_stream(struct snd_pcm_substream *substream, struct psc_dma *psc_dma)
 {
        if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
diff --git a/sound/soc/fsl/mpc5200_psc_ac97.c b/sound/soc/fsl/mpc5200_psc_ac97.c
index 11706c128c08..40acc8e2b1ca 100644
--- a/sound/soc/fsl/mpc5200_psc_ac97.c
+++ b/sound/soc/fsl/mpc5200_psc_ac97.c
@@ -20,6 +20,7 @@
 #include <asm/time.h>
 #include <asm/delay.h>
+#include <asm/mpc52xx.h>
 #include <asm/mpc52xx_psc.h>
 #include "mpc5200_dma.h"
@@ -100,19 +101,32 @@ static void psc_ac97_warm_reset(struct snd_ac97 *ac97)
 {
        struct mpc52xx_psc __iomem *regs = psc_dma->psc_regs;
+        mutex_lock(&psc_dma->mutex);
        out_be32(&regs->sicr, psc_dma->sicr | MPC52xx_PSC_SICR_AWR);
        udelay(3);
        out_be32(&regs->sicr, psc_dma->sicr);
+        mutex_unlock(&psc_dma->mutex);
 }
 static void psc_ac97_cold_reset(struct snd_ac97 *ac97)
 {
        struct mpc52xx_psc __iomem *regs = psc_dma->psc_regs;
-        /* Do a cold reset */
+        mutex_lock(&psc_dma->mutex);
-        out_8(&regs->op1, MPC52xx_PSC_OP_RES);
+        dev_dbg(psc_dma->dev, "cold reset\n");
-        udelay(10);
-        out_8(&regs->op0, MPC52xx_PSC_OP_RES);
+        mpc5200_psc_ac97_gpio_reset(psc_dma->id);
+        /* Notify the PSC that a reset has occurred */
+        out_be32(&regs->sicr, psc_dma->sicr | MPC52xx_PSC_SICR_ACRB);
+        /* Re-enable RX and TX */
+        out_8(&regs->command, MPC52xx_PSC_TX_ENABLE | MPC52xx_PSC_RX_ENABLE);
+        mutex_unlock(&psc_dma->mutex);
        msleep(1);
        psc_ac97_warm_reset(ac97);
 }
@@ -258,7 +272,7 @@ static struct snd_soc_dai_driver psc_ac97_dai[] = {
 * - Probe/remove operations
 * - OF device match table
 */
-static int __devinit psc_ac97_of_probe(struct of_device *op,
+static int __devinit psc_ac97_of_probe(struct platform_device *op,
                                      const struct of_device_id *match)
 {
        int rc;
@@ -288,7 +302,7 @@ static int __devinit psc_ac97_of_probe(struct of_device *op,
        return 0;
 }
-static int __devexit psc_ac97_of_remove(struct of_device *op)
+static int __devexit psc_ac97_of_remove(struct platform_device *op)
 {
        snd_soc_unregister_dais(&op->dev, ARRAY_SIZE(psc_ac97_dai));
        return 0;
diff --git a/sound/soc/fsl/mpc5200_psc_i2s.c b/sound/soc/fsl/mpc5200_psc_i2s.c
index 5b9f2c73f031..74ffed41340f 100644
--- a/sound/soc/fsl/mpc5200_psc_i2s.c
+++ b/sound/soc/fsl/mpc5200_psc_i2s.c
@@ -150,7 +150,7 @@ static struct snd_soc_dai_driver psc_i2s_dai[] = {{
 * - Probe/remove operations
 * - OF device match table
 */
-static int __devinit psc_i2s_of_probe(struct of_device *op,
+static int __devinit psc_i2s_of_probe(struct platform_device *op,
                                      const struct of_device_id *match)
 {
        int rc;
@@ -199,7 +199,7 @@ static int __devinit psc_i2s_of_probe(struct of_device *op,
 }
-static int __devexit psc_i2s_of_remove(struct of_device *op)
+static int __devexit psc_i2s_of_remove(struct platform_device *op)
 {
        snd_soc_unregister_dais(&op->dev, ARRAY_SIZE(psc_i2s_dai));
        return 0;
diff --git a/sound/soc/imx/imx-ssi.c b/sound/soc/imx/imx-ssi.c
index 02a3e7c799d8..2601be5a4ed8 100644
--- a/sound/soc/imx/imx-ssi.c
+++ b/sound/soc/imx/imx-ssi.c
@@ -23,7 +23,7 @@
 * between pcm data and GPIO status data changes. Our FIQ handler is not
 * able to handle this, hence this driver only works with 48000Hz sampling
 * rate.
- * Reading and writing AC97 registers is another challange. The core
+ * Reading and writing AC97 registers is another challenge. The core
 * provides us status bits when the read register is updated with *another*
 * value. When we read the same register two times (and the register still
 * contains the same value) these status bits are not set. We work
diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index cea0fe488623..3d480eb3555f 100644
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -1531,7 +1531,7 @@ card_probe_error:
 }
 /*
- * Attempt to initialise any uninitalised cards.  Must be called with
+ * Attempt to initialise any uninitialised cards.  Must be called with
 * client_mutex.
 */
 static void snd_soc_instantiate_cards(void)
diff --git a/sound/sound_core.c b/sound/sound_core.c
index 7c2d677a2df5..cb61317df509 100644
--- a/sound/sound_core.c
+++ b/sound/sound_core.c
@@ -576,8 +576,6 @@ static int soundcore_open(struct inode *inode, struct file *file)
        struct sound_unit *s;
        const struct file_operations *new_fops = NULL;
-        lock_kernel ();
        chain=unit&0x0F;
        if(chain==4 || chain==5)        /* dsp/audio/dsp16 */
        {
@@ -630,18 +628,19 @@ static int soundcore_open(struct inode *inode, struct file *file)
                const struct file_operations *old_fops = file->f_op;
                file->f_op = new_fops;
                spin_unlock(&sound_loader_lock);
-                if(file->f_op->open)
+                if (file->f_op->open)
                        err = file->f_op->open(inode,file);
                if (err) {
                        fops_put(file->f_op);
                        file->f_op = fops_get(old_fops);
                }
                fops_put(old_fops);
-                unlock_kernel();
                return err;
        }
        spin_unlock(&sound_loader_lock);
-        unlock_kernel();
        return -ENODEV;
 }
diff --git a/sound/sparc/amd7930.c b/sound/sparc/amd7930.c
index 71221fd20944..f8bcfc30f800 100644
--- a/sound/sparc/amd7930.c
+++ b/sound/sparc/amd7930.c
@@ -336,7 +336,7 @@ struct snd_amd7930 {
        int                     pgain;
        int                     mgain;
-        struct of_device        *op;
+        struct platform_device  *op;
        unsigned int            irq;
        struct snd_amd7930      *next;
 };
@@ -906,7 +906,7 @@ static int __devinit snd_amd7930_mixer(struct snd_amd7930 *amd)
 static int snd_amd7930_free(struct snd_amd7930 *amd)
 {
-        struct of_device *op = amd->op;
+        struct platform_device *op = amd->op;
        amd7930_idle(amd);
@@ -934,7 +934,7 @@ static struct snd_device_ops snd_amd7930_dev_ops = {
 };
 static int __devinit snd_amd7930_create(struct snd_card *card,
-                                        struct of_device *op,
+                                        struct platform_device *op,
                                        int irq, int dev,
                                        struct snd_amd7930 **ramd)
 {
@@ -1002,7 +1002,7 @@ static int __devinit snd_amd7930_create(struct snd_card *card,
        return 0;
 }
-static int __devinit amd7930_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit amd7930_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
        struct resource *rp = &op->resource[0];
        static int dev_num;
@@ -1010,7 +1010,7 @@ static int __devinit amd7930_sbus_probe(struct of_device *op, const struct of_de
        struct snd_amd7930 *amd;
        int err, irq;
-        irq = op->irqs[0];
+        irq = op->archdata.irqs[0];
        if (dev_num >= SNDRV_CARDS)
                return -ENODEV;
@@ -1075,7 +1075,7 @@ static struct of_platform_driver amd7930_sbus_driver = {
 static int __init amd7930_init(void)
 {
-        return of_register_driver(&amd7930_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&amd7930_sbus_driver);
 }
 static void __exit amd7930_exit(void)
@@ -1092,7 +1092,7 @@ static void __exit amd7930_exit(void)
        amd7930_list = NULL;
-        of_unregister_driver(&amd7930_sbus_driver);
+        of_unregister_platform_driver(&amd7930_sbus_driver);
 }
 module_init(amd7930_init);
diff --git a/sound/sparc/cs4231.c b/sound/sparc/cs4231.c
index fb4c6f2f29e5..c276086c3b57 100644
--- a/sound/sparc/cs4231.c
+++ b/sound/sparc/cs4231.c
@@ -111,7 +111,7 @@ struct snd_cs4231 {
        struct mutex            mce_mutex;      /* mutex for mce register */
        struct mutex            open_mutex;     /* mutex for ALSA open/close */
-        struct of_device        *op;
+        struct platform_device  *op;
        unsigned int            irq[2];
        unsigned int            regs_size;
        struct snd_cs4231       *next;
@@ -1771,7 +1771,7 @@ static unsigned int sbus_dma_addr(struct cs4231_dma_control *dma_cont)
 static int snd_cs4231_sbus_free(struct snd_cs4231 *chip)
 {
-        struct of_device *op = chip->op;
+        struct platform_device *op = chip->op;
        if (chip->irq[0])
                free_irq(chip->irq[0], chip);
@@ -1794,7 +1794,7 @@ static struct snd_device_ops snd_cs4231_sbus_dev_ops = {
 };
 static int __devinit snd_cs4231_sbus_create(struct snd_card *card,
-                                            struct of_device *op,
+                                            struct platform_device *op,
                                            int dev)
 {
        struct snd_cs4231 *chip = card->private_data;
@@ -1832,14 +1832,14 @@ static int __devinit snd_cs4231_sbus_create(struct snd_card *card,
        chip->c_dma.request = sbus_dma_request;
        chip->c_dma.address = sbus_dma_addr;
-        if (request_irq(op->irqs[0], snd_cs4231_sbus_interrupt,
+        if (request_irq(op->archdata.irqs[0], snd_cs4231_sbus_interrupt,
                        IRQF_SHARED, "cs4231", chip)) {
                snd_printdd("cs4231-%d: Unable to grab SBUS IRQ %d\n",
-                            dev, op->irqs[0]);
+                            dev, op->archdata.irqs[0]);
                snd_cs4231_sbus_free(chip);
                return -EBUSY;
        }
-        chip->irq[0] = op->irqs[0];
+        chip->irq[0] = op->archdata.irqs[0];
        if (snd_cs4231_probe(chip) < 0) {
                snd_cs4231_sbus_free(chip);
@@ -1856,7 +1856,7 @@ static int __devinit snd_cs4231_sbus_create(struct snd_card *card,
        return 0;
 }
-static int __devinit cs4231_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
        struct resource *rp = &op->resource[0];
        struct snd_card *card;
@@ -1870,7 +1870,7 @@ static int __devinit cs4231_sbus_probe(struct of_device *op, const struct of_dev
                card->shortname,
                rp->flags & 0xffL,
                (unsigned long long)rp->start,
-                op->irqs[0]);
+                op->archdata.irqs[0]);
        err = snd_cs4231_sbus_create(card, op, dev);
        if (err < 0) {
@@ -1931,7 +1931,7 @@ static unsigned int _ebus_dma_addr(struct cs4231_dma_control *dma_cont)
 static int snd_cs4231_ebus_free(struct snd_cs4231 *chip)
 {
-        struct of_device *op = chip->op;
+        struct platform_device *op = chip->op;
        if (chip->c_dma.ebus_info.regs) {
                ebus_dma_unregister(&chip->c_dma.ebus_info);
@@ -1960,7 +1960,7 @@ static struct snd_device_ops snd_cs4231_ebus_dev_ops = {
 };
 static int __devinit snd_cs4231_ebus_create(struct snd_card *card,
-                                            struct of_device *op,
+                                            struct platform_device *op,
                                            int dev)
 {
        struct snd_cs4231 *chip = card->private_data;
@@ -1979,12 +1979,12 @@ static int __devinit snd_cs4231_ebus_create(struct snd_card *card,
        chip->c_dma.ebus_info.flags = EBUS_DMA_FLAG_USE_EBDMA_HANDLER;
        chip->c_dma.ebus_info.callback = snd_cs4231_ebus_capture_callback;
        chip->c_dma.ebus_info.client_cookie = chip;
-        chip->c_dma.ebus_info.irq = op->irqs[0];
+        chip->c_dma.ebus_info.irq = op->archdata.irqs[0];
        strcpy(chip->p_dma.ebus_info.name, "cs4231(play)");
        chip->p_dma.ebus_info.flags = EBUS_DMA_FLAG_USE_EBDMA_HANDLER;
        chip->p_dma.ebus_info.callback = snd_cs4231_ebus_play_callback;
        chip->p_dma.ebus_info.client_cookie = chip;
-        chip->p_dma.ebus_info.irq = op->irqs[1];
+        chip->p_dma.ebus_info.irq = op->archdata.irqs[1];
        chip->p_dma.prepare = _ebus_dma_prepare;
        chip->p_dma.enable = _ebus_dma_enable;
@@ -2048,7 +2048,7 @@ static int __devinit snd_cs4231_ebus_create(struct snd_card *card,
        return 0;
 }
-static int __devinit cs4231_ebus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_ebus_probe(struct platform_device *op, const struct of_device_id *match)
 {
        struct snd_card *card;
        int err;
@@ -2060,7 +2060,7 @@ static int __devinit cs4231_ebus_probe(struct of_device *op, const struct of_dev
        sprintf(card->longname, "%s at 0x%llx, irq %d",
                card->shortname,
                op->resource[0].start,
-                op->irqs[0]);
+                op->archdata.irqs[0]);
        err = snd_cs4231_ebus_create(card, op, dev);
        if (err < 0) {
@@ -2072,7 +2072,7 @@ static int __devinit cs4231_ebus_probe(struct of_device *op, const struct of_dev
 }
 #endif
-static int __devinit cs4231_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_probe(struct platform_device *op, const struct of_device_id *match)
 {
 #ifdef EBUS_SUPPORT
        if (!strcmp(op->dev.of_node->parent->name, "ebus"))
@@ -2086,7 +2086,7 @@ static int __devinit cs4231_probe(struct of_device *op, const struct of_device_i
        return -ENODEV;
 }
-static int __devexit cs4231_remove(struct of_device *op)
+static int __devexit cs4231_remove(struct platform_device *op)
 {
        struct snd_cs4231 *chip = dev_get_drvdata(&op->dev);
@@ -2120,12 +2120,12 @@ static struct of_platform_driver cs4231_driver = {
 static int __init cs4231_init(void)
 {
-        return of_register_driver(&cs4231_driver, &of_bus_type);
+        return of_register_platform_driver(&cs4231_driver);
 }
 static void __exit cs4231_exit(void)
 {
-        of_unregister_driver(&cs4231_driver);
+        of_unregister_platform_driver(&cs4231_driver);
 }
 module_init(cs4231_init);
diff --git a/sound/sparc/dbri.c b/sound/sparc/dbri.c
index 1557bf132e73..39cd5d69d051 100644
--- a/sound/sparc/dbri.c
+++ b/sound/sparc/dbri.c
@@ -299,7 +299,7 @@ struct dbri_streaminfo {
 /* This structure holds the information for both chips (DBRI & CS4215) */
 struct snd_dbri {
        int regs_size, irq;     /* Needed for unload */
-        struct of_device *op;   /* OF device info */
+        struct platform_device *op;     /* OF device info */
        spinlock_t lock;
        struct dbri_dma *dma;   /* Pointer to our DMA block */
@@ -2523,7 +2523,7 @@ static void __devinit snd_dbri_proc(struct snd_card *card)
 static void snd_dbri_free(struct snd_dbri *dbri);
 static int __devinit snd_dbri_create(struct snd_card *card,
-                                     struct of_device *op,
+                                     struct platform_device *op,
                                     int irq, int dev)
 {
        struct snd_dbri *dbri = card->private_data;
@@ -2592,7 +2592,7 @@ static void snd_dbri_free(struct snd_dbri *dbri)
                                  (void *)dbri->dma, dbri->dma_dvma);
 }
-static int __devinit dbri_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit dbri_probe(struct platform_device *op, const struct of_device_id *match)
 {
        struct snd_dbri *dbri;
        struct resource *rp;
@@ -2608,7 +2608,7 @@ static int __devinit dbri_probe(struct of_device *op, const struct of_device_id
                return -ENOENT;
        }
-        irq = op->irqs[0];
+        irq = op->archdata.irqs[0];
        if (irq <= 0) {
                printk(KERN_ERR "DBRI-%d: No IRQ.\n", dev);
                return -ENODEV;
@@ -2662,7 +2662,7 @@ _err:
        return err;
 }
-static int __devexit dbri_remove(struct of_device *op)
+static int __devexit dbri_remove(struct platform_device *op)
 {
        struct snd_card *card = dev_get_drvdata(&op->dev);
@@ -2699,12 +2699,12 @@ static struct of_platform_driver dbri_sbus_driver = {
 /* Probe for the dbri chip and then attach the driver. */
 static int __init dbri_init(void)
 {
-        return of_register_driver(&dbri_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&dbri_sbus_driver);
 }
 static void __exit dbri_exit(void)
 {
-        of_unregister_driver(&dbri_sbus_driver);
+        of_unregister_platform_driver(&dbri_sbus_driver);
 }
 module_init(dbri_init);
diff --git a/sound/spi/at73c213.c b/sound/spi/at73c213.c
index 4c7b051f9d17..1bc56b2b94e2 100644
--- a/sound/spi/at73c213.c
+++ b/sound/spi/at73c213.c
@@ -69,7 +69,6 @@ struct snd_at73c213 {
        int                             irq;
        int                             period;
        unsigned long                   bitrate;
-        struct clk                      *bitclk;
        struct ssc_device               *ssc;
        struct spi_device               *spi;
        u8                              spi_wbuffer[2];
diff --git a/sound/usb/Makefile b/sound/usb/Makefile
index e7ac7f493a8f..1e362bf8834f 100644
--- a/sound/usb/Makefile
+++ b/sound/usb/Makefile
@@ -11,7 +11,8 @@ snd-usb-audio-objs := 	card.o \
                        endpoint.o \
                        urb.o \
                        pcm.o \
-                        helper.o
+                        helper.o \
+                        clock.o
 snd-usbmidi-lib-objs := midi.o
diff --git a/sound/usb/card.c b/sound/usb/card.c
index da1346bd4856..9feb00c831a0 100644
--- a/sound/usb/card.c
+++ b/sound/usb/card.c
@@ -217,7 +217,7 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
        switch (protocol) {
        case UAC_VERSION_1: {
-                struct uac_ac_header_descriptor_v1 *h1 = control_header;
+                struct uac1_ac_header_descriptor *h1 = control_header;
                if (!h1->bInCollection) {
                        snd_printk(KERN_INFO "skipping empty audio interface (v1)\n");
@@ -236,7 +236,6 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
        }
        case UAC_VERSION_2: {
-                struct uac_clock_source_descriptor *cs;
                struct usb_interface_assoc_descriptor *assoc =
                        usb_ifnum_to_if(dev, ctrlif)->intf_assoc;
@@ -245,21 +244,6 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
                        return -EINVAL;
                }
-                /* FIXME: for now, we expect there is at least one clock source
-                 * descriptor and we always take the first one.
-                 * We should properly support devices with multiple clock sources,
-                 * clock selectors and sample rate conversion units. */
-                cs = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen,
-                                                NULL, UAC2_CLOCK_SOURCE);
-                if (!cs) {
-                        snd_printk(KERN_ERR "CLOCK_SOURCE descriptor not found\n");
-                        return -EINVAL;
-                }
-                chip->clock_id = cs->bClockID;
                for (i = 0; i < assoc->bInterfaceCount; i++) {
                        int intf = assoc->bFirstInterface + i;
@@ -481,6 +465,8 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
                        goto __error;
        }
+        chip->ctrl_intf = alts;
        if (err > 0) {
                /* create normal USB audio interfaces */
                if (snd_usb_create_streams(chip, ifnum) < 0 ||
diff --git a/sound/usb/card.h b/sound/usb/card.h
index ed92420c1095..1febf2f23754 100644
--- a/sound/usb/card.h
+++ b/sound/usb/card.h
@@ -25,6 +25,7 @@ struct audioformat {
        unsigned int rate_min, rate_max;        /* min/max rates */
        unsigned int nr_rates;          /* number of rate table entries */
        unsigned int *rate_table;       /* rate table */
+        unsigned char clock;            /* associated clock */
 };
 struct snd_usb_substream;
diff --git a/sound/usb/clock.c b/sound/usb/clock.c
new file mode 100644
index 000000000000..b853f8df794f
--- /dev/null
+++ b/sound/usb/clock.c
@@ -0,0 +1,306 @@
+/*
+ *   Clock domain and sample rate management functions
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ */
+#include <linux/bitops.h>
+#include <linux/init.h>
+#include <linux/string.h>
+#include <linux/usb.h>
+#include <linux/usb/audio.h>
+#include <linux/usb/audio-v2.h>
+#include <sound/core.h>
+#include <sound/info.h>
+#include <sound/pcm.h>
+#include "usbaudio.h"
+#include "card.h"
+#include "helper.h"
+#include "clock.h"
+static struct uac_clock_source_descriptor *
+        snd_usb_find_clock_source(struct usb_host_interface *ctrl_iface,
+                                  int clock_id)
+{
+        struct uac_clock_source_descriptor *cs = NULL;
+        while ((cs = snd_usb_find_csint_desc(ctrl_iface->extra,
+                                             ctrl_iface->extralen,
+                                             cs, UAC2_CLOCK_SOURCE))) {
+                if (cs->bClockID == clock_id)
+                        return cs;
+        }
+        return NULL;
+}
+static struct uac_clock_selector_descriptor *
+        snd_usb_find_clock_selector(struct usb_host_interface *ctrl_iface,
+                                    int clock_id)
+{
+        struct uac_clock_selector_descriptor *cs = NULL;
+        while ((cs = snd_usb_find_csint_desc(ctrl_iface->extra,
+                                             ctrl_iface->extralen,
+                                             cs, UAC2_CLOCK_SELECTOR))) {
+                if (cs->bClockID == clock_id)
+                        return cs;
+        }
+        return NULL;
+}
+static struct uac_clock_multiplier_descriptor *
+        snd_usb_find_clock_multiplier(struct usb_host_interface *ctrl_iface,
+                                      int clock_id)
+{
+        struct uac_clock_multiplier_descriptor *cs = NULL;
+        while ((cs = snd_usb_find_csint_desc(ctrl_iface->extra,
+                                             ctrl_iface->extralen,
+                                             cs, UAC2_CLOCK_MULTIPLIER))) {
+                if (cs->bClockID == clock_id)
+                        return cs;
+        }
+        return NULL;
+}
+static int uac_clock_selector_get_val(struct snd_usb_audio *chip, int selector_id)
+{
+        unsigned char buf;
+        int ret;
+        ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0),
+                              UAC2_CS_CUR,
+                              USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
+                              UAC2_CX_CLOCK_SELECTOR << 8,
+                              snd_usb_ctrl_intf(chip) | (selector_id << 8),
+                              &buf, sizeof(buf), 1000);
+        if (ret < 0)
+                return ret;
+        return buf;
+}
+static bool uac_clock_source_is_valid(struct snd_usb_audio *chip, int source_id)
+{
+        int err;
+        unsigned char data;
+        struct usb_device *dev = chip->dev;
+        err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR,
+                              USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
+                              UAC2_CS_CONTROL_CLOCK_VALID << 8,
+                              snd_usb_ctrl_intf(chip) | (source_id << 8),
+                              &data, sizeof(data), 1000);
+        if (err < 0) {
+                snd_printk(KERN_WARNING "%s(): cannot get clock validity for id %d\n",
+                           __func__, source_id);
+                return err;
+        }
+        return !!data;
+}
+static int __uac_clock_find_source(struct snd_usb_audio *chip,
+                                   int entity_id, unsigned long *visited)
+{
+        struct uac_clock_source_descriptor *source;
+        struct uac_clock_selector_descriptor *selector;
+        struct uac_clock_multiplier_descriptor *multiplier;
+        entity_id &= 0xff;
+        if (test_and_set_bit(entity_id, visited)) {
+                snd_printk(KERN_WARNING
+                        "%s(): recursive clock topology detected, id %d.\n",
+                        __func__, entity_id);
+                return -EINVAL;
+        }
+        /* first, see if the ID we're looking for is a clock source already */
+        source = snd_usb_find_clock_source(chip->ctrl_intf, entity_id);
+        if (source)
+                return source->bClockID;
+        selector = snd_usb_find_clock_selector(chip->ctrl_intf, entity_id);
+        if (selector) {
+                int ret;
+                /* the entity ID we are looking for is a selector.
+                 * find out what it currently selects */
+                ret = uac_clock_selector_get_val(chip, selector->bClockID);
+                if (ret < 0)
+                        return ret;
+                /* Selector values are one-based */
+                if (ret > selector->bNrInPins || ret < 1) {
+                        printk(KERN_ERR
+                                "%s(): selector reported illegal value, id %d, ret %d\n",
+                                __func__, selector->bClockID, ret);
+                        return -EINVAL;
+                }
+                return __uac_clock_find_source(chip, selector->baCSourceID[ret-1],
+                                               visited);
+        }
+        /* FIXME: multipliers only act as pass-thru element for now */
+        multiplier = snd_usb_find_clock_multiplier(chip->ctrl_intf, entity_id);
+        if (multiplier)
+                return __uac_clock_find_source(chip, multiplier->bCSourceID,
+                                                visited);
+        return -EINVAL;
+}
+/*
+ * For all kinds of sample rate settings and other device queries,
+ * the clock source (end-leaf) must be used. However, clock selectors,
+ * clock multipliers and sample rate converters may be specified as
+ * clock source input to terminal. This functions walks the clock path
+ * to its end and tries to find the source.
+ *
+ * The 'visited' bitfield is used internally to detect recursive loops.
+ *
+ * Returns the clock source UnitID (>=0) on success, or an error.
+ */
+int snd_usb_clock_find_source(struct snd_usb_audio *chip, int entity_id)
+{
+        DECLARE_BITMAP(visited, 256);
+        memset(visited, 0, sizeof(visited));
+        return __uac_clock_find_source(chip, entity_id, visited);
+}
+static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface,
+                              struct usb_host_interface *alts,
+                              struct audioformat *fmt, int rate)
+{
+        struct usb_device *dev = chip->dev;
+        unsigned int ep;
+        unsigned char data[3];
+        int err, crate;
+        ep = get_endpoint(alts, 0)->bEndpointAddress;
+        /* if endpoint doesn't have sampling rate control, bail out */
+        if (!(fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE))
+                return 0;
+        data[0] = rate;
+        data[1] = rate >> 8;
+        data[2] = rate >> 16;
+        if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
+                                   USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
+                                   UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
+                                   data, sizeof(data), 1000)) < 0) {
+                snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep %#x\n",
+                           dev->devnum, iface, fmt->altsetting, rate, ep);
+                return err;
+        }
+        if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
+                                   USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
+                                   UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
+                                   data, sizeof(data), 1000)) < 0) {
+                snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep %#x\n",
+                           dev->devnum, iface, fmt->altsetting, ep);
+                return 0; /* some devices don't support reading */
+        }
+        crate = data[0] | (data[1] << 8) | (data[2] << 16);
+        if (crate != rate) {
+                snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
+                // runtime->rate = crate;
+        }
+        return 0;
+}
+static int set_sample_rate_v2(struct snd_usb_audio *chip, int iface,
+                              struct usb_host_interface *alts,
+                              struct audioformat *fmt, int rate)
+{
+        struct usb_device *dev = chip->dev;
+        unsigned char data[4];
+        int err, crate;
+        int clock = snd_usb_clock_find_source(chip, fmt->clock);
+        if (clock < 0)
+                return clock;
+        if (!uac_clock_source_is_valid(chip, clock)) {
+                /* TODO: should we try to find valid clock setups by ourself? */
+                snd_printk(KERN_ERR "%d:%d:%d: clock source %d is not valid, cannot use\n",
+                           dev->devnum, iface, fmt->altsetting, clock);
+                return -ENXIO;
+        }
+        data[0] = rate;
+        data[1] = rate >> 8;
+        data[2] = rate >> 16;
+        data[3] = rate >> 24;
+        if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR,
+                                   USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
+                                   UAC2_CS_CONTROL_SAM_FREQ << 8,
+                                   snd_usb_ctrl_intf(chip) | (clock << 8),
+                                   data, sizeof(data), 1000)) < 0) {
+                snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d (v2)\n",
+                           dev->devnum, iface, fmt->altsetting, rate);
+                return err;
+        }
+        if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR,
+                                   USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
+                                   UAC2_CS_CONTROL_SAM_FREQ << 8,
+                                   snd_usb_ctrl_intf(chip) | (clock << 8),
+                                   data, sizeof(data), 1000)) < 0) {
+                snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq (v2)\n",
+                           dev->devnum, iface, fmt->altsetting);
+                return err;
+        }
+        crate = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
+        if (crate != rate)
+                snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
+        return 0;
+}
+int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
+                             struct usb_host_interface *alts,
+                             struct audioformat *fmt, int rate)
+{
+        struct usb_interface_descriptor *altsd = get_iface_desc(alts);
+        switch (altsd->bInterfaceProtocol) {
+        case UAC_VERSION_1:
+                return set_sample_rate_v1(chip, iface, alts, fmt, rate);
+        case UAC_VERSION_2:
+                return set_sample_rate_v2(chip, iface, alts, fmt, rate);
+        }
+        return -EINVAL;
+}
diff --git a/sound/usb/clock.h b/sound/usb/clock.h
new file mode 100644
index 000000000000..46630936d31f
--- /dev/null
+++ b/sound/usb/clock.h
@@ -0,0 +1,10 @@
+#ifndef __USBAUDIO_CLOCK_H
+#define __USBAUDIO_CLOCK_H
+int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
+                             struct usb_host_interface *alts,
+                             struct audioformat *fmt, int rate);
+int snd_usb_clock_find_source(struct snd_usb_audio *chip, int entity_id);
+#endif /* __USBAUDIO_CLOCK_H */
diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c
index 28ee1ce3971a..1a701f1e8f50 100644
--- a/sound/usb/endpoint.c
+++ b/sound/usb/endpoint.c
@@ -33,6 +33,7 @@
 #include "pcm.h"
 #include "helper.h"
 #include "format.h"
+#include "clock.h"
 /*
 * free a substream
@@ -190,6 +191,38 @@ static int parse_uac_endpoint_attributes(struct snd_usb_audio *chip,
        return attributes;
 }
+static struct uac2_input_terminal_descriptor *
+        snd_usb_find_input_terminal_descriptor(struct usb_host_interface *ctrl_iface,
+                                               int terminal_id)
+{
+        struct uac2_input_terminal_descriptor *term = NULL;
+        while ((term = snd_usb_find_csint_desc(ctrl_iface->extra,
+                                               ctrl_iface->extralen,
+                                               term, UAC_INPUT_TERMINAL))) {
+                if (term->bTerminalID == terminal_id)
+                        return term;
+        }
+        return NULL;
+}
+static struct uac2_output_terminal_descriptor *
+        snd_usb_find_output_terminal_descriptor(struct usb_host_interface *ctrl_iface,
+                                                int terminal_id)
+{
+        struct uac2_output_terminal_descriptor *term = NULL;
+        while ((term = snd_usb_find_csint_desc(ctrl_iface->extra,
+                                               ctrl_iface->extralen,
+                                               term, UAC_OUTPUT_TERMINAL))) {
+                if (term->bTerminalID == terminal_id)
+                        return term;
+        }
+        return NULL;
+}
 int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
 {
        struct usb_device *dev;
@@ -199,7 +232,7 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
        int i, altno, err, stream;
        int format = 0, num_channels = 0;
        struct audioformat *fp = NULL;
-        int num, protocol;
+        int num, protocol, clock = 0;
        struct uac_format_type_i_continuous_descriptor *fmt;
        dev = chip->dev;
@@ -243,7 +276,7 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                /* get audio formats */
                switch (protocol) {
                case UAC_VERSION_1: {
-                        struct uac_as_header_descriptor_v1 *as =
+                        struct uac1_as_header_descriptor *as =
                                snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
                        if (!as) {
@@ -263,7 +296,9 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                }
                case UAC_VERSION_2: {
-                        struct uac_as_header_descriptor_v2 *as =
+                        struct uac2_input_terminal_descriptor *input_term;
+                        struct uac2_output_terminal_descriptor *output_term;
+                        struct uac2_as_header_descriptor *as =
                                snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
                        if (!as) {
@@ -281,7 +316,25 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                        num_channels = as->bNrChannels;
                        format = le32_to_cpu(as->bmFormats);
-                        break;
+                        /* lookup the terminal associated to this interface
+                         * to extract the clock */
+                        input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf,
+                                                                            as->bTerminalLink);
+                        if (input_term) {
+                                clock = input_term->bCSourceID;
+                                break;
+                        }
+                        output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf,
+                                                                              as->bTerminalLink);
+                        if (output_term) {
+                                clock = output_term->bCSourceID;
+                                break;
+                        }
+                        snd_printk(KERN_ERR "%d:%u:%d : bogus bTerminalLink %d\n",
+                                   dev->devnum, iface_no, altno, as->bTerminalLink);
+                        continue;
                }
                default:
@@ -338,6 +391,7 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                        fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
                                        * (fp->maxpacksize & 0x7ff);
                fp->attributes = parse_uac_endpoint_attributes(chip, alts, protocol, iface_no);
+                fp->clock = clock;
                /* some quirks for attributes here */
@@ -374,6 +428,7 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                if (snd_usb_parse_audio_format(chip, fp, format, fmt, stream, alts) < 0) {
                        kfree(fp->rate_table);
                        kfree(fp);
+                        fp = NULL;
                        continue;
                }
diff --git a/sound/usb/format.c b/sound/usb/format.c
index fe29d61de19b..3a1375459c06 100644
--- a/sound/usb/format.c
+++ b/sound/usb/format.c
@@ -29,6 +29,7 @@
 #include "quirks.h"
 #include "helper.h"
 #include "debug.h"
+#include "clock.h"
 /*
 * parse the audio format type I descriptor
@@ -205,30 +206,92 @@ static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audiof
 }
 /*
+ * Helper function to walk the array of sample rate triplets reported by
+ * the device. The problem is that we need to parse whole array first to
+ * get to know how many sample rates we have to expect.
+ * Then fp->rate_table can be allocated and filled.
+ */
+static int parse_uac2_sample_rate_range(struct audioformat *fp, int nr_triplets,
+                                        const unsigned char *data)
+{
+        int i, nr_rates = 0;
+        fp->rates = fp->rate_min = fp->rate_max = 0;
+        for (i = 0; i < nr_triplets; i++) {
+                int min = combine_quad(&data[2 + 12 * i]);
+                int max = combine_quad(&data[6 + 12 * i]);
+                int res = combine_quad(&data[10 + 12 * i]);
+                int rate;
+                if ((max < 0) || (min < 0) || (res < 0) || (max < min))
+                        continue;
+                /*
+                 * for ranges with res == 1, we announce a continuous sample
+                 * rate range, and this function should return 0 for no further
+                 * parsing.
+                 */
+                if (res == 1) {
+                        fp->rate_min = min;
+                        fp->rate_max = max;
+                        fp->rates = SNDRV_PCM_RATE_CONTINUOUS;
+                        return 0;
+                }
+                for (rate = min; rate <= max; rate += res) {
+                        if (fp->rate_table)
+                                fp->rate_table[nr_rates] = rate;
+                        if (!fp->rate_min || rate < fp->rate_min)
+                                fp->rate_min = rate;
+                        if (!fp->rate_max || rate > fp->rate_max)
+                                fp->rate_max = rate;
+                        fp->rates |= snd_pcm_rate_to_rate_bit(rate);
+                        nr_rates++;
+                        /* avoid endless loop */
+                        if (res == 0)
+                                break;
+                }
+        }
+        return nr_rates;
+}
+/*
 * parse the format descriptor and stores the possible sample rates
 * on the audioformat table (audio class v2).
 */
 static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
-                                       struct audioformat *fp,
+                                       struct audioformat *fp)
-                                       struct usb_host_interface *iface)
 {
        struct usb_device *dev = chip->dev;
        unsigned char tmp[2], *data;
-        int i, nr_rates, data_size, ret = 0;
+        int nr_triplets, data_size, ret = 0;
+        int clock = snd_usb_clock_find_source(chip, fp->clock);
+        if (clock < 0) {
+                snd_printk(KERN_ERR "%s(): unable to find clock source (clock %d)\n",
+                                __func__, clock);
+                goto err;
+        }
        /* get the number of sample rates first by only fetching 2 bytes */
        ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
                              USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
-                              UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8,
+                              UAC2_CS_CONTROL_SAM_FREQ << 8,
+                              snd_usb_ctrl_intf(chip) | (clock << 8),
                              tmp, sizeof(tmp), 1000);
        if (ret < 0) {
-                snd_printk(KERN_ERR "unable to retrieve number of sample rates\n");
+                snd_printk(KERN_ERR "%s(): unable to retrieve number of sample rates (clock %d)\n",
+                                __func__, clock);
                goto err;
        }
-        nr_rates = (tmp[1] << 8) | tmp[0];
+        nr_triplets = (tmp[1] << 8) | tmp[0];
-        data_size = 2 + 12 * nr_rates;
+        data_size = 2 + 12 * nr_triplets;
        data = kzalloc(data_size, GFP_KERNEL);
        if (!data) {
                ret = -ENOMEM;
@@ -237,36 +300,40 @@ static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
        /* now get the full information */
        ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
-                               USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
+                              USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
-                               UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8,
+                              UAC2_CS_CONTROL_SAM_FREQ << 8,
-                               data, data_size, 1000);
+                              snd_usb_ctrl_intf(chip) | (clock << 8),
+                              data, data_size, 1000);
        if (ret < 0) {
-                snd_printk(KERN_ERR "unable to retrieve sample rate range\n");
+                snd_printk(KERN_ERR "%s(): unable to retrieve sample rate range (clock %d)\n",
+                                __func__, clock);
                ret = -EINVAL;
                goto err_free;
        }
-        fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
+        /* Call the triplet parser, and make sure fp->rate_table is NULL.
+         * We just use the return value to know how many sample rates we
+         * will have to deal with. */
+        kfree(fp->rate_table);
+        fp->rate_table = NULL;
+        fp->nr_rates = parse_uac2_sample_rate_range(fp, nr_triplets, data);
+        if (fp->nr_rates == 0) {
+                /* SNDRV_PCM_RATE_CONTINUOUS */
+                ret = 0;
+                goto err_free;
+        }
+        fp->rate_table = kmalloc(sizeof(int) * fp->nr_rates, GFP_KERNEL);
        if (!fp->rate_table) {
                ret = -ENOMEM;
                goto err_free;
        }
-        fp->nr_rates = 0;
+        /* Call the triplet parser again, but this time, fp->rate_table is
-        fp->rate_min = fp->rate_max = 0;
+         * allocated, so the rates will be stored */
+        parse_uac2_sample_rate_range(fp, nr_triplets, data);
-        for (i = 0; i < nr_rates; i++) {
-                int rate = combine_quad(&data[2 + 12 * i]);
-                fp->rate_table[fp->nr_rates] = rate;
-                if (!fp->rate_min || rate < fp->rate_min)
-                        fp->rate_min = rate;
-                if (!fp->rate_max || rate > fp->rate_max)
-                        fp->rate_max = rate;
-                fp->rates |= snd_pcm_rate_to_rate_bit(rate);
-                fp->nr_rates++;
-        }
 err_free:
        kfree(data);
@@ -323,8 +390,12 @@ static int parse_audio_format_i(struct snd_usb_audio *chip,
                break;
        case UAC_VERSION_2:
                /* fp->channels is already set in this case */
-                ret = parse_audio_format_rates_v2(chip, fp, iface);
+                ret = parse_audio_format_rates_v2(chip, fp);
                break;
+        default:
+                snd_printk(KERN_ERR "%d:%u:%d : invalid protocol version %d\n",
+                           chip->dev->devnum, fp->iface, fp->altsetting, protocol);
+                return -EINVAL;
        }
        if (fp->channels < 1) {
@@ -382,9 +453,13 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip,
                framesize = le16_to_cpu(fmt->wSamplesPerFrame);
                snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
                fp->frame_size = framesize;
-                ret = parse_audio_format_rates_v2(chip, fp, iface);
+                ret = parse_audio_format_rates_v2(chip, fp);
                break;
        }
+        default:
+                snd_printk(KERN_ERR "%d:%u:%d : invalid protocol version %d\n",
+                           chip->dev->devnum, fp->iface, fp->altsetting, protocol);
+                return -EINVAL;
        }
        return ret;
diff --git a/sound/usb/helper.h b/sound/usb/helper.h
index a6b0e51b3a9a..09bd943c43bf 100644
--- a/sound/usb/helper.h
+++ b/sound/usb/helper.h
@@ -28,5 +28,9 @@ unsigned char snd_usb_parse_datainterval(struct snd_usb_audio *chip,
 #define snd_usb_get_speed(dev) ((dev)->speed)
 #endif
+static inline int snd_usb_ctrl_intf(struct snd_usb_audio *chip)
+{
+        return get_iface_desc(chip->ctrl_intf)->bInterfaceNumber;
+}
 #endif /* __USBAUDIO_HELPER_H */
diff --git a/sound/usb/midi.c b/sound/usb/midi.c
index 46785643c66d..b9c2bc65f51a 100644
--- a/sound/usb/midi.c
+++ b/sound/usb/midi.c
@@ -434,7 +434,7 @@ static void snd_usbmidi_maudio_broken_running_status_input(
                        u8 cin = buffer[i] & 0x0f;
                        struct usbmidi_in_port *port = &ep->ports[cable];
                        int length;
-                        
                        length = snd_usbmidi_cin_length[cin];
                        if (cin == 0xf && buffer[i + 1] >= 0xf8)
                                ; /* realtime msg: no running status change */
@@ -628,13 +628,13 @@ static struct usb_protocol_ops snd_usbmidi_standard_ops = {
 static struct usb_protocol_ops snd_usbmidi_midiman_ops = {
        .input = snd_usbmidi_midiman_input,
-        .output = snd_usbmidi_standard_output, 
+        .output = snd_usbmidi_standard_output,
        .output_packet = snd_usbmidi_output_midiman_packet,
 };
 static struct usb_protocol_ops snd_usbmidi_maudio_broken_running_status_ops = {
        .input = snd_usbmidi_maudio_broken_running_status_input,
-        .output = snd_usbmidi_standard_output, 
+        .output = snd_usbmidi_standard_output,
        .output_packet = snd_usbmidi_output_standard_packet,
 };
@@ -1248,7 +1248,7 @@ static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint *ep
 */
 static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi,
                                           struct snd_usb_midi_endpoint_info* ep_info,
-                                           struct snd_usb_midi_endpoint* rep)
+                                           struct snd_usb_midi_endpoint* rep)
 {
        struct snd_usb_midi_out_endpoint* ep;
        unsigned int i;
@@ -1398,7 +1398,7 @@ static void snd_usbmidi_rawmidi_free(struct snd_rawmidi *rmidi)
 }
 static struct snd_rawmidi_substream *snd_usbmidi_find_substream(struct snd_usb_midi* umidi,
-                                                           int stream, int number)
+                                                                int stream, int number)
 {
        struct list_head* list;
@@ -1811,7 +1811,7 @@ static int snd_usbmidi_detect_endpoints(struct snd_usb_midi* umidi,
                snd_usbmidi_switch_roland_altsetting(umidi);
        if (endpoint[0].out_ep || endpoint[0].in_ep)
-                return 0;       
+                return 0;
        intf = umidi->iface;
        if (!intf || intf->num_altsetting < 1)
@@ -1849,7 +1849,7 @@ static int snd_usbmidi_detect_per_port_endpoints(struct snd_usb_midi* umidi,
                                                 struct snd_usb_midi_endpoint_info* endpoints)
 {
        int err, i;
-        
        err = snd_usbmidi_detect_endpoints(umidi, endpoints, MIDI_MAX_ENDPOINTS);
        for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
                if (endpoints[i].out_ep)
diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
index 03ce971e0027..c166db0057d3 100644
--- a/sound/usb/mixer.c
+++ b/sound/usb/mixer.c
@@ -26,6 +26,22 @@
 *
 */
+/*
+ * TODOs, for both the mixer and the streaming interfaces:
+ *
+ *  - support for UAC2 effect units
+ *  - support for graphical equalizers
+ *  - RANGE and MEM set commands (UAC2)
+ *  - RANGE and MEM interrupt dispatchers (UAC2)
+ *  - audio channel clustering (UAC2)
+ *  - audio sample rate converter units (UAC2)
+ *  - proper handling of clock multipliers (UAC2)
+ *  - dispatch clock change notifications (UAC2)
+ *      - stop PCM streams which use a clock that became invalid
+ *      - stop PCM streams which use a clock selector that has changed
+ *      - parse available sample rates again when clock sources changed
+ */
 #include <linux/bitops.h>
 #include <linux/init.h>
 #include <linux/list.h>
@@ -78,39 +94,6 @@ enum {
        USB_MIXER_U16,
 };
-enum {
-        USB_PROC_UPDOWN = 1,
-        USB_PROC_UPDOWN_SWITCH = 1,
-        USB_PROC_UPDOWN_MODE_SEL = 2,
-        USB_PROC_PROLOGIC = 2,
-        USB_PROC_PROLOGIC_SWITCH = 1,
-        USB_PROC_PROLOGIC_MODE_SEL = 2,
-        USB_PROC_3DENH = 3,
-        USB_PROC_3DENH_SWITCH = 1,
-        USB_PROC_3DENH_SPACE = 2,
-        USB_PROC_REVERB = 4,
-        USB_PROC_REVERB_SWITCH = 1,
-        USB_PROC_REVERB_LEVEL = 2,
-        USB_PROC_REVERB_TIME = 3,
-        USB_PROC_REVERB_DELAY = 4,
-        USB_PROC_CHORUS = 5,
-        USB_PROC_CHORUS_SWITCH = 1,
-        USB_PROC_CHORUS_LEVEL = 2,
-        USB_PROC_CHORUS_RATE = 3,
-        USB_PROC_CHORUS_DEPTH = 4,
-        USB_PROC_DCR = 6,
-        USB_PROC_DCR_SWITCH = 1,
-        USB_PROC_DCR_RATIO = 2,
-        USB_PROC_DCR_MAX_AMP = 3,
-        USB_PROC_DCR_THRESHOLD = 4,
-        USB_PROC_DCR_ATTACK = 5,
-        USB_PROC_DCR_RELEASE = 6,
-};
 /*E-mu 0202(0404) eXtension Unit(XU) control*/
 enum {
@@ -198,22 +181,24 @@ static int check_mapped_selector_name(struct mixer_build *state, int unitid,
 /*
 * find an audio control unit with the given unit id
- * this doesn't return any clock related units, so they need to be handled elsewhere
 */
 static void *find_audio_control_unit(struct mixer_build *state, unsigned char unit)
 {
-        unsigned char *p;
+        /* we just parse the header */
+        struct uac_feature_unit_descriptor *hdr = NULL;
-        p = NULL;
+        while ((hdr = snd_usb_find_desc(state->buffer, state->buflen, hdr,
-        while ((p = snd_usb_find_desc(state->buffer, state->buflen, p,
+                                        USB_DT_CS_INTERFACE)) != NULL) {
-                                      USB_DT_CS_INTERFACE)) != NULL) {
+                if (hdr->bLength >= 4 &&
-                if (p[0] >= 4 && p[2] >= UAC_INPUT_TERMINAL && p[2] <= UAC2_EXTENSION_UNIT_V2 && p[3] == unit)
+                    hdr->bDescriptorSubtype >= UAC_INPUT_TERMINAL &&
-                        return p;
+                    hdr->bDescriptorSubtype <= UAC2_SAMPLE_RATE_CONVERTER &&
+                    hdr->bUnitID == unit)
+                        return hdr;
        }
        return NULL;
 }
 /*
 * copy a string with the given id
 */
@@ -306,49 +291,56 @@ static int get_abs_value(struct usb_mixer_elem_info *cval, int val)
 static int get_ctl_value_v1(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
 {
+        struct snd_usb_audio *chip = cval->mixer->chip;
        unsigned char buf[2];
        int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
        int timeout = 10;
        while (timeout-- > 0) {
-                if (snd_usb_ctl_msg(cval->mixer->chip->dev,
+                if (snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), request,
-                                    usb_rcvctrlpipe(cval->mixer->chip->dev, 0),
-                                    request,
                                    USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
-                                    validx, cval->mixer->ctrlif | (cval->id << 8),
+                                    validx, snd_usb_ctrl_intf(chip) | (cval->id << 8),
                                    buf, val_len, 100) >= val_len) {
                        *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
                        return 0;
                }
        }
        snd_printdd(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
-                    request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type);
+                    request, validx, snd_usb_ctrl_intf(chip) | (cval->id << 8), cval->val_type);
        return -EINVAL;
 }
 static int get_ctl_value_v2(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
 {
-        unsigned char buf[14]; /* enough space for one range of 4 bytes */
+        struct snd_usb_audio *chip = cval->mixer->chip;
+        unsigned char buf[2 + 3*sizeof(__u16)]; /* enough space for one range */
        unsigned char *val;
-        int ret;
+        int ret, size;
        __u8 bRequest;
-        bRequest = (request == UAC_GET_CUR) ?
+        if (request == UAC_GET_CUR) {
-                UAC2_CS_CUR : UAC2_CS_RANGE;
+                bRequest = UAC2_CS_CUR;
+                size = sizeof(__u16);
+        } else {
+                bRequest = UAC2_CS_RANGE;
+                size = sizeof(buf);
+        }
+        memset(buf, 0, sizeof(buf));
-        ret = snd_usb_ctl_msg(cval->mixer->chip->dev,
+        ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), bRequest,
-                              usb_rcvctrlpipe(cval->mixer->chip->dev, 0),
-                              bRequest,
                              USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
-                              validx, cval->mixer->ctrlif | (cval->id << 8),
+                              validx, snd_usb_ctrl_intf(chip) | (cval->id << 8),
-                              buf, sizeof(buf), 1000);
+                              buf, size, 1000);
        if (ret < 0) {
-                snd_printdd(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
+                snd_printk(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
-                            request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type);
+                           request, validx, snd_usb_ctrl_intf(chip) | (cval->id << 8), cval->val_type);
                return ret;
        }
+        /* FIXME: how should we handle multiple triplets here? */
        switch (request) {
        case UAC_GET_CUR:
                val = buf;
@@ -419,6 +411,7 @@ static int get_cur_mix_value(struct usb_mixer_elem_info *cval,
 int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
                                int request, int validx, int value_set)
 {
+        struct snd_usb_audio *chip = cval->mixer->chip;
        unsigned char buf[2];
        int val_len, timeout = 10;
@@ -441,15 +434,14 @@ int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
        buf[0] = value_set & 0xff;
        buf[1] = (value_set >> 8) & 0xff;
        while (timeout-- > 0)
-                if (snd_usb_ctl_msg(cval->mixer->chip->dev,
+                if (snd_usb_ctl_msg(chip->dev,
-                                    usb_sndctrlpipe(cval->mixer->chip->dev, 0),
+                                    usb_sndctrlpipe(chip->dev, 0), request,
-                                    request,
                                    USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
-                                    validx, cval->mixer->ctrlif | (cval->id << 8),
+                                    validx, snd_usb_ctrl_intf(chip) | (cval->id << 8),
                                    buf, val_len, 100) >= 0)
                        return 0;
        snd_printdd(KERN_ERR "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n",
-                    request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type, buf[0], buf[1]);
+                    request, validx, snd_usb_ctrl_intf(chip) | (cval->id << 8), cval->val_type, buf[0], buf[1]);
        return -EINVAL;
 }
@@ -462,6 +454,16 @@ static int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
                             int index, int value)
 {
        int err;
+        unsigned int read_only = (channel == 0) ?
+                cval->master_readonly :
+                cval->ch_readonly & (1 << (channel - 1));
+        if (read_only) {
+                snd_printdd(KERN_INFO "%s(): channel %d of control %d is read_only\n",
+                            __func__, channel, cval->control);
+                return 0;
+        }
        err = snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, (cval->control << 8) | channel,
                            value);
        if (err < 0)
@@ -594,9 +596,9 @@ static int get_term_name(struct mixer_build *state, struct usb_audio_term *iterm
                switch (iterm->type >> 16) {
                case UAC_SELECTOR_UNIT:
                        strcpy(name, "Selector"); return 8;
-                case UAC_PROCESSING_UNIT_V1:
+                case UAC1_PROCESSING_UNIT:
                        strcpy(name, "Process Unit"); return 12;
-                case UAC_EXTENSION_UNIT_V1:
+                case UAC1_EXTENSION_UNIT:
                        strcpy(name, "Ext Unit"); return 8;
                case UAC_MIXER_UNIT:
                        strcpy(name, "Mixer"); return 5;
@@ -631,6 +633,7 @@ static int get_term_name(struct mixer_build *state, struct usb_audio_term *iterm
 */
 static int check_input_term(struct mixer_build *state, int id, struct usb_audio_term *term)
 {
+        int err;
        void *p1;
        memset(term, 0, sizeof(*term));
@@ -651,6 +654,11 @@ static int check_input_term(struct mixer_build *state, int id, struct usb_audio_
                                term->channels = d->bNrChannels;
                                term->chconfig = le32_to_cpu(d->bmChannelConfig);
                                term->name = d->iTerminal;
+                                /* call recursively to get the clock selectors */
+                                err = check_input_term(state, d->bCSourceID, term);
+                                if (err < 0)
+                                        return err;
                        }
                        return 0;
                case UAC_FEATURE_UNIT: {
@@ -667,7 +675,8 @@ static int check_input_term(struct mixer_build *state, int id, struct usb_audio_
                        term->name = uac_mixer_unit_iMixer(d);
                        return 0;
                }
-                case UAC_SELECTOR_UNIT: {
+                case UAC_SELECTOR_UNIT:
+                case UAC2_CLOCK_SELECTOR: {
                        struct uac_selector_unit_descriptor *d = p1;
                        /* call recursively to retrieve the channel info */
                        if (check_input_term(state, d->baSourceID[0], term) < 0)
@@ -677,8 +686,8 @@ static int check_input_term(struct mixer_build *state, int id, struct usb_audio_
                        term->name = uac_selector_unit_iSelector(d);
                        return 0;
                }
-                case UAC_PROCESSING_UNIT_V1:
+                case UAC1_PROCESSING_UNIT:
-                case UAC_EXTENSION_UNIT_V1: {
+                case UAC1_EXTENSION_UNIT: {
                        struct uac_processing_unit_descriptor *d = p1;
                        if (d->bNrInPins) {
                                id = d->baSourceID[0];
@@ -690,6 +699,13 @@ static int check_input_term(struct mixer_build *state, int id, struct usb_audio_
                        term->name = uac_processing_unit_iProcessing(d, state->mixer->protocol);
                        return 0;
                }
+                case UAC2_CLOCK_SOURCE: {
+                        struct uac_clock_source_descriptor *d = p1;
+                        term->type = d->bDescriptorSubtype << 16; /* virtual type */
+                        term->id = id;
+                        term->name = d->iClockSource;
+                        return 0;
+                }
                default:
                        return -ENODEV;
                }
@@ -709,16 +725,20 @@ struct usb_feature_control_info {
 };
 static struct usb_feature_control_info audio_feature_info[] = {
-        { "Mute",               USB_MIXER_INV_BOOLEAN },
+        { "Mute",                       USB_MIXER_INV_BOOLEAN },
-        { "Volume",             USB_MIXER_S16 },
+        { "Volume",                     USB_MIXER_S16 },
        { "Tone Control - Bass",        USB_MIXER_S8 },
        { "Tone Control - Mid",         USB_MIXER_S8 },
        { "Tone Control - Treble",      USB_MIXER_S8 },
        { "Graphic Equalizer",          USB_MIXER_S8 }, /* FIXME: not implemeted yet */
-        { "Auto Gain Control",  USB_MIXER_BOOLEAN },
+        { "Auto Gain Control",          USB_MIXER_BOOLEAN },
-        { "Delay Control",      USB_MIXER_U16 },
+        { "Delay Control",              USB_MIXER_U16 },
-        { "Bass Boost",         USB_MIXER_BOOLEAN },
+        { "Bass Boost",                 USB_MIXER_BOOLEAN },
-        { "Loudness",           USB_MIXER_BOOLEAN },
+        { "Loudness",                   USB_MIXER_BOOLEAN },
+        /* UAC2 specific */
+        { "Input Gain Control",         USB_MIXER_U16 },
+        { "Input Gain Pad Control",     USB_MIXER_BOOLEAN },
+        { "Phase Inverter Control",     USB_MIXER_BOOLEAN },
 };
@@ -739,6 +759,8 @@ static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
 */
 static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
 {
+        struct snd_usb_audio *chip = cval->mixer->chip;
        /* for failsafe */
        cval->min = default_min;
        cval->max = cval->min + 1;
@@ -761,7 +783,7 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
                if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
                    get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
                        snd_printd(KERN_ERR "%d:%d: cannot get min/max values for control %d (id %d)\n",
-                                   cval->id, cval->mixer->ctrlif, cval->control, cval->id);
+                                   cval->id, snd_usb_ctrl_intf(chip), cval->control, cval->id);
                        return -EINVAL;
                }
                if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
@@ -958,7 +980,7 @@ static size_t append_ctl_name(struct snd_kcontrol *kctl, const char *str)
 static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
                              unsigned int ctl_mask, int control,
                              struct usb_audio_term *iterm, int unitid,
-                              int read_only)
+                              int readonly_mask)
 {
        struct uac_feature_unit_descriptor *desc = raw_desc;
        unsigned int len = 0;
@@ -970,7 +992,7 @@ static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
        control++; /* change from zero-based to 1-based value */
-        if (control == UAC_GRAPHIC_EQUALIZER_CONTROL) {
+        if (control == UAC_FU_GRAPHIC_EQUALIZER) {
                /* FIXME: not supported yet */
                return;
        }
@@ -989,20 +1011,25 @@ static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
        cval->control = control;
        cval->cmask = ctl_mask;
        cval->val_type = audio_feature_info[control-1].type;
-        if (ctl_mask == 0)
+        if (ctl_mask == 0) {
                cval->channels = 1;     /* master channel */
-        else {
+                cval->master_readonly = readonly_mask;
+        } else {
                int i, c = 0;
                for (i = 0; i < 16; i++)
                        if (ctl_mask & (1 << i))
                                c++;
                cval->channels = c;
+                cval->ch_readonly = readonly_mask;
        }
        /* get min/max values */
        get_min_max(cval, 0);
-        if (read_only)
+        /* if all channels in the mask are marked read-only, make the control
+         * read-only. set_cur_mix_value() will check the mask again and won't
+         * issue write commands to read-only channels. */
+        if (cval->channels == readonly_mask)
                kctl = snd_ctl_new1(&usb_feature_unit_ctl_ro, cval);
        else
                kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
@@ -1021,8 +1048,8 @@ static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
                                kctl->id.name, sizeof(kctl->id.name));
        switch (control) {
-        case UAC_MUTE_CONTROL:
+        case UAC_FU_MUTE:
-        case UAC_VOLUME_CONTROL:
+        case UAC_FU_VOLUME:
                /* determine the control name.  the rule is:
                 * - if a name id is given in descriptor, use it.
                 * - if the connected input can be determined, then use the name
@@ -1049,9 +1076,9 @@ static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
                                len = append_ctl_name(kctl, " Playback");
                        }
                }
-                append_ctl_name(kctl, control == UAC_MUTE_CONTROL ?
+                append_ctl_name(kctl, control == UAC_FU_MUTE ?
                                " Switch" : " Volume");
-                if (control == UAC_VOLUME_CONTROL) {
+                if (control == UAC_FU_VOLUME) {
                        kctl->tlv.c = mixer_vol_tlv;
                        kctl->vd[0].access |= 
                                SNDRV_CTL_ELEM_ACCESS_TLV_READ |
@@ -1096,6 +1123,19 @@ static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
                }
                break;
+        case USB_ID(0x046d, 0x0809):
+        case USB_ID(0x046d, 0x0991):
+        /* Most audio usb devices lie about volume resolution.
+         * Most Logitech webcams have res = 384.
+         * Proboly there is some logitech magic behind this number --fishor
+         */
+                if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
+                        snd_printk(KERN_INFO
+                                "set resolution quirk: cval->res = 384\n");
+                        cval->res = 384;
+                }
+                break;
        }
        snd_printdd(KERN_INFO "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
@@ -1150,7 +1190,7 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void
                snd_printk(KERN_INFO
                           "usbmixer: master volume quirk for PCM2702 chip\n");
                /* disable non-functional volume control */
-                master_bits &= ~UAC_FU_VOLUME;
+                master_bits &= ~UAC_CONTROL_BIT(UAC_FU_VOLUME);
                break;
        }
        if (channels > 0)
@@ -1175,32 +1215,27 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void
                }
        } else { /* UAC_VERSION_2 */
                for (i = 0; i < 30/2; i++) {
-                        /* From the USB Audio spec v2.0:
-                           bmaControls() is a (ch+1)-element array of 4-byte bitmaps,
-                           each containing a set of bit pairs. If a Control is present,
-                           it must be Host readable. If a certain Control is not
-                           present then the bit pair must be set to 0b00.
-                           If a Control is present but read-only, the bit pair must be
-                           set to 0b01. If a Control is also Host programmable, the bit
-                           pair must be set to 0b11. The value 0b10 is not allowed. */
                        unsigned int ch_bits = 0;
                        unsigned int ch_read_only = 0;
                        for (j = 0; j < channels; j++) {
                                unsigned int mask = snd_usb_combine_bytes(bmaControls + csize * (j+1), csize);
-                                if (mask & (1 << (i * 2))) {
+                                if (uac2_control_is_readable(mask, i)) {
                                        ch_bits |= (1 << j);
-                                        if (~mask & (1 << ((i * 2) + 1)))
+                                        if (!uac2_control_is_writeable(mask, i))
                                                ch_read_only |= (1 << j);
                                }
                        }
-                        /* FIXME: the whole unit is read-only if any of the channels is marked read-only */
+                        /* NOTE: build_feature_ctl() will mark the control read-only if all channels
+                         * are marked read-only in the descriptors. Otherwise, the control will be
+                         * reported as writeable, but the driver will not actually issue a write
+                         * command for read-only channels */
                        if (ch_bits & 1) /* the first channel must be set (for ease of programming) */
-                                build_feature_ctl(state, _ftr, ch_bits, i, &iterm, unitid, !!ch_read_only);
+                                build_feature_ctl(state, _ftr, ch_bits, i, &iterm, unitid, ch_read_only);
-                        if (master_bits & (1 << i * 2))
+                        if (uac2_control_is_readable(master_bits, i))
                                build_feature_ctl(state, _ftr, 0, i, &iterm, unitid,
-                                                  ~master_bits & (1 << ((i * 2) + 1)));
+                                                  !uac2_control_is_writeable(master_bits, i));
                }
        }
@@ -1392,51 +1427,51 @@ struct procunit_info {
 };
 static struct procunit_value_info updown_proc_info[] = {
-        { USB_PROC_UPDOWN_SWITCH, "Switch", USB_MIXER_BOOLEAN },
+        { UAC_UD_ENABLE, "Switch", USB_MIXER_BOOLEAN },
-        { USB_PROC_UPDOWN_MODE_SEL, "Mode Select", USB_MIXER_U8, 1 },
+        { UAC_UD_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 },
        { 0 }
 };
 static struct procunit_value_info prologic_proc_info[] = {
-        { USB_PROC_PROLOGIC_SWITCH, "Switch", USB_MIXER_BOOLEAN },
+        { UAC_DP_ENABLE, "Switch", USB_MIXER_BOOLEAN },
-        { USB_PROC_PROLOGIC_MODE_SEL, "Mode Select", USB_MIXER_U8, 1 },
+        { UAC_DP_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 },
        { 0 }
 };
 static struct procunit_value_info threed_enh_proc_info[] = {
-        { USB_PROC_3DENH_SWITCH, "Switch", USB_MIXER_BOOLEAN },
+        { UAC_3D_ENABLE, "Switch", USB_MIXER_BOOLEAN },
-        { USB_PROC_3DENH_SPACE, "Spaciousness", USB_MIXER_U8 },
+        { UAC_3D_SPACE, "Spaciousness", USB_MIXER_U8 },
        { 0 }
 };
 static struct procunit_value_info reverb_proc_info[] = {
-        { USB_PROC_REVERB_SWITCH, "Switch", USB_MIXER_BOOLEAN },
+        { UAC_REVERB_ENABLE, "Switch", USB_MIXER_BOOLEAN },
-        { USB_PROC_REVERB_LEVEL, "Level", USB_MIXER_U8 },
+        { UAC_REVERB_LEVEL, "Level", USB_MIXER_U8 },
-        { USB_PROC_REVERB_TIME, "Time", USB_MIXER_U16 },
+        { UAC_REVERB_TIME, "Time", USB_MIXER_U16 },
-        { USB_PROC_REVERB_DELAY, "Delay", USB_MIXER_U8 },
+        { UAC_REVERB_FEEDBACK, "Feedback", USB_MIXER_U8 },
        { 0 }
 };
 static struct procunit_value_info chorus_proc_info[] = {
-        { USB_PROC_CHORUS_SWITCH, "Switch", USB_MIXER_BOOLEAN },
+        { UAC_CHORUS_ENABLE, "Switch", USB_MIXER_BOOLEAN },
-        { USB_PROC_CHORUS_LEVEL, "Level", USB_MIXER_U8 },
+        { UAC_CHORUS_LEVEL, "Level", USB_MIXER_U8 },
-        { USB_PROC_CHORUS_RATE, "Rate", USB_MIXER_U16 },
+        { UAC_CHORUS_RATE, "Rate", USB_MIXER_U16 },
-        { USB_PROC_CHORUS_DEPTH, "Depth", USB_MIXER_U16 },
+        { UAC_CHORUS_DEPTH, "Depth", USB_MIXER_U16 },
        { 0 }
 };
 static struct procunit_value_info dcr_proc_info[] = {
-        { USB_PROC_DCR_SWITCH, "Switch", USB_MIXER_BOOLEAN },
+        { UAC_DCR_ENABLE, "Switch", USB_MIXER_BOOLEAN },
-        { USB_PROC_DCR_RATIO, "Ratio", USB_MIXER_U16 },
+        { UAC_DCR_RATE, "Ratio", USB_MIXER_U16 },
-        { USB_PROC_DCR_MAX_AMP, "Max Amp", USB_MIXER_S16 },
+        { UAC_DCR_MAXAMPL, "Max Amp", USB_MIXER_S16 },
-        { USB_PROC_DCR_THRESHOLD, "Threshold", USB_MIXER_S16 },
+        { UAC_DCR_THRESHOLD, "Threshold", USB_MIXER_S16 },
-        { USB_PROC_DCR_ATTACK, "Attack Time", USB_MIXER_U16 },
+        { UAC_DCR_ATTACK_TIME, "Attack Time", USB_MIXER_U16 },
-        { USB_PROC_DCR_RELEASE, "Release Time", USB_MIXER_U16 },
+        { UAC_DCR_RELEASE_TIME, "Release Time", USB_MIXER_U16 },
        { 0 }
 };
 static struct procunit_info procunits[] = {
-        { USB_PROC_UPDOWN, "Up Down", updown_proc_info },
+        { UAC_PROCESS_UP_DOWNMIX, "Up Down", updown_proc_info },
-        { USB_PROC_PROLOGIC, "Dolby Prologic", prologic_proc_info },
+        { UAC_PROCESS_DOLBY_PROLOGIC, "Dolby Prologic", prologic_proc_info },
-        { USB_PROC_3DENH, "3D Stereo Extender", threed_enh_proc_info },
+        { UAC_PROCESS_STEREO_EXTENDER, "3D Stereo Extender", threed_enh_proc_info },
-        { USB_PROC_REVERB, "Reverb", reverb_proc_info },
+        { UAC_PROCESS_REVERB, "Reverb", reverb_proc_info },
-        { USB_PROC_CHORUS, "Chorus", chorus_proc_info },
+        { UAC_PROCESS_CHORUS, "Chorus", chorus_proc_info },
-        { USB_PROC_DCR, "DCR", dcr_proc_info },
+        { UAC_PROCESS_DYN_RANGE_COMP, "DCR", dcr_proc_info },
        { 0 },
 };
 /*
@@ -1524,7 +1559,7 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, void *raw
                cval->channels = 1;
                /* get min/max values */
-                if (type == USB_PROC_UPDOWN && cval->control == USB_PROC_UPDOWN_MODE_SEL) {
+                if (type == UAC_PROCESS_UP_DOWNMIX && cval->control == UAC_UD_MODE_SELECT) {
                        __u8 *control_spec = uac_processing_unit_specific(desc, state->mixer->protocol);
                        /* FIXME: hard-coded */
                        cval->min = 1;
@@ -1619,7 +1654,7 @@ static int mixer_ctl_selector_get(struct snd_kcontrol *kcontrol, struct snd_ctl_
        struct usb_mixer_elem_info *cval = kcontrol->private_data;
        int val, err;
-        err = get_cur_ctl_value(cval, 0, &val);
+        err = get_cur_ctl_value(cval, cval->control << 8, &val);
        if (err < 0) {
                if (cval->mixer->ignore_ctl_error) {
                        ucontrol->value.enumerated.item[0] = 0;
@@ -1638,7 +1673,7 @@ static int mixer_ctl_selector_put(struct snd_kcontrol *kcontrol, struct snd_ctl_
        struct usb_mixer_elem_info *cval = kcontrol->private_data;
        int val, oval, err;
-        err = get_cur_ctl_value(cval, 0, &oval);
+        err = get_cur_ctl_value(cval, cval->control << 8, &oval);
        if (err < 0) {
                if (cval->mixer->ignore_ctl_error)
                        return 0;
@@ -1647,7 +1682,7 @@ static int mixer_ctl_selector_put(struct snd_kcontrol *kcontrol, struct snd_ctl_
        val = ucontrol->value.enumerated.item[0];
        val = get_abs_value(cval, val);
        if (val != oval) {
-                set_cur_ctl_value(cval, 0, val);
+                set_cur_ctl_value(cval, cval->control << 8, val);
                return 1;
        }
        return 0;
@@ -1729,6 +1764,11 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, void
        cval->res = 1;
        cval->initialized = 1;
+        if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR)
+                cval->control = UAC2_CX_CLOCK_SELECTOR;
+        else
+                cval->control = 0;
        namelist = kmalloc(sizeof(char *) * desc->bNrInPins, GFP_KERNEL);
        if (! namelist) {
                snd_printk(KERN_ERR "cannot malloc\n");
@@ -1778,7 +1818,9 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, void
                if (! len)
                        strlcpy(kctl->id.name, "USB", sizeof(kctl->id.name));
-                if ((state->oterm.type & 0xff00) == 0x0100)
+                if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR)
+                        append_ctl_name(kctl, " Clock Source");
+                else if ((state->oterm.type & 0xff00) == 0x0100)
                        append_ctl_name(kctl, " Capture Source");
                else
                        append_ctl_name(kctl, " Playback Source");
@@ -1812,20 +1854,22 @@ static int parse_audio_unit(struct mixer_build *state, int unitid)
        switch (p1[2]) {
        case UAC_INPUT_TERMINAL:
+        case UAC2_CLOCK_SOURCE:
                return 0; /* NOP */
        case UAC_MIXER_UNIT:
                return parse_audio_mixer_unit(state, unitid, p1);
        case UAC_SELECTOR_UNIT:
+        case UAC2_CLOCK_SELECTOR:
                return parse_audio_selector_unit(state, unitid, p1);
        case UAC_FEATURE_UNIT:
                return parse_audio_feature_unit(state, unitid, p1);
-        case UAC_PROCESSING_UNIT_V1:
+        case UAC1_PROCESSING_UNIT:
        /*   UAC2_EFFECT_UNIT has the same value */
                if (state->mixer->protocol == UAC_VERSION_1)
                        return parse_audio_processing_unit(state, unitid, p1);
                else
                        return 0; /* FIXME - effect units not implemented yet */
-        case UAC_EXTENSION_UNIT_V1:
+        case UAC1_EXTENSION_UNIT:
        /*   UAC2_PROCESSING_UNIT_V2 has the same value */
                if (state->mixer->protocol == UAC_VERSION_1)
                        return parse_audio_extension_unit(state, unitid, p1);
@@ -1869,7 +1913,7 @@ static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
        struct usb_host_interface *hostif;
        void *p;
-        hostif = &usb_ifnum_to_if(mixer->chip->dev, mixer->ctrlif)->altsetting[0];
+        hostif = mixer->chip->ctrl_intf;
        memset(&state, 0, sizeof(state));
        state.chip = mixer->chip;
        state.mixer = mixer;
@@ -1889,7 +1933,7 @@ static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
        p = NULL;
        while ((p = snd_usb_find_csint_desc(hostif->extra, hostif->extralen, p, UAC_OUTPUT_TERMINAL)) != NULL) {
                if (mixer->protocol == UAC_VERSION_1) {
-                        struct uac_output_terminal_descriptor_v1 *desc = p;
+                        struct uac1_output_terminal_descriptor *desc = p;
                        if (desc->bLength < sizeof(*desc))
                                continue; /* invalid descriptor? */
@@ -1912,6 +1956,11 @@ static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
                        err = parse_audio_unit(&state, desc->bSourceID);
                        if (err < 0)
                                return err;
+                        /* for UAC2, use the same approach to also add the clock selectors */
+                        err = parse_audio_unit(&state, desc->bCSourceID);
+                        if (err < 0)
+                                return err;
                }
        }
@@ -1956,7 +2005,7 @@ static void snd_usb_mixer_proc_read(struct snd_info_entry *entry,
        list_for_each_entry(mixer, &chip->mixer_list, list) {
                snd_iprintf(buffer,
                        "USB Mixer: usb_id=0x%08x, ctrlif=%i, ctlerr=%i\n",
-                                chip->usb_id, mixer->ctrlif,
+                                chip->usb_id, snd_usb_ctrl_intf(chip),
                                mixer->ignore_ctl_error);
                snd_iprintf(buffer, "Card: %s\n", chip->card->longname);
                for (unitid = 0; unitid < MAX_ID_ELEMS; unitid++) {
@@ -2074,7 +2123,7 @@ static int snd_usb_mixer_status_create(struct usb_mixer_interface *mixer)
        int buffer_length;
        unsigned int epnum;
-        hostif = &usb_ifnum_to_if(mixer->chip->dev, mixer->ctrlif)->altsetting[0];
+        hostif = mixer->chip->ctrl_intf;
        /* we need one interrupt input endpoint */
        if (get_iface_desc(hostif)->bNumEndpoints < 1)
                return 0;
@@ -2117,7 +2166,6 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
        if (!mixer)
                return -ENOMEM;
        mixer->chip = chip;
-        mixer->ctrlif = ctrlif;
        mixer->ignore_ctl_error = ignore_error;
        mixer->id_elems = kcalloc(MAX_ID_ELEMS, sizeof(*mixer->id_elems),
                                  GFP_KERNEL);
diff --git a/sound/usb/mixer.h b/sound/usb/mixer.h
index 130123854a6c..26c636c5c93a 100644
--- a/sound/usb/mixer.h
+++ b/sound/usb/mixer.h
@@ -3,7 +3,6 @@
 struct usb_mixer_interface {
        struct snd_usb_audio *chip;
-        unsigned int ctrlif;
        struct list_head list;
        unsigned int ignore_ctl_error;
        struct urb *urb;
@@ -34,6 +33,8 @@ struct usb_mixer_elem_info {
        unsigned int id;
        unsigned int control;   /* CS or ICN (high byte) */
        unsigned int cmask; /* channel mask bitmap: 0 = master */
+        unsigned int ch_readonly;
+        unsigned int master_readonly;
        int channels;
        int val_type;
        int min, max, res;
diff --git a/sound/usb/mixer_maps.c b/sound/usb/mixer_maps.c
index d93fc89beba8..f1324c423835 100644
--- a/sound/usb/mixer_maps.c
+++ b/sound/usb/mixer_maps.c
@@ -85,8 +85,8 @@ static struct usbmix_name_map extigy_map[] = {
        /* 16: MU (w/o controls) */
        { 17, NULL, 1 }, /* DISABLED: PU-switch (any effect?) */
        { 17, "Channel Routing", 2 },   /* PU: mode select */
-        { 18, "Tone Control - Bass", UAC_BASS_CONTROL }, /* FU */
+        { 18, "Tone Control - Bass", UAC_FU_BASS }, /* FU */
-        { 18, "Tone Control - Treble", UAC_TREBLE_CONTROL }, /* FU */
+        { 18, "Tone Control - Treble", UAC_FU_TREBLE }, /* FU */
        { 18, "Master Playback" }, /* FU; others */
        /* 19: OT speaker */
        /* 20: OT headphone */
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index 056587de7be4..3634cedf9306 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -31,6 +31,7 @@
 #include "urb.h"
 #include "helper.h"
 #include "pcm.h"
+#include "clock.h"
 /*
 * return the current pcm pointer.  just based on the hwptr_done value.
@@ -181,103 +182,6 @@ int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
        return -EINVAL;
 }
-static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface,
-                              struct usb_host_interface *alts,
-                              struct audioformat *fmt, int rate)
-{
-        struct usb_device *dev = chip->dev;
-        unsigned int ep;
-        unsigned char data[3];
-        int err, crate;
-        ep = get_endpoint(alts, 0)->bEndpointAddress;
-        /* if endpoint doesn't have sampling rate control, bail out */
-        if (!(fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE)) {
-                snd_printk(KERN_WARNING "%d:%d:%d: endpoint lacks sample rate attribute bit, cannot set.\n",
-                                   dev->devnum, iface, fmt->altsetting);
-                return 0;
-        }
-        data[0] = rate;
-        data[1] = rate >> 8;
-        data[2] = rate >> 16;
-        if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
-                                   USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
-                                   UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
-                                   data, sizeof(data), 1000)) < 0) {
-                snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep %#x\n",
-                           dev->devnum, iface, fmt->altsetting, rate, ep);
-                return err;
-        }
-        if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
-                                   USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
-                                   UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep,
-                                   data, sizeof(data), 1000)) < 0) {
-                snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep %#x\n",
-                           dev->devnum, iface, fmt->altsetting, ep);
-                return 0; /* some devices don't support reading */
-        }
-        crate = data[0] | (data[1] << 8) | (data[2] << 16);
-        if (crate != rate) {
-                snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
-                // runtime->rate = crate;
-        }
-        return 0;
-}
-static int set_sample_rate_v2(struct snd_usb_audio *chip, int iface,
-                              struct usb_host_interface *alts,
-                              struct audioformat *fmt, int rate)
-{
-        struct usb_device *dev = chip->dev;
-        unsigned char data[4];
-        int err, crate;
-        data[0] = rate;
-        data[1] = rate >> 8;
-        data[2] = rate >> 16;
-        data[3] = rate >> 24;
-        if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR,
-                                   USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
-                                   UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8,
-                                   data, sizeof(data), 1000)) < 0) {
-                snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d (v2)\n",
-                           dev->devnum, iface, fmt->altsetting, rate);
-                return err;
-        }
-        if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR,
-                                   USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
-                                   UAC2_CS_CONTROL_SAM_FREQ << 8, chip->clock_id << 8,
-                                   data, sizeof(data), 1000)) < 0) {
-                snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq (v2)\n",
-                           dev->devnum, iface, fmt->altsetting);
-                return err;
-        }
-        crate = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
-        if (crate != rate)
-                snd_printd(KERN_WARNING "current rate %d is different from the runtime rate %d\n", crate, rate);
-        return 0;
-}
-int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
-                             struct usb_host_interface *alts,
-                             struct audioformat *fmt, int rate)
-{
-        struct usb_interface_descriptor *altsd = get_iface_desc(alts);
-        switch (altsd->bInterfaceProtocol) {
-        case UAC_VERSION_1:
-                return set_sample_rate_v1(chip, iface, alts, fmt, rate);
-        case UAC_VERSION_2:
-                return set_sample_rate_v2(chip, iface, alts, fmt, rate);
-        }
-        return -EINVAL;
-}
 /*
 * find a matching format and set up the interface
 */
@@ -732,7 +636,7 @@ static int hw_rule_period_time(struct snd_pcm_hw_params *params,
                min_datainterval = min(min_datainterval, fp->datainterval);
        }
        if (min_datainterval == 0xff) {
-                hwc_debug("  --> get emtpy\n");
+                hwc_debug("  --> get empty\n");
                it->empty = 1;
                return -EINVAL;
        }
diff --git a/sound/usb/pcm.h b/sound/usb/pcm.h
index 1c931b68f3b5..ed3e283f618d 100644
--- a/sound/usb/pcm.h
+++ b/sound/usb/pcm.h
@@ -7,8 +7,5 @@ int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
                       struct usb_host_interface *alts,
                       struct audioformat *fmt);
-int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
-                             struct usb_host_interface *alts,
-                             struct audioformat *fmt, int rate);
 #endif /* __USBAUDIO_PCM_H */
diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h
index f8797f61a24b..2e8003f98fca 100644
--- a/sound/usb/quirks-table.h
+++ b/sound/usb/quirks-table.h
@@ -2152,7 +2152,21 @@ YAMAHA_DEVICE(0x7010, "UB99"),
        }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7201),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-850",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                       USB_DEVICE_ID_MATCH_INT_CLASS |
                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2166,7 +2180,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
        }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7202),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                       USB_DEVICE_ID_MATCH_INT_CLASS |
                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2180,7 +2194,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
        }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7203),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                       USB_DEVICE_ID_MATCH_INT_CLASS |
                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2194,7 +2208,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
        }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7204),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                       USB_DEVICE_ID_MATCH_INT_CLASS |
                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2208,7 +2222,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
        }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7205),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                       USB_DEVICE_ID_MATCH_INT_CLASS |
                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2222,7 +2236,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
        }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7250),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                       USB_DEVICE_ID_MATCH_INT_CLASS |
                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2236,7 +2250,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
        }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7230),
+        USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                       USB_DEVICE_ID_MATCH_INT_CLASS |
                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2244,7 +2258,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
                .vendor_name = "Hauppauge",
-                .product_name = "HVR-850",
+                .product_name = "HVR-950Q",
                .ifnum = QUIRK_ANY_INTERFACE,
                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
        }
diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
index b45e54c09ba2..9a9da09586a5 100644
--- a/sound/usb/quirks.c
+++ b/sound/usb/quirks.c
@@ -32,6 +32,7 @@
 #include "helper.h"
 #include "endpoint.h"
 #include "pcm.h"
+#include "clock.h"
 /*
 * handle the quirks for the contained interfaces
diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h
index 06ebf24d3a4d..24d3319cc34d 100644
--- a/sound/usb/usbaudio.h
+++ b/sound/usb/usbaudio.h
@@ -40,9 +40,6 @@ struct snd_usb_audio {
        int num_interfaces;
        int num_suspended_intf;
-        /* for audio class v2 */
-        int clock_id;
        struct list_head pcm_list;      /* list of pcm streams */
        int pcm_devs;
@@ -53,6 +50,8 @@ struct snd_usb_audio {
        int setup;                      /* from the 'device_setup' module param */
        int nrpacks;                    /* from the 'nrpacks' module param */
        int async_unlink;               /* from the 'async_unlink' module param */
+        struct usb_host_interface *ctrl_intf;   /* the audio control interface */
 };
 /*
author	Mark Brown <broonie@opensource.wolfsonmicro.com>	2010-08-16 13:42:58 -0400
committer	Mark Brown <broonie@opensource.wolfsonmicro.com>	2010-08-16 13:42:58 -0400
commit	e4862f2f6f5653dfb67f3ba2b6f0bc74516ed51a (patch)
tree	1db5a0540a4eecfad9b7daee476b985e82ddc810 /sound
parent	ec62dbd7eb8e3dddb221da89ecbcea0fc3dee8c1 (diff)
parent	b2c1e07b81a126e5846dfc3d36f559d861df59f4 (diff)