442 files changed, 12427 insertions, 4972 deletions

diff --git a/sound/aoa/soundbus/i2sbus/control.c b/sound/aoa/soundbus/i2sbus/control.c
index 4dc9b49c02cf..f4495decc699 100644
--- a/sound/aoa/soundbus/i2sbus/control.c
+++ b/sound/aoa/soundbus/i2sbus/control.c
@@ -9,8 +9,8 @@
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 
-#include <asm/io.h>
 #include <asm/prom.h>
 #include <asm/macio.h>
 #include <asm/pmac_feature.h>
diff --git a/sound/aoa/soundbus/i2sbus/core.c b/sound/aoa/soundbus/i2sbus/core.c
index 4e2b4fbf2496..b9737fae656a 100644
--- a/sound/aoa/soundbus/i2sbus/core.c
+++ b/sound/aoa/soundbus/i2sbus/core.c
@@ -74,10 +74,9 @@ static void i2sbus_release_dev(struct device *dev)
         int i;
 
         i2sdev = container_of(dev, struct i2sbus_dev, sound.ofdev.dev);
-
-        if (i2sdev->intfregs) iounmap(i2sdev->intfregs);
-        if (i2sdev->out.dbdma) iounmap(i2sdev->out.dbdma);
-        if (i2sdev->in.dbdma) iounmap(i2sdev->in.dbdma);
+        iounmap(i2sdev->intfregs);
+        iounmap(i2sdev->out.dbdma);
+        iounmap(i2sdev->in.dbdma);
         for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++)
                 release_and_free_resource(i2sdev->allocated_resource[i]);
         free_dbdma_descriptor_ring(i2sdev, &i2sdev->out.dbdma_ring);
@@ -318,9 +317,9 @@ static int i2sbus_add_dev(struct macio_dev *macio,
                         free_irq(dev->interrupts[i], dev);
         free_dbdma_descriptor_ring(dev, &dev->out.dbdma_ring);
         free_dbdma_descriptor_ring(dev, &dev->in.dbdma_ring);
-        if (dev->intfregs) iounmap(dev->intfregs);
-        if (dev->out.dbdma) iounmap(dev->out.dbdma);
-        if (dev->in.dbdma) iounmap(dev->in.dbdma);
+        iounmap(dev->intfregs);
+        iounmap(dev->out.dbdma);
+        iounmap(dev->in.dbdma);
         for (i=0;i<3;i++)
                 release_and_free_resource(dev->allocated_resource[i]);
         mutex_destroy(&dev->lock);
@@ -381,10 +380,8 @@ static int i2sbus_suspend(struct macio_dev* dev, pm_message_t state)
 
         list_for_each_entry(i2sdev, &control->list, item) {
                 /* Notify Alsa */
-                if (i2sdev->sound.pcm) {
-                        /* Suspend PCM streams */
-                        snd_pcm_suspend_all(i2sdev->sound.pcm);
-                }
+                /* Suspend PCM streams */
+                snd_pcm_suspend_all(i2sdev->sound.pcm);
 
                 /* Notify codecs */
                 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
diff --git a/sound/aoa/soundbus/i2sbus/pcm.c b/sound/aoa/soundbus/i2sbus/pcm.c
index 7b74a4ba75f8..053b09c79053 100644
--- a/sound/aoa/soundbus/i2sbus/pcm.c
+++ b/sound/aoa/soundbus/i2sbus/pcm.c
@@ -6,7 +6,7 @@
  * GPL v2, can be found in COPYING.
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <sound/core.h>
@@ -968,7 +968,6 @@ i2sbus_attach_codec(struct soundbus_dev *dev, struct snd_card *card,
                         printk(KERN_DEBUG "i2sbus: failed to create pcm\n");
                         goto out_put_ci_module;
                 }
-                dev->pcm->dev = &dev->ofdev.dev;
         }
 
         /* ALSA yet again sucks.
@@ -988,6 +987,8 @@ i2sbus_attach_codec(struct soundbus_dev *dev, struct snd_card *card,
                         goto out_put_ci_module;
                 snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                 &i2sbus_playback_ops);
+                dev->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].dev.parent =
+                        &dev->ofdev.dev;
                 i2sdev->out.created = 1;
         }
 
@@ -1003,6 +1004,8 @@ i2sbus_attach_codec(struct soundbus_dev *dev, struct snd_card *card,
                         goto out_put_ci_module;
                 snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_CAPTURE,
                                 &i2sbus_record_ops);
+                dev->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].dev.parent =
+                        &dev->ofdev.dev;
                 i2sdev->in.created = 1;
         }
 
diff --git a/sound/arm/aaci.c b/sound/arm/aaci.c
index 0e83a73efb16..4140b1b95054 100644
--- a/sound/arm/aaci.c
+++ b/sound/arm/aaci.c
@@ -889,8 +889,8 @@ static int aaci_probe_ac97(struct aaci *aaci)
 static void aaci_free_card(struct snd_card *card)
 {
         struct aaci *aaci = card->private_data;
-        if (aaci->base)
-                iounmap(aaci->base);
+
+        iounmap(aaci->base);
 }
 
 static struct aaci *aaci_init_card(struct amba_device *dev)
diff --git a/sound/atmel/ac97c.c b/sound/atmel/ac97c.c
index 4f6b14d704f3..cf4cedf2b420 100644
--- a/sound/atmel/ac97c.c
+++ b/sound/atmel/ac97c.c
@@ -22,6 +22,9 @@
 #include <linux/gpio.h>
 #include <linux/types.h>
 #include <linux/io.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/of_device.h>
 
 #include <sound/core.h>
 #include <sound/initval.h>
@@ -34,10 +37,10 @@
 #include <linux/platform_data/dma-dw.h>
 #include <linux/dma/dw.h>
 
+#ifdef CONFIG_AVR32
 #include <mach/cpu.h>
-
-#ifdef CONFIG_ARCH_AT91
-#include <mach/hardware.h>
+#else
+#define cpu_is_at32ap7000() 0
 #endif
 
 #include "ac97c.h"
@@ -902,6 +905,40 @@ static void atmel_ac97c_reset(struct atmel_ac97c *chip)
         }
 }
 
+#ifdef CONFIG_OF
+static const struct of_device_id atmel_ac97c_dt_ids[] = {
+        { .compatible = "atmel,at91sam9263-ac97c", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, atmel_ac97c_dt_ids);
+
+static struct ac97c_platform_data *atmel_ac97c_probe_dt(struct device *dev)
+{
+        struct ac97c_platform_data *pdata;
+        struct device_node *node = dev->of_node;
+        const struct of_device_id *match;
+
+        if (!node) {
+                dev_err(dev, "Device does not have associated DT data\n");
+                return ERR_PTR(-EINVAL);
+        }
+
+        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return ERR_PTR(-ENOMEM);
+
+        pdata->reset_pin = of_get_named_gpio(dev->of_node, "ac97-gpios", 2);
+
+        return pdata;
+}
+#else
+static struct ac97c_platform_data *atmel_ac97c_probe_dt(struct device *dev)
+{
+        dev_err(dev, "no platform data defined\n");
+        return ERR_PTR(-ENXIO);
+}
+#endif
+
 static int atmel_ac97c_probe(struct platform_device *pdev)
 {
         struct snd_card                 *card;
@@ -922,10 +959,11 @@ static int atmel_ac97c_probe(struct platform_device *pdev)
                 return -ENXIO;
         }
 
-        pdata = pdev->dev.platform_data;
+        pdata = dev_get_platdata(&pdev->dev);
         if (!pdata) {
-                dev_dbg(&pdev->dev, "no platform data\n");
-                return -ENXIO;
+                pdata = atmel_ac97c_probe_dt(&pdev->dev);
+                if (IS_ERR(pdata))
+                        return PTR_ERR(pdata);
         }
 
         irq = platform_get_irq(pdev, 0);
@@ -1204,6 +1242,7 @@ static struct platform_driver atmel_ac97c_driver = {
         .driver         = {
                 .name   = "atmel_ac97c",
                 .pm     = ATMEL_AC97C_PM_OPS,
+                .of_match_table = of_match_ptr(atmel_ac97c_dt_ids),
         },
 };
 module_platform_driver(atmel_ac97c_driver);
diff --git a/sound/core/compress_offload.c b/sound/core/compress_offload.c
index 89028fab64fd..b123c42e7dc8 100644
--- a/sound/core/compress_offload.c
+++ b/sound/core/compress_offload.c
@@ -868,12 +868,12 @@ static int snd_compress_dev_register(struct snd_device *device)
                 return -EBADFD;
         compr = device->device_data;
 
-        sprintf(str, "comprC%iD%i", compr->card->number, compr->device);
         pr_debug("reg %s for device %s, direction %d\n", str, compr->name,
                         compr->direction);
         /* register compressed device */
-        ret = snd_register_device(SNDRV_DEVICE_TYPE_COMPRESS, compr->card,
-                        compr->device, &snd_compr_file_ops, compr, str);
+        ret = snd_register_device(SNDRV_DEVICE_TYPE_COMPRESS,
+                                  compr->card, compr->device,
+                                  &snd_compr_file_ops, compr, &compr->dev);
         if (ret < 0) {
                 pr_err("snd_register_device failed\n %d", ret);
                 return ret;
@@ -887,8 +887,16 @@ static int snd_compress_dev_disconnect(struct snd_device *device)
         struct snd_compr *compr;
 
         compr = device->device_data;
-        snd_unregister_device(SNDRV_DEVICE_TYPE_COMPRESS, compr->card,
-                compr->device);
+        snd_unregister_device(&compr->dev);
+        return 0;
+}
+
+static int snd_compress_dev_free(struct snd_device *device)
+{
+        struct snd_compr *compr;
+
+        compr = device->device_data;
+        put_device(&compr->dev);
         return 0;
 }
 
@@ -903,7 +911,7 @@ int snd_compress_new(struct snd_card *card, int device,
                         int dirn, struct snd_compr *compr)
 {
         static struct snd_device_ops ops = {
-                .dev_free = NULL,
+                .dev_free = snd_compress_dev_free,
                 .dev_register = snd_compress_dev_register,
                 .dev_disconnect = snd_compress_dev_disconnect,
         };
@@ -911,6 +919,10 @@ int snd_compress_new(struct snd_card *card, int device,
         compr->card = card;
         compr->device = device;
         compr->direction = dirn;
+
+        snd_device_initialize(&compr->dev, card);
+        dev_set_name(&compr->dev, "comprC%iD%i", card->number, device);
+
         return snd_device_new(card, SNDRV_DEV_COMPRESS, compr, &ops);
 }
 EXPORT_SYMBOL_GPL(snd_compress_new);
@@ -948,7 +960,7 @@ int snd_compress_register(struct snd_compr *device)
 {
         int retval;
 
-        if (device->name == NULL || device->dev == NULL || device->ops == NULL)
+        if (device->name == NULL || device->ops == NULL)
                 return -EINVAL;
 
         pr_debug("Registering compressed device %s\n", device->name);
diff --git a/sound/core/control.c b/sound/core/control.c
index bb96a467e88d..35324a8e83c8 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -50,7 +50,7 @@ static int snd_ctl_open(struct inode *inode, struct file *file)
         unsigned long flags;
         struct snd_card *card;
         struct snd_ctl_file *ctl;
-        int err;
+        int i, err;
 
         err = nonseekable_open(inode, file);
         if (err < 0)
@@ -79,8 +79,8 @@ static int snd_ctl_open(struct inode *inode, struct file *file)
         init_waitqueue_head(&ctl->change_sleep);
         spin_lock_init(&ctl->read_lock);
         ctl->card = card;
-        ctl->prefer_pcm_subdevice = -1;
-        ctl->prefer_rawmidi_subdevice = -1;
+        for (i = 0; i < SND_CTL_SUBDEV_ITEMS; i++)
+                ctl->preferred_subdevice[i] = -1;
         ctl->pid = get_pid(task_pid(current));
         file->private_data = ctl;
         write_lock_irqsave(&card->ctl_files_rwlock, flags);
@@ -373,6 +373,7 @@ int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
         card->controls_count += kcontrol->count;
         kcontrol->id.numid = card->last_numid + 1;
         card->last_numid += kcontrol->count;
+        id = kcontrol->id;
         count = kcontrol->count;
         up_write(&card->controls_rwsem);
         for (idx = 0; idx < count; idx++, id.index++, id.numid++)
@@ -439,6 +440,7 @@ add:
         card->controls_count += kcontrol->count;
         kcontrol->id.numid = card->last_numid + 1;
         card->last_numid += kcontrol->count;
+        id = kcontrol->id;
         count = kcontrol->count;
         up_write(&card->controls_rwsem);
         for (idx = 0; idx < count; idx++, id.index++, id.numid++)
@@ -1607,6 +1609,27 @@ static int snd_ctl_fasync(int fd, struct file * file, int on)
         return fasync_helper(fd, file, on, &ctl->fasync);
 }
 
+/* return the preferred subdevice number if already assigned;
+ * otherwise return -1
+ */
+int snd_ctl_get_preferred_subdevice(struct snd_card *card, int type)
+{
+        struct snd_ctl_file *kctl;
+        int subdevice = -1;
+
+        read_lock(&card->ctl_files_rwlock);
+        list_for_each_entry(kctl, &card->ctl_files, list) {
+                if (kctl->pid == task_pid(current)) {
+                        subdevice = kctl->preferred_subdevice[type];
+                        if (subdevice != -1)
+                                break;
+                }
+        }
+        read_unlock(&card->ctl_files_rwlock);
+        return subdevice;
+}
+EXPORT_SYMBOL_GPL(snd_ctl_get_preferred_subdevice);
+
 /*
  * ioctl32 compat
  */
@@ -1639,19 +1662,9 @@ static const struct file_operations snd_ctl_f_ops =
 static int snd_ctl_dev_register(struct snd_device *device)
 {
         struct snd_card *card = device->device_data;
-        int err, cardnum;
-        char name[16];
 
-        if (snd_BUG_ON(!card))
-                return -ENXIO;
-        cardnum = card->number;
-        if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
-                return -ENXIO;
-        sprintf(name, "controlC%i", cardnum);
-        if ((err = snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
-                                       &snd_ctl_f_ops, card, name)) < 0)
-                return err;
-        return 0;
+        return snd_register_device(SNDRV_DEVICE_TYPE_CONTROL, card, -1,
+                                   &snd_ctl_f_ops, card, &card->ctl_dev);
 }
 
 /*
@@ -1661,13 +1674,6 @@ static int snd_ctl_dev_disconnect(struct snd_device *device)
 {
         struct snd_card *card = device->device_data;
         struct snd_ctl_file *ctl;
-        int err, cardnum;
-
-        if (snd_BUG_ON(!card))
-                return -ENXIO;
-        cardnum = card->number;
-        if (snd_BUG_ON(cardnum < 0 || cardnum >= SNDRV_CARDS))
-                return -ENXIO;
 
         read_lock(&card->ctl_files_rwlock);
         list_for_each_entry(ctl, &card->ctl_files, list) {
@@ -1676,10 +1682,7 @@ static int snd_ctl_dev_disconnect(struct snd_device *device)
         }
         read_unlock(&card->ctl_files_rwlock);
 
-        if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL,
-                                         card, -1)) < 0)
-                return err;
-        return 0;
+        return snd_unregister_device(&card->ctl_dev);
 }
 
 /*
@@ -1696,6 +1699,7 @@ static int snd_ctl_dev_free(struct snd_device *device)
                 snd_ctl_remove(card, control);
         }
         up_write(&card->controls_rwsem);
+        put_device(&card->ctl_dev);
         return 0;
 }
 
@@ -1710,10 +1714,20 @@ int snd_ctl_create(struct snd_card *card)
                 .dev_register = snd_ctl_dev_register,
                 .dev_disconnect = snd_ctl_dev_disconnect,
         };
+        int err;
 
         if (snd_BUG_ON(!card))
                 return -ENXIO;
-        return snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
+        if (snd_BUG_ON(card->number < 0 || card->number >= SNDRV_CARDS))
+                return -ENXIO;
+
+        snd_device_initialize(&card->ctl_dev, card);
+        dev_set_name(&card->ctl_dev, "controlC%d", card->number);
+
+        err = snd_device_new(card, SNDRV_DEV_CONTROL, card, &ops);
+        if (err < 0)
+                put_device(&card->ctl_dev);
+        return err;
 }
 
 /*
diff --git a/sound/core/hwdep.c b/sound/core/hwdep.c
index 69459e5f712e..84244a5143cf 100644
--- a/sound/core/hwdep.c
+++ b/sound/core/hwdep.c
@@ -38,7 +38,6 @@ MODULE_LICENSE("GPL");
 static LIST_HEAD(snd_hwdep_devices);
 static DEFINE_MUTEX(register_mutex);
 
-static int snd_hwdep_free(struct snd_hwdep *hwdep);
 static int snd_hwdep_dev_free(struct snd_device *device);
 static int snd_hwdep_dev_register(struct snd_device *device);
 static int snd_hwdep_dev_disconnect(struct snd_device *device);
@@ -345,6 +344,11 @@ static const struct file_operations snd_hwdep_f_ops =
         .mmap =         snd_hwdep_mmap,
 };
 
+static void release_hwdep_device(struct device *dev)
+{
+        kfree(container_of(dev, struct snd_hwdep, dev));
+}
+
 /**
  * snd_hwdep_new - create a new hwdep instance
  * @card: the card instance
@@ -378,48 +382,49 @@ int snd_hwdep_new(struct snd_card *card, char *id, int device,
                 dev_err(card->dev, "hwdep: cannot allocate\n");
                 return -ENOMEM;
         }
+
+        init_waitqueue_head(&hwdep->open_wait);
+        mutex_init(&hwdep->open_mutex);
         hwdep->card = card;
         hwdep->device = device;
         if (id)
                 strlcpy(hwdep->id, id, sizeof(hwdep->id));
+
+        snd_device_initialize(&hwdep->dev, card);
+        hwdep->dev.release = release_hwdep_device;
+        dev_set_name(&hwdep->dev, "hwC%iD%i", card->number, device);
 #ifdef CONFIG_SND_OSSEMUL
         hwdep->oss_type = -1;
 #endif
-        if ((err = snd_device_new(card, SNDRV_DEV_HWDEP, hwdep, &ops)) < 0) {
-                snd_hwdep_free(hwdep);
+
+        err = snd_device_new(card, SNDRV_DEV_HWDEP, hwdep, &ops);
+        if (err < 0) {
+                put_device(&hwdep->dev);
                 return err;
         }
-        init_waitqueue_head(&hwdep->open_wait);
-        mutex_init(&hwdep->open_mutex);
+
         if (rhwdep)
                 *rhwdep = hwdep;
         return 0;
 }
 EXPORT_SYMBOL(snd_hwdep_new);
 
-static int snd_hwdep_free(struct snd_hwdep *hwdep)
+static int snd_hwdep_dev_free(struct snd_device *device)
 {
+        struct snd_hwdep *hwdep = device->device_data;
         if (!hwdep)
                 return 0;
         if (hwdep->private_free)
                 hwdep->private_free(hwdep);
-        kfree(hwdep);
+        put_device(&hwdep->dev);
         return 0;
 }
 
-static int snd_hwdep_dev_free(struct snd_device *device)
-{
-        struct snd_hwdep *hwdep = device->device_data;
-        return snd_hwdep_free(hwdep);
-}
-
 static int snd_hwdep_dev_register(struct snd_device *device)
 {
         struct snd_hwdep *hwdep = device->device_data;
         struct snd_card *card = hwdep->card;
-        struct device *dev;
         int err;
-        char name[32];
 
         mutex_lock(&register_mutex);
         if (snd_hwdep_search(card, hwdep->device)) {
@@ -427,53 +432,30 @@ static int snd_hwdep_dev_register(struct snd_device *device)
                 return -EBUSY;
         }
         list_add_tail(&hwdep->list, &snd_hwdep_devices);
-        sprintf(name, "hwC%iD%i", hwdep->card->number, hwdep->device);
-        dev = hwdep->dev;
-        if (!dev)
-                dev = snd_card_get_device_link(hwdep->card);
-        err = snd_register_device_for_dev(SNDRV_DEVICE_TYPE_HWDEP,
-                                          hwdep->card, hwdep->device,
-                                          &snd_hwdep_f_ops, hwdep, name, dev);
+        err = snd_register_device(SNDRV_DEVICE_TYPE_HWDEP,
+                                  hwdep->card, hwdep->device,
+                                  &snd_hwdep_f_ops, hwdep, &hwdep->dev);
         if (err < 0) {
-                dev_err(dev,
-                        "unable to register hardware dependent device %i:%i\n",
-                        card->number, hwdep->device);
+                dev_err(&hwdep->dev, "unable to register\n");
                 list_del(&hwdep->list);
                 mutex_unlock(&register_mutex);
                 return err;
         }
 
-        if (hwdep->groups) {
-                struct device *d = snd_get_device(SNDRV_DEVICE_TYPE_HWDEP,
-                                                  hwdep->card, hwdep->device);
-                if (d) {
-                        if (hwdep->private_data)
-                                dev_set_drvdata(d, hwdep->private_data);
-                        err = sysfs_create_groups(&d->kobj, hwdep->groups);
-                        if (err < 0)
-                                dev_warn(dev,
-                                         "hwdep %d:%d: cannot create sysfs groups\n",
-                                         card->number, hwdep->device);
-                        put_device(d);
-                }
-        }
-
 #ifdef CONFIG_SND_OSSEMUL
         hwdep->ossreg = 0;
         if (hwdep->oss_type >= 0) {
-                if ((hwdep->oss_type == SNDRV_OSS_DEVICE_TYPE_DMFM) && (hwdep->device != 0)) {
-                        dev_warn(dev,
+                if (hwdep->oss_type == SNDRV_OSS_DEVICE_TYPE_DMFM &&
+                    hwdep->device)
+                        dev_warn(&hwdep->dev,
                                  "only hwdep device 0 can be registered as OSS direct FM device!\n");
-                } else {
-                        if (snd_register_oss_device(hwdep->oss_type,
-                                                    card, hwdep->device,
-                                                    &snd_hwdep_f_ops, hwdep) < 0) {
-                                dev_err(dev,
-                                        "unable to register OSS compatibility device %i:%i\n",
-                                        card->number, hwdep->device);
-                        } else
-                                hwdep->ossreg = 1;
-                }
+                else if (snd_register_oss_device(hwdep->oss_type,
+                                                 card, hwdep->device,
+                                                 &snd_hwdep_f_ops, hwdep) < 0)
+                        dev_warn(&hwdep->dev,
+                                 "unable to register OSS compatibility device\n");
+                else
+                        hwdep->ossreg = 1;
         }
 #endif
         mutex_unlock(&register_mutex);
@@ -497,7 +479,7 @@ static int snd_hwdep_dev_disconnect(struct snd_device *device)
         if (hwdep->ossreg)
                 snd_unregister_oss_device(hwdep->oss_type, hwdep->card, hwdep->device);
 #endif
-        snd_unregister_device(SNDRV_DEVICE_TYPE_HWDEP, hwdep->card, hwdep->device);
+        snd_unregister_device(&hwdep->dev);
         list_del_init(&hwdep->list);
         mutex_unlock(&hwdep->open_mutex);
         mutex_unlock(&register_mutex);
diff --git a/sound/core/init.c b/sound/core/init.c
index 074875d68c15..35419054821c 100644
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -157,8 +157,31 @@ static int get_slot_from_bitmask(int mask, int (*check)(struct module *, int),
         return mask; /* unchanged */
 }
 
+/* the default release callback set in snd_device_initialize() below;
+ * this is just NOP for now, as almost all jobs are already done in
+ * dev_free callback of snd_device chain instead.
+ */
+static void default_release(struct device *dev)
+{
+}
+
+/**
+ * snd_device_initialize - Initialize struct device for sound devices
+ * @dev: device to initialize
+ * @card: card to assign, optional
+ */
+void snd_device_initialize(struct device *dev, struct snd_card *card)
+{
+        device_initialize(dev);
+        if (card)
+                dev->parent = &card->card_dev;
+        dev->class = sound_class;
+        dev->release = default_release;
+}
+EXPORT_SYMBOL_GPL(snd_device_initialize);
+
 static int snd_card_do_free(struct snd_card *card);
-static const struct attribute_group *card_dev_attr_groups[];
+static const struct attribute_group card_dev_attr_group;
 
 static void release_card_device(struct device *dev)
 {
@@ -246,7 +269,8 @@ int snd_card_new(struct device *parent, int idx, const char *xid,
         card->card_dev.parent = parent;
         card->card_dev.class = sound_class;
         card->card_dev.release = release_card_device;
-        card->card_dev.groups = card_dev_attr_groups;
+        card->card_dev.groups = card->dev_groups;
+        card->dev_groups[0] = &card_dev_attr_group;
         err = kobject_set_name(&card->card_dev.kobj, "card%d", idx);
         if (err < 0)
                 goto __error;
@@ -677,14 +701,32 @@ static struct attribute *card_dev_attrs[] = {
         NULL
 };
 
-static struct attribute_group card_dev_attr_group = {
+static const struct attribute_group card_dev_attr_group = {
         .attrs  = card_dev_attrs,
 };
 
-static const struct attribute_group *card_dev_attr_groups[] = {
-        &card_dev_attr_group,
-        NULL
+/**
+ * snd_card_add_dev_attr - Append a new sysfs attribute group to card
+ * @card: card instance
+ * @group: attribute group to append
+ */
+int snd_card_add_dev_attr(struct snd_card *card,
+                          const struct attribute_group *group)
+{
+        int i;
+
+        /* loop for (arraysize-1) here to keep NULL at the last entry */
+        for (i = 0; i < ARRAY_SIZE(card->dev_groups) - 1; i++) {
+                if (!card->dev_groups[i]) {
+                        card->dev_groups[i] = group;
+                        return 0;
+                }
+        }
+
+        dev_err(card->dev, "Too many groups assigned\n");
+        return -ENOSPC;
 };
+EXPORT_SYMBOL_GPL(snd_card_add_dev_attr);
 
 /**
  *  snd_card_register - register the soundcard
diff --git a/sound/core/memory.c b/sound/core/memory.c
index 36c0f1a2e189..4cd664efad77 100644
--- a/sound/core/memory.c
+++ b/sound/core/memory.c
@@ -21,8 +21,8 @@
  */
 
 #include <linux/export.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 #include <sound/core.h>
 
 /**
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index ada69d7a8d70..80423a4ccab6 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -719,7 +719,7 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream,
 
         oss_buffer_size = snd_pcm_plug_client_size(substream,
                                                    snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, NULL)) * oss_frame_size;
-        oss_buffer_size = 1 << ld2(oss_buffer_size);
+        oss_buffer_size = rounddown_pow_of_two(oss_buffer_size);
         if (atomic_read(&substream->mmap_count)) {
                 if (oss_buffer_size > runtime->oss.mmap_bytes)
                         oss_buffer_size = runtime->oss.mmap_bytes;
@@ -755,14 +755,14 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream,
         min_period_size = snd_pcm_plug_client_size(substream,
                                                    snd_pcm_hw_param_value_min(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
         min_period_size *= oss_frame_size;
-        min_period_size = 1 << (ld2(min_period_size - 1) + 1);
+        min_period_size = roundup_pow_of_two(min_period_size);
         if (oss_period_size < min_period_size)
                 oss_period_size = min_period_size;
 
         max_period_size = snd_pcm_plug_client_size(substream,
                                                    snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
         max_period_size *= oss_frame_size;
-        max_period_size = 1 << ld2(max_period_size);
+        max_period_size = rounddown_pow_of_two(max_period_size);
         if (oss_period_size > max_period_size)
                 oss_period_size = max_period_size;
 
diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index cfc56c806964..0345e53a340c 100644
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -161,7 +161,7 @@ static int snd_pcm_control_ioctl(struct snd_card *card,
                         
                         if (get_user(val, (int __user *)arg))
                                 return -EFAULT;
-                        control->prefer_pcm_subdevice = val;
+                        control->preferred_subdevice[SND_CTL_SUBDEV_PCM] = val;
                         return 0;
                 }
         }
@@ -673,6 +673,8 @@ static inline int snd_pcm_substream_proc_init(struct snd_pcm_substream *substrea
 static inline int snd_pcm_substream_proc_done(struct snd_pcm_substream *substream) { return 0; }
 #endif /* CONFIG_SND_VERBOSE_PROCFS */
 
+static const struct attribute_group *pcm_dev_attr_groups[];
+
 /**
  * snd_pcm_new_stream - create a new PCM stream
  * @pcm: the pcm instance
@@ -698,7 +700,15 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
         pstr->stream = stream;
         pstr->pcm = pcm;
         pstr->substream_count = substream_count;
-        if (substream_count > 0 && !pcm->internal) {
+        if (!substream_count)
+                return 0;
+
+        snd_device_initialize(&pstr->dev, pcm->card);
+        pstr->dev.groups = pcm_dev_attr_groups;
+        dev_set_name(&pstr->dev, "pcmC%iD%i%c", pcm->card->number, pcm->device,
+                     stream == SNDRV_PCM_STREAM_PLAYBACK ? 'p' : 'c');
+
+        if (!pcm->internal) {
                 err = snd_pcm_stream_proc_init(pstr);
                 if (err < 0) {
                         pcm_err(pcm, "Error in snd_pcm_stream_proc_init\n");
@@ -868,6 +878,8 @@ static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
                 kfree(setup);
         }
 #endif
+        if (pstr->substream_count)
+                put_device(&pstr->dev);
 }
 
 static int snd_pcm_free(struct snd_pcm *pcm)
@@ -901,9 +913,8 @@ int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
         struct snd_pcm_str * pstr;
         struct snd_pcm_substream *substream;
         struct snd_pcm_runtime *runtime;
-        struct snd_ctl_file *kctl;
         struct snd_card *card;
-        int prefer_subdevice = -1;
+        int prefer_subdevice;
         size_t size;
 
         if (snd_BUG_ON(!pcm || !rsubstream))
@@ -914,15 +925,7 @@ int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
                 return -ENODEV;
 
         card = pcm->card;
-        read_lock(&card->ctl_files_rwlock);
-        list_for_each_entry(kctl, &card->ctl_files, list) {
-                if (kctl->pid == task_pid(current)) {
-                        prefer_subdevice = kctl->prefer_pcm_subdevice;
-                        if (prefer_subdevice != -1)
-                                break;
-                }
-        }
-        read_unlock(&card->ctl_files_rwlock);
+        prefer_subdevice = snd_ctl_get_preferred_subdevice(card, SND_CTL_SUBDEV_PCM);
 
         switch (stream) {
         case SNDRV_PCM_STREAM_PLAYBACK:
@@ -1078,9 +1081,7 @@ static int snd_pcm_dev_register(struct snd_device *device)
         int cidx, err;
         struct snd_pcm_substream *substream;
         struct snd_pcm_notify *notify;
-        char str[16];
         struct snd_pcm *pcm;
-        struct device *dev;
 
         if (snd_BUG_ON(!device || !device->device_data))
                 return -ENXIO;
@@ -1097,42 +1098,22 @@ static int snd_pcm_dev_register(struct snd_device *device)
                         continue;
                 switch (cidx) {
                 case SNDRV_PCM_STREAM_PLAYBACK:
-                        sprintf(str, "pcmC%iD%ip", pcm->card->number, pcm->device);
                         devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
                         break;
                 case SNDRV_PCM_STREAM_CAPTURE:
-                        sprintf(str, "pcmC%iD%ic", pcm->card->number, pcm->device);
                         devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
                         break;
                 }
-                /* device pointer to use, pcm->dev takes precedence if
-                 * it is assigned, otherwise fall back to card's device
-                 * if possible */
-                dev = pcm->dev;
-                if (!dev)
-                        dev = snd_card_get_device_link(pcm->card);
                 /* register pcm */
-                err = snd_register_device_for_dev(devtype, pcm->card,
-                                                  pcm->device,
-                                                  &snd_pcm_f_ops[cidx],
-                                                  pcm, str, dev);
+                err = snd_register_device(devtype, pcm->card, pcm->device,
+                                          &snd_pcm_f_ops[cidx], pcm,
+                                          &pcm->streams[cidx].dev);
                 if (err < 0) {
                         list_del(&pcm->list);
                         mutex_unlock(&register_mutex);
                         return err;
                 }
 
-                dev = snd_get_device(devtype, pcm->card, pcm->device);
-                if (dev) {
-                        err = sysfs_create_groups(&dev->kobj,
-                                                  pcm_dev_attr_groups);
-                        if (err < 0)
-                                dev_warn(dev,
-                                         "pcm %d:%d: cannot create sysfs groups\n",
-                                         pcm->card->number, pcm->device);
-                        put_device(dev);
-                }
-
                 for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
                         snd_pcm_timer_init(substream);
         }
@@ -1149,7 +1130,7 @@ static int snd_pcm_dev_disconnect(struct snd_device *device)
         struct snd_pcm *pcm = device->device_data;
         struct snd_pcm_notify *notify;
         struct snd_pcm_substream *substream;
-        int cidx, devtype;
+        int cidx;
 
         mutex_lock(&register_mutex);
         if (list_empty(&pcm->list))
@@ -1172,16 +1153,7 @@ static int snd_pcm_dev_disconnect(struct snd_device *device)
                 notify->n_disconnect(pcm);
         }
         for (cidx = 0; cidx < 2; cidx++) {
-                devtype = -1;
-                switch (cidx) {
-                case SNDRV_PCM_STREAM_PLAYBACK:
-                        devtype = SNDRV_DEVICE_TYPE_PCM_PLAYBACK;
-                        break;
-                case SNDRV_PCM_STREAM_CAPTURE:
-                        devtype = SNDRV_DEVICE_TYPE_PCM_CAPTURE;
-                        break;
-                }
-                snd_unregister_device(devtype, pcm->card, pcm->device);
+                snd_unregister_device(&pcm->streams[cidx].dev);
                 if (pcm->streams[cidx].chmap_kctl) {
                         snd_ctl_remove(pcm->card, pcm->streams[cidx].chmap_kctl);
                         pcm->streams[cidx].chmap_kctl = NULL;
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index ec9e7866177f..ffd656012ab8 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -1015,6 +1015,60 @@ int snd_interval_list(struct snd_interval *i, unsigned int count,
 
 EXPORT_SYMBOL(snd_interval_list);
 
+/**
+ * snd_interval_ranges - refine the interval value from the list of ranges
+ * @i: the interval value to refine
+ * @count: the number of elements in the list of ranges
+ * @ranges: the ranges list
+ * @mask: the bit-mask to evaluate
+ *
+ * Refines the interval value from the list of ranges.
+ * When mask is non-zero, only the elements corresponding to bit 1 are
+ * evaluated.
+ *
+ * Return: Positive if the value is changed, zero if it's not changed, or a
+ * negative error code.
+ */
+int snd_interval_ranges(struct snd_interval *i, unsigned int count,
+                        const struct snd_interval *ranges, unsigned int mask)
+{
+        unsigned int k;
+        struct snd_interval range_union;
+        struct snd_interval range;
+
+        if (!count) {
+                snd_interval_none(i);
+                return -EINVAL;
+        }
+        snd_interval_any(&range_union);
+        range_union.min = UINT_MAX;
+        range_union.max = 0;
+        for (k = 0; k < count; k++) {
+                if (mask && !(mask & (1 << k)))
+                        continue;
+                snd_interval_copy(&range, &ranges[k]);
+                if (snd_interval_refine(&range, i) < 0)
+                        continue;
+                if (snd_interval_empty(&range))
+                        continue;
+
+                if (range.min < range_union.min) {
+                        range_union.min = range.min;
+                        range_union.openmin = 1;
+                }
+                if (range.min == range_union.min && !range.openmin)
+                        range_union.openmin = 0;
+                if (range.max > range_union.max) {
+                        range_union.max = range.max;
+                        range_union.openmax = 1;
+                }
+                if (range.max == range_union.max && !range.openmax)
+                        range_union.openmax = 0;
+        }
+        return snd_interval_refine(i, &range_union);
+}
+EXPORT_SYMBOL(snd_interval_ranges);
+
 static int snd_interval_step(struct snd_interval *i, unsigned int step)
 {
         unsigned int n;
@@ -1221,6 +1275,37 @@ int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
 
 EXPORT_SYMBOL(snd_pcm_hw_constraint_list);
 
+static int snd_pcm_hw_rule_ranges(struct snd_pcm_hw_params *params,
+                                  struct snd_pcm_hw_rule *rule)
+{
+        struct snd_pcm_hw_constraint_ranges *r = rule->private;
+        return snd_interval_ranges(hw_param_interval(params, rule->var),
+                                   r->count, r->ranges, r->mask);
+}
+
+
+/**
+ * snd_pcm_hw_constraint_ranges - apply list of range constraints to a parameter
+ * @runtime: PCM runtime instance
+ * @cond: condition bits
+ * @var: hw_params variable to apply the list of range constraints
+ * @r: ranges
+ *
+ * Apply the list of range constraints to an interval parameter.
+ *
+ * Return: Zero if successful, or a negative error code on failure.
+ */
+int snd_pcm_hw_constraint_ranges(struct snd_pcm_runtime *runtime,
+                                 unsigned int cond,
+                                 snd_pcm_hw_param_t var,
+                                 const struct snd_pcm_hw_constraint_ranges *r)
+{
+        return snd_pcm_hw_rule_add(runtime, cond, var,
+                                   snd_pcm_hw_rule_ranges, (void *)r,
+                                   var, -1);
+}
+EXPORT_SYMBOL(snd_pcm_hw_constraint_ranges);
+
 static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,
                                    struct snd_pcm_hw_rule *rule)
 {
@@ -1299,8 +1384,14 @@ static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
         int width = l & 0xffff;
         unsigned int msbits = l >> 16;
         struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
-        if (snd_interval_single(i) && snd_interval_value(i) == width)
-                params->msbits = msbits;
+
+        if (!snd_interval_single(i))
+                return 0;
+
+        if ((snd_interval_value(i) == width) ||
+            (width == 0 && snd_interval_value(i) > msbits))
+                params->msbits = min_not_zero(params->msbits, msbits);
+
         return 0;
 }
 
@@ -1311,6 +1402,11 @@ static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
  * @width: sample bits width
  * @msbits: msbits width
  *
+ * This constraint will set the number of most significant bits (msbits) if a
+ * sample format with the specified width has been select. If width is set to 0
+ * the msbits will be set for any sample format with a width larger than the
+ * specified msbits.
+ *
  * Return: Zero if successful, or a negative error code on failure.
  */
 int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime, 
diff --git a/sound/core/pcm_memory.c b/sound/core/pcm_memory.c
index 54debc07f5cb..b45f6aa32264 100644
--- a/sound/core/pcm_memory.c
+++ b/sound/core/pcm_memory.c
@@ -19,7 +19,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/time.h>
 #include <linux/init.h>
 #include <linux/slab.h>
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 095d9572ad2b..279e24f61305 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -26,6 +26,7 @@
 #include <linux/time.h>
 #include <linux/pm_qos.h>
 #include <linux/aio.h>
+#include <linux/io.h>
 #include <linux/dma-mapping.h>
 #include <sound/core.h>
 #include <sound/control.h>
@@ -34,7 +35,6 @@
 #include <sound/pcm_params.h>
 #include <sound/timer.h>
 #include <sound/minors.h>
-#include <asm/io.h>
 
 /*
  *  Compatibility
@@ -420,7 +420,8 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
 
         hw = &substream->runtime->hw;
         if (!params->info) {
-                params->info = hw->info & ~SNDRV_PCM_INFO_FIFO_IN_FRAMES;
+                params->info = hw->info & ~(SNDRV_PCM_INFO_FIFO_IN_FRAMES |
+                                            SNDRV_PCM_INFO_DRAIN_TRIGGER);
                 if (!hw_support_mmap(substream))
                         params->info &= ~(SNDRV_PCM_INFO_MMAP |
                                           SNDRV_PCM_INFO_MMAP_VALID);
@@ -719,8 +720,11 @@ int snd_pcm_status(struct snd_pcm_substream *substream,
                                 runtime->status->audio_tstamp;
                         goto _tstamp_end;
                 }
+        } else {
+                /* get tstamp only in fallback mode and only if enabled */
+                if (runtime->tstamp_mode == SNDRV_PCM_TSTAMP_ENABLE)
+                        snd_pcm_gettime(runtime, &status->tstamp);
         }
-        snd_pcm_gettime(runtime, &status->tstamp);
  _tstamp_end:
         status->appl_ptr = runtime->control->appl_ptr;
         status->hw_ptr = runtime->status->hw_ptr;
@@ -806,7 +810,8 @@ static void snd_pcm_trigger_tstamp(struct snd_pcm_substream *substream)
         if (runtime->trigger_master == NULL)
                 return;
         if (runtime->trigger_master == substream) {
-                snd_pcm_gettime(runtime, &runtime->trigger_tstamp);
+                if (!runtime->trigger_tstamp_latched)
+                        snd_pcm_gettime(runtime, &runtime->trigger_tstamp);
         } else {
                 snd_pcm_trigger_tstamp(runtime->trigger_master);
                 runtime->trigger_tstamp = runtime->trigger_master->runtime->trigger_tstamp;
@@ -975,6 +980,7 @@ static int snd_pcm_pre_start(struct snd_pcm_substream *substream, int state)
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
             !snd_pcm_playback_data(substream))
                 return -EPIPE;
+        runtime->trigger_tstamp_latched = false;
         runtime->trigger_master = substream;
         return 0;
 }
@@ -1546,6 +1552,8 @@ static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state)
                         if (! snd_pcm_playback_empty(substream)) {
                                 snd_pcm_do_start(substream, SNDRV_PCM_STATE_DRAINING);
                                 snd_pcm_post_start(substream, SNDRV_PCM_STATE_DRAINING);
+                        } else {
+                                runtime->status->state = SNDRV_PCM_STATE_SETUP;
                         }
                         break;
                 case SNDRV_PCM_STATE_RUNNING:
@@ -1566,6 +1574,13 @@ static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state)
                         snd_pcm_post_stop(substream, new_state);
                 }
         }
+
+        if (runtime->status->state == SNDRV_PCM_STATE_DRAINING &&
+            runtime->trigger_master == substream &&
+            (runtime->hw.info & SNDRV_PCM_INFO_DRAIN_TRIGGER))
+                return substream->ops->trigger(substream,
+                                               SNDRV_PCM_TRIGGER_DRAIN);
+
         return 0;
 }
 
diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c
index 6fc71a4c8a51..b5a748596fc4 100644
--- a/sound/core/rawmidi.c
+++ b/sound/core/rawmidi.c
@@ -57,11 +57,11 @@ static LIST_HEAD(snd_rawmidi_devices);
 static DEFINE_MUTEX(register_mutex);
 
 #define rmidi_err(rmidi, fmt, args...) \
-        dev_err((rmidi)->card->dev, fmt, ##args)
+        dev_err(&(rmidi)->dev, fmt, ##args)
 #define rmidi_warn(rmidi, fmt, args...) \
-        dev_warn((rmidi)->card->dev, fmt, ##args)
+        dev_warn(&(rmidi)->dev, fmt, ##args)
 #define rmidi_dbg(rmidi, fmt, args...) \
-        dev_dbg((rmidi)->card->dev, fmt, ##args)
+        dev_dbg(&(rmidi)->dev, fmt, ##args)
 
 static struct snd_rawmidi *snd_rawmidi_search(struct snd_card *card, int device)
 {
@@ -369,7 +369,6 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file)
         struct snd_rawmidi *rmidi;
         struct snd_rawmidi_file *rawmidi_file = NULL;
         wait_queue_t wait;
-        struct snd_ctl_file *kctl;
 
         if ((file->f_flags & O_APPEND) && !(file->f_flags & O_NONBLOCK)) 
                 return -EINVAL;         /* invalid combination */
@@ -413,16 +412,7 @@ static int snd_rawmidi_open(struct inode *inode, struct file *file)
         init_waitqueue_entry(&wait, current);
         add_wait_queue(&rmidi->open_wait, &wait);
         while (1) {
-                subdevice = -1;
-                read_lock(&card->ctl_files_rwlock);
-                list_for_each_entry(kctl, &card->ctl_files, list) {
-                        if (kctl->pid == task_pid(current)) {
-                                subdevice = kctl->prefer_rawmidi_subdevice;
-                                if (subdevice != -1)
-                                        break;
-                        }
-                }
-                read_unlock(&card->ctl_files_rwlock);
+                subdevice = snd_ctl_get_preferred_subdevice(card, SND_CTL_SUBDEV_RAWMIDI);
                 err = rawmidi_open_priv(rmidi, subdevice, fflags, rawmidi_file);
                 if (err >= 0)
                         break;
@@ -862,7 +852,7 @@ static int snd_rawmidi_control_ioctl(struct snd_card *card,
                 
                 if (get_user(val, (int __user *)argp))
                         return -EFAULT;
-                control->prefer_rawmidi_subdevice = val;
+                control->preferred_subdevice[SND_CTL_SUBDEV_RAWMIDI] = val;
                 return 0;
         }
         case SNDRV_CTL_IOCTL_RAWMIDI_INFO:
@@ -1453,6 +1443,11 @@ static int snd_rawmidi_alloc_substreams(struct snd_rawmidi *rmidi,
         return 0;
 }
 
+static void release_rawmidi_device(struct device *dev)
+{
+        kfree(container_of(dev, struct snd_rawmidi, dev));
+}
+
 /**
  * snd_rawmidi_new - create a rawmidi instance
  * @card: the card instance
@@ -1497,6 +1492,11 @@ int snd_rawmidi_new(struct snd_card *card, char *id, int device,
 
         if (id != NULL)
                 strlcpy(rmidi->id, id, sizeof(rmidi->id));
+
+        snd_device_initialize(&rmidi->dev, card);
+        rmidi->dev.release = release_rawmidi_device;
+        dev_set_name(&rmidi->dev, "midiC%iD%i", card->number, device);
+
         if ((err = snd_rawmidi_alloc_substreams(rmidi,
                                                 &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT],
                                                 SNDRV_RAWMIDI_STREAM_INPUT,
@@ -1548,7 +1548,7 @@ static int snd_rawmidi_free(struct snd_rawmidi *rmidi)
         snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT]);
         if (rmidi->private_free)
                 rmidi->private_free(rmidi);
-        kfree(rmidi);
+        put_device(&rmidi->dev);
         return 0;
 }
 
@@ -1581,19 +1581,18 @@ static int snd_rawmidi_dev_register(struct snd_device *device)
                 return -EBUSY;
         }
         list_add_tail(&rmidi->list, &snd_rawmidi_devices);
-        sprintf(name, "midiC%iD%i", rmidi->card->number, rmidi->device);
-        if ((err = snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI,
-                                       rmidi->card, rmidi->device,
-                                       &snd_rawmidi_f_ops, rmidi, name)) < 0) {
-                rmidi_err(rmidi, "unable to register rawmidi device %i:%i\n",
-                          rmidi->card->number, rmidi->device);
+        err = snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI,
+                                  rmidi->card, rmidi->device,
+                                  &snd_rawmidi_f_ops, rmidi, &rmidi->dev);
+        if (err < 0) {
+                rmidi_err(rmidi, "unable to register\n");
                 list_del(&rmidi->list);
                 mutex_unlock(&register_mutex);
                 return err;
         }
         if (rmidi->ops && rmidi->ops->dev_register &&
             (err = rmidi->ops->dev_register(rmidi)) < 0) {
-                snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device);
+                snd_unregister_device(&rmidi->dev);
                 list_del(&rmidi->list);
                 mutex_unlock(&register_mutex);
                 return err;
@@ -1681,7 +1680,7 @@ static int snd_rawmidi_dev_disconnect(struct snd_device *device)
                 rmidi->ossreg = 0;
         }
 #endif /* CONFIG_SND_OSSEMUL */
-        snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device);
+        snd_unregister_device(&rmidi->dev);
         mutex_unlock(&rmidi->open_mutex);
         mutex_unlock(&register_mutex);
         return 0;
diff --git a/sound/core/seq/oss/seq_oss_midi.c b/sound/core/seq/oss/seq_oss_midi.c
index 3a4569669efa..e79cc44b1394 100644
--- a/sound/core/seq/oss/seq_oss_midi.c
+++ b/sound/core/seq/oss/seq_oss_midi.c
@@ -237,8 +237,7 @@ snd_seq_oss_midi_check_exit_port(int client, int port)
                 spin_unlock_irqrestore(&register_lock, flags);
                 snd_use_lock_free(&mdev->use_lock);
                 snd_use_lock_sync(&mdev->use_lock);
-                if (mdev->coder)
-                        snd_midi_event_free(mdev->coder);
+                snd_midi_event_free(mdev->coder);
                 kfree(mdev);
         }
         spin_lock_irqsave(&register_lock, flags);
@@ -265,8 +264,7 @@ snd_seq_oss_midi_clear_all(void)
         spin_lock_irqsave(&register_lock, flags);
         for (i = 0; i < max_midi_devs; i++) {
                 if ((mdev = midi_devs[i]) != NULL) {
-                        if (mdev->coder)
-                                snd_midi_event_free(mdev->coder);
+                        snd_midi_event_free(mdev->coder);
                         kfree(mdev);
                         midi_devs[i] = NULL;
                 }
diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index 225c73152ee9..48287651ac77 100644
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -1133,7 +1133,7 @@ static int snd_seq_ioctl_system_info(struct snd_seq_client *client, void __user
         /* fill the info fields */
         info.queues = SNDRV_SEQ_MAX_QUEUES;
         info.clients = SNDRV_SEQ_MAX_CLIENTS;
-        info.ports = 256;       /* fixed limit */
+        info.ports = SNDRV_SEQ_MAX_PORTS;
         info.channels = 256;    /* fixed limit */
         info.cur_clients = client_usage.cur;
         info.cur_queues = snd_seq_queue_get_cur_queues();
@@ -1279,7 +1279,6 @@ static int snd_seq_ioctl_create_port(struct snd_seq_client *client,
                                 port->owner = callback->owner;
                         port->private_data = callback->private_data;
                         port->private_free = callback->private_free;
-                        port->callback_all = callback->callback_all;
                         port->event_input = callback->event_input;
                         port->c_src.open = callback->subscribe;
                         port->c_src.close = callback->unsubscribe;
@@ -2571,6 +2570,8 @@ static const struct file_operations snd_seq_f_ops =
         .compat_ioctl = snd_seq_ioctl_compat,
 };
 
+static struct device seq_dev;
+
 /* 
  * register sequencer device 
  */
@@ -2578,12 +2579,17 @@ int __init snd_sequencer_device_init(void)
 {
         int err;
 
+        snd_device_initialize(&seq_dev, NULL);
+        dev_set_name(&seq_dev, "seq");
+
         if (mutex_lock_interruptible(&register_mutex))
                 return -ERESTARTSYS;
 
-        if ((err = snd_register_device(SNDRV_DEVICE_TYPE_SEQUENCER, NULL, 0,
-                                       &snd_seq_f_ops, NULL, "seq")) < 0) {
+        err = snd_register_device(SNDRV_DEVICE_TYPE_SEQUENCER, NULL, 0,
+                                  &snd_seq_f_ops, NULL, &seq_dev);
+        if (err < 0) {
                 mutex_unlock(&register_mutex);
+                put_device(&seq_dev);
                 return err;
         }
         
@@ -2599,5 +2605,6 @@ int __init snd_sequencer_device_init(void)
  */
 void __exit snd_sequencer_device_done(void)
 {
-        snd_unregister_device(SNDRV_DEVICE_TYPE_SEQUENCER, NULL, 0);
+        snd_unregister_device(&seq_dev);
+        put_device(&seq_dev);
 }
diff --git a/sound/core/seq/seq_midi.c b/sound/core/seq/seq_midi.c
index a1fd77af6059..68fec776da26 100644
--- a/sound/core/seq/seq_midi.c
+++ b/sound/core/seq/seq_midi.c
@@ -268,8 +268,7 @@ static void snd_seq_midisynth_delete(struct seq_midisynth *msynth)
                 snd_seq_event_port_detach(msynth->seq_client, msynth->seq_port);
         }
 
-        if (msynth->parser)
-                snd_midi_event_free(msynth->parser);
+        snd_midi_event_free(msynth->parser);
 }
 
 /* register new midi synth port */
diff --git a/sound/core/seq/seq_midi_emul.c b/sound/core/seq/seq_midi_emul.c
index 9b6470cdcf24..7ba937399ac7 100644
--- a/sound/core/seq/seq_midi_emul.c
+++ b/sound/core/seq/seq_midi_emul.c
@@ -269,6 +269,9 @@ do_control(struct snd_midi_op *ops, void *drv, struct snd_midi_channel_set *chse
 {
         int  i;
 
+        if (control >= ARRAY_SIZE(chan->control))
+                return;
+
         /* Switches */
         if ((control >=64 && control <=69) || (control >= 80 && control <= 83)) {
                 /* These are all switches; either off or on so set to 0 or 127 */
diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c
index 794a341bf0e5..46ff593f618d 100644
--- a/sound/core/seq/seq_ports.c
+++ b/sound/core/seq/seq_ports.c
@@ -134,7 +134,7 @@ struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client,
         if (snd_BUG_ON(!client))
                 return NULL;
 
-        if (client->num_ports >= SNDRV_SEQ_MAX_PORTS - 1) {
+        if (client->num_ports >= SNDRV_SEQ_MAX_PORTS) {
                 pr_warn("ALSA: seq: too many ports for client %d\n", client->number);
                 return NULL;
         }
@@ -411,9 +411,6 @@ int snd_seq_get_port_info(struct snd_seq_client_port * port,
  * invoked.
  * This feature is useful if these callbacks are associated with
  * initialization or termination of devices (see seq_midi.c).
- *
- * If callback_all option is set, the callback function is invoked
- * at each connection/disconnection. 
  */
 
 static int subscribe_port(struct snd_seq_client *client,
@@ -427,7 +424,7 @@ static int subscribe_port(struct snd_seq_client *client,
         if (!try_module_get(port->owner))
                 return -EFAULT;
         grp->count++;
-        if (grp->open && (port->callback_all || grp->count == 1)) {
+        if (grp->open && grp->count == 1) {
                 err = grp->open(port->private_data, info);
                 if (err < 0) {
                         module_put(port->owner);
@@ -452,7 +449,7 @@ static int unsubscribe_port(struct snd_seq_client *client,
         if (! grp->count)
                 return -EINVAL;
         grp->count--;
-        if (grp->close && (port->callback_all || grp->count == 0))
+        if (grp->close && grp->count == 0)
                 err = grp->close(port->private_data, info);
         if (send_ack && client->type == USER_CLIENT)
                 snd_seq_client_notify_subscription(port->addr.client, port->addr.port,
diff --git a/sound/core/seq/seq_ports.h b/sound/core/seq/seq_ports.h
index 9d7117118ba4..26bd71f36c41 100644
--- a/sound/core/seq/seq_ports.h
+++ b/sound/core/seq/seq_ports.h
@@ -73,7 +73,6 @@ struct snd_seq_client_port {
                            int atomic, int hop);
         void (*private_free)(void *private_data);
         void *private_data;
-        unsigned int callback_all : 1;
         unsigned int closing : 1;
         unsigned int timestamping: 1;
         unsigned int time_real: 1;
diff --git a/sound/core/sound.c b/sound/core/sound.c
index f1333060bf1c..185cec01ee25 100644
--- a/sound/core/sound.c
+++ b/sound/core/sound.c
@@ -242,30 +242,30 @@ static int snd_kernel_minor(int type, struct snd_card *card, int dev)
 #endif
 
 /**
- * snd_register_device_for_dev - Register the ALSA device file for the card
+ * snd_register_device - Register the ALSA device file for the card
  * @type: the device type, SNDRV_DEVICE_TYPE_XXX
  * @card: the card instance
  * @dev: the device index
  * @f_ops: the file operations
  * @private_data: user pointer for f_ops->open()
- * @name: the device file name
- * @device: the &struct device to link this new device to
+ * @device: the device to register
  *
  * Registers an ALSA device file for the given card.
  * The operators have to be set in reg parameter.
  *
  * Return: Zero if successful, or a negative error code on failure.
  */
-int snd_register_device_for_dev(int type, struct snd_card *card, int dev,
-                                const struct file_operations *f_ops,
-                                void *private_data,
-                                const char *name, struct device *device)
+int snd_register_device(int type, struct snd_card *card, int dev,
+                        const struct file_operations *f_ops,
+                        void *private_data, struct device *device)
 {
         int minor;
+        int err = 0;
         struct snd_minor *preg;
 
-        if (snd_BUG_ON(!name))
+        if (snd_BUG_ON(!device))
                 return -EINVAL;
+
         preg = kmalloc(sizeof *preg, GFP_KERNEL);
         if (preg == NULL)
                 return -ENOMEM;
@@ -284,102 +284,56 @@ int snd_register_device_for_dev(int type, struct snd_card *card, int dev,
                 minor = -EBUSY;
 #endif
         if (minor < 0) {
-                mutex_unlock(&sound_mutex);
-                kfree(preg);
-                return minor;
-        }
-        snd_minors[minor] = preg;
-        preg->dev = device_create(sound_class, device, MKDEV(major, minor),
-                                  private_data, "%s", name);
-        if (IS_ERR(preg->dev)) {
-                snd_minors[minor] = NULL;
-                mutex_unlock(&sound_mutex);
-                minor = PTR_ERR(preg->dev);
-                kfree(preg);
-                return minor;
+                err = minor;
+                goto error;
         }
 
-        mutex_unlock(&sound_mutex);
-        return 0;
-}
-
-EXPORT_SYMBOL(snd_register_device_for_dev);
-
-/* find the matching minor record
- * return the index of snd_minor, or -1 if not found
- */
-static int find_snd_minor(int type, struct snd_card *card, int dev)
-{
-        int cardnum, minor;
-        struct snd_minor *mptr;
+        preg->dev = device;
+        device->devt = MKDEV(major, minor);
+        err = device_add(device);
+        if (err < 0)
+                goto error;
 
-        cardnum = card ? card->number : -1;
-        for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor)
-                if ((mptr = snd_minors[minor]) != NULL &&
-                    mptr->type == type &&
-                    mptr->card == cardnum &&
-                    mptr->device == dev)
-                        return minor;
-        return -1;
+        snd_minors[minor] = preg;
+ error:
+        mutex_unlock(&sound_mutex);
+        if (err < 0)
+                kfree(preg);
+        return err;
 }
+EXPORT_SYMBOL(snd_register_device);
 
 /**
  * snd_unregister_device - unregister the device on the given card
- * @type: the device type, SNDRV_DEVICE_TYPE_XXX
- * @card: the card instance
- * @dev: the device index
+ * @dev: the device instance
  *
  * Unregisters the device file already registered via
  * snd_register_device().
  *
  * Return: Zero if successful, or a negative error code on failure.
  */
-int snd_unregister_device(int type, struct snd_card *card, int dev)
+int snd_unregister_device(struct device *dev)
 {
         int minor;
+        struct snd_minor *preg;
 
         mutex_lock(&sound_mutex);
-        minor = find_snd_minor(type, card, dev);
-        if (minor < 0) {
-                mutex_unlock(&sound_mutex);
-                return -EINVAL;
+        for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) {
+                preg = snd_minors[minor];
+                if (preg && preg->dev == dev) {
+                        snd_minors[minor] = NULL;
+                        device_del(dev);
+                        kfree(preg);
+                        break;
+                }
         }
-
-        device_destroy(sound_class, MKDEV(major, minor));
-
-        kfree(snd_minors[minor]);
-        snd_minors[minor] = NULL;
         mutex_unlock(&sound_mutex);
+        if (minor >= ARRAY_SIZE(snd_minors))
+                return -ENOENT;
         return 0;
 }
-
 EXPORT_SYMBOL(snd_unregister_device);
 
-/**
- * snd_get_device - get the assigned device to the given type and device number
- * @type: the device type, SNDRV_DEVICE_TYPE_XXX
- * @card:the card instance
- * @dev: the device index
- *
- * The caller needs to release it via put_device() after using it.
- */
-struct device *snd_get_device(int type, struct snd_card *card, int dev)
-{
-        int minor;
-        struct device *d = NULL;
-
-        mutex_lock(&sound_mutex);
-        minor = find_snd_minor(type, card, dev);
-        if (minor >= 0) {
-                d = snd_minors[minor]->dev;
-                if (d)
-                        get_device(d);
-        }
-        mutex_unlock(&sound_mutex);
-        return d;
-}
-EXPORT_SYMBOL(snd_get_device);
-
 #ifdef CONFIG_PROC_FS
 /*
  *  INFO PART
diff --git a/sound/core/timer.c b/sound/core/timer.c
index 777a45e08e53..490b489d713d 100644
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -1030,9 +1030,7 @@ static int snd_timer_register_system(void)
                 snd_timer_free(timer);
                 return -ENOMEM;
         }
-        init_timer(&priv->tlist);
-        priv->tlist.function = snd_timer_s_function;
-        priv->tlist.data = (unsigned long) timer;
+        setup_timer(&priv->tlist, snd_timer_s_function, (unsigned long) timer);
         timer->private_data = priv;
         timer->private_free = snd_timer_free_system;
         return snd_timer_global_register(timer);
@@ -1942,6 +1940,17 @@ static const struct file_operations snd_timer_f_ops =
         .fasync =       snd_timer_user_fasync,
 };
 
+/* unregister the system timer */
+static void snd_timer_free_all(void)
+{
+        struct snd_timer *timer, *n;
+
+        list_for_each_entry_safe(timer, n, &snd_timer_list, device_list)
+                snd_timer_free(timer);
+}
+
+static struct device timer_dev;
+
 /*
  *  ENTRY functions
  */
@@ -1950,30 +1959,39 @@ static int __init alsa_timer_init(void)
 {
         int err;
 
+        snd_device_initialize(&timer_dev, NULL);
+        dev_set_name(&timer_dev, "timer");
+
 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
         snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1,
                               "system timer");
 #endif
 
-        if ((err = snd_timer_register_system()) < 0)
+        err = snd_timer_register_system();
+        if (err < 0) {
                 pr_err("ALSA: unable to register system timer (%i)\n", err);
-        if ((err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0,
-                                       &snd_timer_f_ops, NULL, "timer")) < 0)
+                put_device(&timer_dev);
+                return err;
+        }
+
+        err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0,
+                                  &snd_timer_f_ops, NULL, &timer_dev);
+        if (err < 0) {
                 pr_err("ALSA: unable to register timer device (%i)\n", err);
+                snd_timer_free_all();
+                put_device(&timer_dev);
+                return err;
+        }
+
         snd_timer_proc_init();
         return 0;
 }
 
 static void __exit alsa_timer_exit(void)
 {
-        struct list_head *p, *n;
-
-        snd_unregister_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0);
-        /* unregister the system timer */
-        list_for_each_safe(p, n, &snd_timer_list) {
-                struct snd_timer *timer = list_entry(p, struct snd_timer, device_list);
-                snd_timer_free(timer);
-        }
+        snd_unregister_device(&timer_dev);
+        snd_timer_free_all();
+        put_device(&timer_dev);
         snd_timer_proc_done();
 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
         snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1);
diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c
index 7ea53399404d..7f9126efc1e5 100644
--- a/sound/drivers/aloop.c
+++ b/sound/drivers/aloop.c
@@ -181,8 +181,7 @@ static void loopback_timer_start(struct loopback_pcm *dpcm)
         }
         tick = dpcm->period_size_frac - dpcm->irq_pos;
         tick = (tick + dpcm->pcm_bps - 1) / dpcm->pcm_bps;
-        dpcm->timer.expires = jiffies + tick;
-        add_timer(&dpcm->timer);
+        mod_timer(&dpcm->timer, jiffies + tick);
 }
 
 /* call in cable->lock */
diff --git a/sound/drivers/dummy.c b/sound/drivers/dummy.c
index 5d0dfb787cec..d11baaf0f0b4 100644
--- a/sound/drivers/dummy.c
+++ b/sound/drivers/dummy.c
@@ -245,9 +245,8 @@ struct dummy_systimer_pcm {
 
 static void dummy_systimer_rearm(struct dummy_systimer_pcm *dpcm)
 {
-        dpcm->timer.expires = jiffies +
-                (dpcm->frac_period_rest + dpcm->rate - 1) / dpcm->rate;
-        add_timer(&dpcm->timer);
+        mod_timer(&dpcm->timer, jiffies +
+                (dpcm->frac_period_rest + dpcm->rate - 1) / dpcm->rate);
 }
 
 static void dummy_systimer_update(struct dummy_systimer_pcm *dpcm)
@@ -340,9 +339,8 @@ static int dummy_systimer_create(struct snd_pcm_substream *substream)
         if (!dpcm)
                 return -ENOMEM;
         substream->runtime->private_data = dpcm;
-        init_timer(&dpcm->timer);
-        dpcm->timer.data = (unsigned long) dpcm;
-        dpcm->timer.function = dummy_systimer_callback;
+        setup_timer(&dpcm->timer, dummy_systimer_callback,
+                        (unsigned long) dpcm);
         spin_lock_init(&dpcm->lock);
         dpcm->substream = substream;
         return 0;
diff --git a/sound/drivers/ml403-ac97cr.c b/sound/drivers/ml403-ac97cr.c
index bcca825a1c8d..bdcb5721393b 100644
--- a/sound/drivers/ml403-ac97cr.c
+++ b/sound/drivers/ml403-ac97cr.c
@@ -1094,8 +1094,7 @@ static int snd_ml403_ac97cr_free(struct snd_ml403_ac97cr *ml403_ac97cr)
         if (ml403_ac97cr->capture_irq >= 0)
                 free_irq(ml403_ac97cr->capture_irq, ml403_ac97cr);
         /* give back "port" */
-        if (ml403_ac97cr->port != NULL)
-                iounmap(ml403_ac97cr->port);
+        iounmap(ml403_ac97cr->port);
         kfree(ml403_ac97cr);
         PDEBUG(INIT_INFO, "free(): (done)\n");
         return 0;
@@ -1238,14 +1237,11 @@ snd_ml403_ac97cr_mixer(struct snd_ml403_ac97cr *ml403_ac97cr)
 }
 
 static int
-snd_ml403_ac97cr_pcm(struct snd_ml403_ac97cr *ml403_ac97cr, int device,
-                     struct snd_pcm **rpcm)
+snd_ml403_ac97cr_pcm(struct snd_ml403_ac97cr *ml403_ac97cr, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(ml403_ac97cr->card, "ML403AC97CR/1", device, 1, 1,
                           &pcm);
         if (err < 0)
@@ -1263,8 +1259,6 @@ snd_ml403_ac97cr_pcm(struct snd_ml403_ac97cr *ml403_ac97cr, int device,
                                           snd_dma_continuous_data(GFP_KERNEL),
                                           64 * 1024,
                                           128 * 1024);
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -1298,7 +1292,7 @@ static int snd_ml403_ac97cr_probe(struct platform_device *pfdev)
                 return err;
         }
         PDEBUG(INIT_INFO, "probe(): mixer done\n");
-        err = snd_ml403_ac97cr_pcm(ml403_ac97cr, 0, NULL);
+        err = snd_ml403_ac97cr_pcm(ml403_ac97cr, 0);
         if (err < 0) {
                 snd_card_free(card);
                 return err;
diff --git a/sound/drivers/mpu401/mpu401_uart.c b/sound/drivers/mpu401/mpu401_uart.c
index e3a90d043f03..776596b5ee05 100644
--- a/sound/drivers/mpu401/mpu401_uart.c
+++ b/sound/drivers/mpu401/mpu401_uart.c
@@ -28,7 +28,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -176,8 +176,7 @@ static void snd_mpu401_uart_timer(unsigned long data)
 
         spin_lock_irqsave(&mpu->timer_lock, flags);
         /*mpu->mode |= MPU401_MODE_TIMER;*/
-        mpu->timer.expires = 1 + jiffies;
-        add_timer(&mpu->timer);
+        mod_timer(&mpu->timer,  1 + jiffies);
         spin_unlock_irqrestore(&mpu->timer_lock, flags);
         if (mpu->rmidi)
                 _snd_mpu401_uart_interrupt(mpu);
@@ -192,11 +191,9 @@ static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input)
 
         spin_lock_irqsave (&mpu->timer_lock, flags);
         if (mpu->timer_invoked == 0) {
-                init_timer(&mpu->timer);
-                mpu->timer.data = (unsigned long)mpu;
-                mpu->timer.function = snd_mpu401_uart_timer;
-                mpu->timer.expires = 1 + jiffies;
-                add_timer(&mpu->timer);
+                setup_timer(&mpu->timer, snd_mpu401_uart_timer,
+                            (unsigned long)mpu);
+                mod_timer(&mpu->timer, 1 + jiffies);
         } 
         mpu->timer_invoked |= input ? MPU401_MODE_INPUT_TIMER :
                 MPU401_MODE_OUTPUT_TIMER;
diff --git a/sound/drivers/mtpav.c b/sound/drivers/mtpav.c
index 15769447688f..30e8a1d5bc87 100644
--- a/sound/drivers/mtpav.c
+++ b/sound/drivers/mtpav.c
@@ -414,8 +414,7 @@ static void snd_mtpav_output_timer(unsigned long data)
 
         spin_lock_irqsave(&chip->spinlock, flags);
         /* reprogram timer */
-        chip->timer.expires = 1 + jiffies;
-        add_timer(&chip->timer);
+        mod_timer(&chip->timer, 1 + jiffies);
         /* process each port */
         for (p = 0; p <= chip->num_ports * 2 + MTPAV_PIDX_BROADCAST; p++) {
                 struct mtpav_port *portp = &chip->ports[p];
@@ -428,8 +427,7 @@ static void snd_mtpav_output_timer(unsigned long data)
 /* spinlock held! */
 static void snd_mtpav_add_output_timer(struct mtpav *chip)
 {
-        chip->timer.expires = 1 + jiffies;
-        add_timer(&chip->timer);
+        mod_timer(&chip->timer, 1 + jiffies);
 }
 
 /* spinlock held! */
@@ -704,15 +702,13 @@ static int snd_mtpav_probe(struct platform_device *dev)
 
         mtp_card = card->private_data;
         spin_lock_init(&mtp_card->spinlock);
-        init_timer(&mtp_card->timer);
         mtp_card->card = card;
         mtp_card->irq = -1;
         mtp_card->share_irq = 0;
         mtp_card->inmidistate = 0;
         mtp_card->outmidihwport = 0xffffffff;
-        init_timer(&mtp_card->timer);
-        mtp_card->timer.function = snd_mtpav_output_timer;
-        mtp_card->timer.data = (unsigned long) mtp_card;
+        setup_timer(&mtp_card->timer, snd_mtpav_output_timer,
+                    (unsigned long) mtp_card);
 
         card->private_free = snd_mtpav_free;
 
diff --git a/sound/drivers/opl3/opl3_lib.c b/sound/drivers/opl3/opl3_lib.c
index f66af5884c40..369cef212ea9 100644
--- a/sound/drivers/opl3/opl3_lib.c
+++ b/sound/drivers/opl3/opl3_lib.c
@@ -24,7 +24,7 @@
  */
 
 #include <sound/opl3.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/init.h>
diff --git a/sound/drivers/opl3/opl3_midi.c b/sound/drivers/opl3/opl3_midi.c
index 6c6d09a51f42..f62780ed64ad 100644
--- a/sound/drivers/opl3/opl3_midi.c
+++ b/sound/drivers/opl3/opl3_midi.c
@@ -258,12 +258,10 @@ void snd_opl3_timer_func(unsigned long data)
         spin_unlock_irqrestore(&opl3->voice_lock, flags);
 
         spin_lock_irqsave(&opl3->sys_timer_lock, flags);
-        if (again) {
-                opl3->tlist.expires = jiffies + 1;      /* invoke again */
-                add_timer(&opl3->tlist);
-        } else {
+        if (again)
+                mod_timer(&opl3->tlist, jiffies + 1);   /* invoke again */
+        else
                 opl3->sys_timer_status = 0;
-        }
         spin_unlock_irqrestore(&opl3->sys_timer_lock, flags);
 }
 
@@ -275,8 +273,7 @@ static void snd_opl3_start_timer(struct snd_opl3 *opl3)
         unsigned long flags;
         spin_lock_irqsave(&opl3->sys_timer_lock, flags);
         if (! opl3->sys_timer_status) {
-                opl3->tlist.expires = jiffies + 1;
-                add_timer(&opl3->tlist);
+                mod_timer(&opl3->tlist, jiffies + 1);
                 opl3->sys_timer_status = 1;
         }
         spin_unlock_irqrestore(&opl3->sys_timer_lock, flags);
diff --git a/sound/drivers/opl3/opl3_seq.c b/sound/drivers/opl3/opl3_seq.c
index 68399538e435..a9f618e06a22 100644
--- a/sound/drivers/opl3/opl3_seq.c
+++ b/sound/drivers/opl3/opl3_seq.c
@@ -247,9 +247,7 @@ static int snd_opl3_seq_new_device(struct snd_seq_device *dev)
         }
 
         /* setup system timer */
-        init_timer(&opl3->tlist);
-        opl3->tlist.function = snd_opl3_timer_func;
-        opl3->tlist.data = (unsigned long) opl3;
+        setup_timer(&opl3->tlist, snd_opl3_timer_func, (unsigned long) opl3);
         spin_lock_init(&opl3->sys_timer_lock);
         opl3->sys_timer_status = 0;
 
diff --git a/sound/drivers/opl4/opl4_lib.c b/sound/drivers/opl4/opl4_lib.c
index b953fb4aa298..3b0ee42a5343 100644
--- a/sound/drivers/opl4/opl4_lib.c
+++ b/sound/drivers/opl4/opl4_lib.c
@@ -23,7 +23,7 @@
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 
 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
 MODULE_DESCRIPTION("OPL4 driver");
diff --git a/sound/drivers/opl4/opl4_synth.c b/sound/drivers/opl4/opl4_synth.c
index 4b91adc0238c..7bc1e58c95aa 100644
--- a/sound/drivers/opl4/opl4_synth.c
+++ b/sound/drivers/opl4/opl4_synth.c
@@ -33,7 +33,7 @@
 
 #include "opl4_local.h"
 #include <linux/delay.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/asoundef.h>
 
 /* GM2 controllers */
diff --git a/sound/drivers/pcsp/pcsp.c b/sound/drivers/pcsp/pcsp.c
index 2adc7548ffca..d9647bd84d0f 100644
--- a/sound/drivers/pcsp/pcsp.c
+++ b/sound/drivers/pcsp/pcsp.c
@@ -13,7 +13,7 @@
 #include <sound/pcm.h>
 #include <linux/input.h>
 #include <linux/delay.h>
-#include <asm/bitops.h>
+#include <linux/bitops.h>
 #include "pcsp_input.h"
 #include "pcsp.h"
 
diff --git a/sound/drivers/pcsp/pcsp_input.c b/sound/drivers/pcsp/pcsp_input.c
index 0ecf8a453e01..bfc25811985f 100644
--- a/sound/drivers/pcsp/pcsp_input.c
+++ b/sound/drivers/pcsp/pcsp_input.c
@@ -14,7 +14,7 @@
 
 #include <linux/init.h>
 #include <linux/input.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include "pcsp.h"
 #include "pcsp_input.h"
 
diff --git a/sound/drivers/pcsp/pcsp_lib.c b/sound/drivers/pcsp/pcsp_lib.c
index 29ebaa4ec0fd..3689f5f6be64 100644
--- a/sound/drivers/pcsp/pcsp_lib.c
+++ b/sound/drivers/pcsp/pcsp_lib.c
@@ -10,8 +10,8 @@
 #include <linux/gfp.h>
 #include <linux/moduleparam.h>
 #include <linux/interrupt.h>
+#include <linux/io.h>
 #include <sound/pcm.h>
-#include <asm/io.h>
 #include "pcsp.h"
 
 static bool nforce_wa;
diff --git a/sound/drivers/serial-u16550.c b/sound/drivers/serial-u16550.c
index 13a34e3c6382..1927b89e1d1f 100644
--- a/sound/drivers/serial-u16550.c
+++ b/sound/drivers/serial-u16550.c
@@ -37,6 +37,7 @@
 #include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/module.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/rawmidi.h>
 #include <sound/initval.h>
@@ -44,8 +45,6 @@
 #include <linux/serial_reg.h>
 #include <linux/jiffies.h>
 
-#include <asm/io.h>
-
 MODULE_DESCRIPTION("MIDI serial u16550");
 MODULE_LICENSE("GPL");
 MODULE_SUPPORTED_DEVICE("{{ALSA, MIDI serial u16550}}");
@@ -174,9 +173,8 @@ static inline void snd_uart16550_add_timer(struct snd_uart16550 *uart)
 {
         if (!uart->timer_running) {
                 /* timer 38600bps * 10bit * 16byte */
-                uart->buffer_timer.expires = jiffies + (HZ+255)/256;
+                mod_timer(&uart->buffer_timer, jiffies + (HZ + 255) / 256);
                 uart->timer_running = 1;
-                add_timer(&uart->buffer_timer);
         }
 }
 
@@ -830,9 +828,8 @@ static int snd_uart16550_create(struct snd_card *card,
         uart->prev_in = 0;
         uart->rstatus = 0;
         memset(uart->prev_status, 0x80, sizeof(unsigned char) * SNDRV_SERIAL_MAX_OUTS);
-        init_timer(&uart->buffer_timer);
-        uart->buffer_timer.function = snd_uart16550_buffer_timer;
-        uart->buffer_timer.data = (unsigned long)uart;
+        setup_timer(&uart->buffer_timer, snd_uart16550_buffer_timer,
+                    (unsigned long)uart);
         uart->timer_running = 0;
 
         /* Register device */
diff --git a/sound/drivers/vx/vx_core.c b/sound/drivers/vx/vx_core.c
index fc05a37fd017..289f041706cd 100644
--- a/sound/drivers/vx/vx_core.c
+++ b/sound/drivers/vx/vx_core.c
@@ -27,11 +27,11 @@
 #include <linux/device.h>
 #include <linux/firmware.h>
 #include <linux/module.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/asoundef.h>
 #include <sound/info.h>
-#include <asm/io.h>
 #include <sound/vx_core.h>
 #include "vx_cmd.h"
 
diff --git a/sound/firewire/amdtp.c b/sound/firewire/amdtp.c
index 0d580186ef1a..5cc356db5351 100644
--- a/sound/firewire/amdtp.c
+++ b/sound/firewire/amdtp.c
@@ -33,7 +33,7 @@
  */
 #define MAX_MIDI_RX_BLOCKS      8
 
-#define TRANSFER_DELAY_TICKS    0x2e00 /* 479.17 µs */
+#define TRANSFER_DELAY_TICKS    0x2e00 /* 479.17 microseconds */
 
 /* isochronous header parameters */
 #define ISO_DATA_LENGTH_SHIFT   16
@@ -78,7 +78,7 @@ static void pcm_period_tasklet(unsigned long data);
 int amdtp_stream_init(struct amdtp_stream *s, struct fw_unit *unit,
                       enum amdtp_stream_direction dir, enum cip_flags flags)
 {
-        s->unit = fw_unit_get(unit);
+        s->unit = unit;
         s->direction = dir;
         s->flags = flags;
         s->context = ERR_PTR(-1);
@@ -102,7 +102,6 @@ void amdtp_stream_destroy(struct amdtp_stream *s)
 {
         WARN_ON(amdtp_stream_running(s));
         mutex_destroy(&s->mutex);
-        fw_unit_put(s->unit);
 }
 EXPORT_SYMBOL(amdtp_stream_destroy);
 
diff --git a/sound/firewire/bebob/bebob.c b/sound/firewire/bebob/bebob.c
index fc19c99654aa..611b7dae7ee5 100644
--- a/sound/firewire/bebob/bebob.c
+++ b/sound/firewire/bebob/bebob.c
@@ -116,11 +116,22 @@ end:
         return err;
 }
 
+/*
+ * This module releases the FireWire unit data after all ALSA character devices
+ * are released by applications. This is for releasing stream data or finishing
+ * transactions safely. Thus at returning from .remove(), this module still keep
+ * references for the unit.
+ */
 static void
 bebob_card_free(struct snd_card *card)
 {
         struct snd_bebob *bebob = card->private_data;
 
+        snd_bebob_stream_destroy_duplex(bebob);
+        fw_unit_put(bebob->unit);
+
+        kfree(bebob->maudio_special_quirk);
+
         if (bebob->card_index >= 0) {
                 mutex_lock(&devices_mutex);
                 clear_bit(bebob->card_index, devices_used);
@@ -205,7 +216,7 @@ bebob_probe(struct fw_unit *unit,
         card->private_free = bebob_card_free;
 
         bebob->card = card;
-        bebob->unit = unit;
+        bebob->unit = fw_unit_get(unit);
         bebob->spec = spec;
         mutex_init(&bebob->mutex);
         spin_lock_init(&bebob->lock);
@@ -306,10 +317,11 @@ static void bebob_remove(struct fw_unit *unit)
         if (bebob == NULL)
                 return;
 
-        kfree(bebob->maudio_special_quirk);
+        /* Awake bus-reset waiters. */
+        if (!completion_done(&bebob->bus_reset))
+                complete_all(&bebob->bus_reset);
 
-        snd_bebob_stream_destroy_duplex(bebob);
-        snd_card_disconnect(bebob->card);
+        /* No need to wait for releasing card object in this context. */
         snd_card_free_when_closed(bebob->card);
 }
 
diff --git a/sound/firewire/bebob/bebob_stream.c b/sound/firewire/bebob/bebob_stream.c
index 0ebcabfdc7ce..98e4fc8121a1 100644
--- a/sound/firewire/bebob/bebob_stream.c
+++ b/sound/firewire/bebob/bebob_stream.c
@@ -410,8 +410,6 @@ break_both_connections(struct snd_bebob *bebob)
 static void
 destroy_both_connections(struct snd_bebob *bebob)
 {
-        break_both_connections(bebob);
-
         cmp_connection_destroy(&bebob->in_conn);
         cmp_connection_destroy(&bebob->out_conn);
 }
@@ -712,22 +710,16 @@ void snd_bebob_stream_update_duplex(struct snd_bebob *bebob)
         mutex_unlock(&bebob->mutex);
 }
 
+/*
+ * This function should be called before starting streams or after stopping
+ * streams.
+ */
 void snd_bebob_stream_destroy_duplex(struct snd_bebob *bebob)
 {
-        mutex_lock(&bebob->mutex);
-
-        amdtp_stream_pcm_abort(&bebob->rx_stream);
-        amdtp_stream_pcm_abort(&bebob->tx_stream);
-
-        amdtp_stream_stop(&bebob->rx_stream);
-        amdtp_stream_stop(&bebob->tx_stream);
-
         amdtp_stream_destroy(&bebob->rx_stream);
         amdtp_stream_destroy(&bebob->tx_stream);
 
         destroy_both_connections(bebob);
-
-        mutex_unlock(&bebob->mutex);
 }
 
 /*
diff --git a/sound/firewire/dice/dice-stream.c b/sound/firewire/dice/dice-stream.c
index fa9cf761b610..07dbd01d7a6b 100644
--- a/sound/firewire/dice/dice-stream.c
+++ b/sound/firewire/dice/dice-stream.c
@@ -311,14 +311,21 @@ end:
         return err;
 }
 
+/*
+ * This function should be called before starting streams or after stopping
+ * streams.
+ */
 static void destroy_stream(struct snd_dice *dice, struct amdtp_stream *stream)
 {
-        amdtp_stream_destroy(stream);
+        struct fw_iso_resources *resources;
 
         if (stream == &dice->tx_stream)
-                fw_iso_resources_destroy(&dice->tx_resources);
+                resources = &dice->tx_resources;
         else
-                fw_iso_resources_destroy(&dice->rx_resources);
+                resources = &dice->rx_resources;
+
+        amdtp_stream_destroy(stream);
+        fw_iso_resources_destroy(resources);
 }
 
 int snd_dice_stream_init_duplex(struct snd_dice *dice)
@@ -332,6 +339,8 @@ int snd_dice_stream_init_duplex(struct snd_dice *dice)
                 goto end;
 
         err = init_stream(dice, &dice->rx_stream);
+        if (err < 0)
+                destroy_stream(dice, &dice->tx_stream);
 end:
         return err;
 }
@@ -340,10 +349,7 @@ void snd_dice_stream_destroy_duplex(struct snd_dice *dice)
 {
         snd_dice_transaction_clear_enable(dice);
 
-        stop_stream(dice, &dice->tx_stream);
         destroy_stream(dice, &dice->tx_stream);
-
-        stop_stream(dice, &dice->rx_stream);
         destroy_stream(dice, &dice->rx_stream);
 
         dice->substreams_counter = 0;
diff --git a/sound/firewire/dice/dice.c b/sound/firewire/dice/dice.c
index 90d8f40ff727..70a111d7f428 100644
--- a/sound/firewire/dice/dice.c
+++ b/sound/firewire/dice/dice.c
@@ -226,11 +226,20 @@ static void dice_card_strings(struct snd_dice *dice)
         strcpy(card->mixername, "DICE");
 }
 
+/*
+ * This module releases the FireWire unit data after all ALSA character devices
+ * are released by applications. This is for releasing stream data or finishing
+ * transactions safely. Thus at returning from .remove(), this module still keep
+ * references for the unit.
+ */
 static void dice_card_free(struct snd_card *card)
 {
         struct snd_dice *dice = card->private_data;
 
+        snd_dice_stream_destroy_duplex(dice);
         snd_dice_transaction_destroy(dice);
+        fw_unit_put(dice->unit);
+
         mutex_destroy(&dice->mutex);
 }
 
@@ -251,7 +260,7 @@ static int dice_probe(struct fw_unit *unit, const struct ieee1394_device_id *id)
 
         dice = card->private_data;
         dice->card = card;
-        dice->unit = unit;
+        dice->unit = fw_unit_get(unit);
         card->private_free = dice_card_free;
 
         spin_lock_init(&dice->lock);
@@ -305,10 +314,7 @@ static void dice_remove(struct fw_unit *unit)
 {
         struct snd_dice *dice = dev_get_drvdata(&unit->device);
 
-        snd_card_disconnect(dice->card);
-
-        snd_dice_stream_destroy_duplex(dice);
-
+        /* No need to wait for releasing card object in this context. */
         snd_card_free_when_closed(dice->card);
 }
 
diff --git a/sound/firewire/fireworks/fireworks.c b/sound/firewire/fireworks/fireworks.c
index 3e2ed8e82cbc..2682e7e3e5c9 100644
--- a/sound/firewire/fireworks/fireworks.c
+++ b/sound/firewire/fireworks/fireworks.c
@@ -173,11 +173,23 @@ end:
         return err;
 }
 
+/*
+ * This module releases the FireWire unit data after all ALSA character devices
+ * are released by applications. This is for releasing stream data or finishing
+ * transactions safely. Thus at returning from .remove(), this module still keep
+ * references for the unit.
+ */
 static void
 efw_card_free(struct snd_card *card)
 {
         struct snd_efw *efw = card->private_data;
 
+        snd_efw_stream_destroy_duplex(efw);
+        snd_efw_transaction_remove_instance(efw);
+        fw_unit_put(efw->unit);
+
+        kfree(efw->resp_buf);
+
         if (efw->card_index >= 0) {
                 mutex_lock(&devices_mutex);
                 clear_bit(efw->card_index, devices_used);
@@ -185,7 +197,6 @@ efw_card_free(struct snd_card *card)
         }
 
         mutex_destroy(&efw->mutex);
-        kfree(efw->resp_buf);
 }
 
 static int
@@ -218,7 +229,7 @@ efw_probe(struct fw_unit *unit,
         card->private_free = efw_card_free;
 
         efw->card = card;
-        efw->unit = unit;
+        efw->unit = fw_unit_get(unit);
         mutex_init(&efw->mutex);
         spin_lock_init(&efw->lock);
         init_waitqueue_head(&efw->hwdep_wait);
@@ -289,10 +300,7 @@ static void efw_remove(struct fw_unit *unit)
 {
         struct snd_efw *efw = dev_get_drvdata(&unit->device);
 
-        snd_efw_stream_destroy_duplex(efw);
-        snd_efw_transaction_remove_instance(efw);
-
-        snd_card_disconnect(efw->card);
+        /* No need to wait for releasing card object in this context. */
         snd_card_free_when_closed(efw->card);
 }
 
diff --git a/sound/firewire/fireworks/fireworks_stream.c b/sound/firewire/fireworks/fireworks_stream.c
index 4f440e163667..c55db1bddc80 100644
--- a/sound/firewire/fireworks/fireworks_stream.c
+++ b/sound/firewire/fireworks/fireworks_stream.c
@@ -100,17 +100,22 @@ end:
         return err;
 }
 
+/*
+ * This function should be called before starting the stream or after stopping
+ * the streams.
+ */
 static void
 destroy_stream(struct snd_efw *efw, struct amdtp_stream *stream)
 {
-        stop_stream(efw, stream);
-
-        amdtp_stream_destroy(stream);
+        struct cmp_connection *conn;
 
         if (stream == &efw->tx_stream)
-                cmp_connection_destroy(&efw->out_conn);
+                conn = &efw->out_conn;
         else
-                cmp_connection_destroy(&efw->in_conn);
+                conn = &efw->in_conn;
+
+        amdtp_stream_destroy(stream);
+        cmp_connection_destroy(&efw->out_conn);
 }
 
 static int
@@ -319,12 +324,8 @@ void snd_efw_stream_update_duplex(struct snd_efw *efw)
 
 void snd_efw_stream_destroy_duplex(struct snd_efw *efw)
 {
-        mutex_lock(&efw->mutex);
-
         destroy_stream(efw, &efw->rx_stream);
         destroy_stream(efw, &efw->tx_stream);
-
-        mutex_unlock(&efw->mutex);
 }
 
 void snd_efw_stream_lock_changed(struct snd_efw *efw)
diff --git a/sound/firewire/oxfw/oxfw-stream.c b/sound/firewire/oxfw/oxfw-stream.c
index bda845afb470..29ccb3637164 100644
--- a/sound/firewire/oxfw/oxfw-stream.c
+++ b/sound/firewire/oxfw/oxfw-stream.c
@@ -337,6 +337,10 @@ void snd_oxfw_stream_stop_simplex(struct snd_oxfw *oxfw,
         stop_stream(oxfw, stream);
 }
 
+/*
+ * This function should be called before starting the stream or after stopping
+ * the streams.
+ */
 void snd_oxfw_stream_destroy_simplex(struct snd_oxfw *oxfw,
                                      struct amdtp_stream *stream)
 {
@@ -347,8 +351,6 @@ void snd_oxfw_stream_destroy_simplex(struct snd_oxfw *oxfw,
         else
                 conn = &oxfw->in_conn;
 
-        stop_stream(oxfw, stream);
-
         amdtp_stream_destroy(stream);
         cmp_connection_destroy(conn);
 }
diff --git a/sound/firewire/oxfw/oxfw.c b/sound/firewire/oxfw/oxfw.c
index 60e5cad0531a..8c6ce019f437 100644
--- a/sound/firewire/oxfw/oxfw.c
+++ b/sound/firewire/oxfw/oxfw.c
@@ -104,11 +104,23 @@ end:
         return err;
 }
 
+/*
+ * This module releases the FireWire unit data after all ALSA character devices
+ * are released by applications. This is for releasing stream data or finishing
+ * transactions safely. Thus at returning from .remove(), this module still keep
+ * references for the unit.
+ */
 static void oxfw_card_free(struct snd_card *card)
 {
         struct snd_oxfw *oxfw = card->private_data;
         unsigned int i;
 
+        snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
+        if (oxfw->has_output)
+                snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->tx_stream);
+
+        fw_unit_put(oxfw->unit);
+
         for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
                 kfree(oxfw->tx_stream_formats[i]);
                 kfree(oxfw->rx_stream_formats[i]);
@@ -136,7 +148,7 @@ static int oxfw_probe(struct fw_unit *unit,
         oxfw = card->private_data;
         oxfw->card = card;
         mutex_init(&oxfw->mutex);
-        oxfw->unit = unit;
+        oxfw->unit = fw_unit_get(unit);
         oxfw->device_info = (const struct device_info *)id->driver_data;
         spin_lock_init(&oxfw->lock);
         init_waitqueue_head(&oxfw->hwdep_wait);
@@ -212,12 +224,7 @@ static void oxfw_remove(struct fw_unit *unit)
 {
         struct snd_oxfw *oxfw = dev_get_drvdata(&unit->device);
 
-        snd_card_disconnect(oxfw->card);
-
-        snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->rx_stream);
-        if (oxfw->has_output)
-                snd_oxfw_stream_destroy_simplex(oxfw, &oxfw->tx_stream);
-
+        /* No need to wait for releasing card object in this context. */
         snd_card_free_when_closed(oxfw->card);
 }
 
diff --git a/sound/i2c/other/ak4113.c b/sound/i2c/other/ak4113.c
index c6bba99a90b2..88844881cbff 100644
--- a/sound/i2c/other/ak4113.c
+++ b/sound/i2c/other/ak4113.c
@@ -89,6 +89,7 @@ int snd_ak4113_create(struct snd_card *card, ak4113_read_t *read,
         chip->private_data = private_data;
         INIT_DELAYED_WORK(&chip->work, ak4113_stats);
         atomic_set(&chip->wq_processing, 0);
+        mutex_init(&chip->reinit_mutex);
 
         for (reg = 0; reg < AK4113_WRITABLE_REGS ; reg++)
                 chip->regmap[reg] = pgm[reg];
@@ -141,7 +142,9 @@ void snd_ak4113_reinit(struct ak4113 *chip)
 {
         if (atomic_inc_return(&chip->wq_processing) == 1)
                 cancel_delayed_work_sync(&chip->work);
+        mutex_lock(&chip->reinit_mutex);
         ak4113_init_regs(chip);
+        mutex_unlock(&chip->reinit_mutex);
         /* bring up statistics / event queing */
         if (atomic_dec_and_test(&chip->wq_processing))
                 schedule_delayed_work(&chip->work, HZ / 10);
@@ -636,3 +639,19 @@ static void ak4113_stats(struct work_struct *work)
         if (atomic_dec_and_test(&chip->wq_processing))
                 schedule_delayed_work(&chip->work, HZ / 10);
 }
+
+#ifdef CONFIG_PM
+void snd_ak4113_suspend(struct ak4113 *chip)
+{
+        atomic_inc(&chip->wq_processing); /* don't schedule new work */
+        cancel_delayed_work_sync(&chip->work);
+}
+EXPORT_SYMBOL(snd_ak4113_suspend);
+
+void snd_ak4113_resume(struct ak4113 *chip)
+{
+        atomic_dec(&chip->wq_processing);
+        snd_ak4113_reinit(chip);
+}
+EXPORT_SYMBOL(snd_ak4113_resume);
+#endif
diff --git a/sound/i2c/other/ak4114.c b/sound/i2c/other/ak4114.c
index b70e6eccbd03..5a4cf3fab4ae 100644
--- a/sound/i2c/other/ak4114.c
+++ b/sound/i2c/other/ak4114.c
@@ -100,6 +100,7 @@ int snd_ak4114_create(struct snd_card *card,
         chip->private_data = private_data;
         INIT_DELAYED_WORK(&chip->work, ak4114_stats);
         atomic_set(&chip->wq_processing, 0);
+        mutex_init(&chip->reinit_mutex);
 
         for (reg = 0; reg < 6; reg++)
                 chip->regmap[reg] = pgm[reg];
@@ -122,6 +123,7 @@ int snd_ak4114_create(struct snd_card *card,
         snd_ak4114_free(chip);
         return err < 0 ? err : -EIO;
 }
+EXPORT_SYMBOL(snd_ak4114_create);
 
 void snd_ak4114_reg_write(struct ak4114 *chip, unsigned char reg, unsigned char mask, unsigned char val)
 {
@@ -131,6 +133,7 @@ void snd_ak4114_reg_write(struct ak4114 *chip, unsigned char reg, unsigned char
                 reg_write(chip, reg,
                           (chip->txcsb[reg-AK4114_REG_TXCSB0] & ~mask) | val);
 }
+EXPORT_SYMBOL(snd_ak4114_reg_write);
 
 static void ak4114_init_regs(struct ak4114 *chip)
 {
@@ -154,11 +157,14 @@ void snd_ak4114_reinit(struct ak4114 *chip)
 {
         if (atomic_inc_return(&chip->wq_processing) == 1)
                 cancel_delayed_work_sync(&chip->work);
+        mutex_lock(&chip->reinit_mutex);
         ak4114_init_regs(chip);
+        mutex_unlock(&chip->reinit_mutex);
         /* bring up statistics / event queing */
         if (atomic_dec_and_test(&chip->wq_processing))
                 schedule_delayed_work(&chip->work, HZ / 10);
 }
+EXPORT_SYMBOL(snd_ak4114_reinit);
 
 static unsigned int external_rate(unsigned char rcs1)
 {
@@ -503,6 +509,7 @@ int snd_ak4114_build(struct ak4114 *ak4114,
         schedule_delayed_work(&ak4114->work, HZ / 10);
         return 0;
 }
+EXPORT_SYMBOL(snd_ak4114_build);
 
 /* notify kcontrols if any parameters are changed */
 static void ak4114_notify(struct ak4114 *ak4114,
@@ -558,6 +565,7 @@ int snd_ak4114_external_rate(struct ak4114 *ak4114)
         rcs1 = reg_read(ak4114, AK4114_REG_RCS1);
         return external_rate(rcs1);
 }
+EXPORT_SYMBOL(snd_ak4114_external_rate);
 
 int snd_ak4114_check_rate_and_errors(struct ak4114 *ak4114, unsigned int flags)
 {
@@ -605,6 +613,7 @@ int snd_ak4114_check_rate_and_errors(struct ak4114 *ak4114, unsigned int flags)
         }
         return res;
 }
+EXPORT_SYMBOL(snd_ak4114_check_rate_and_errors);
 
 static void ak4114_stats(struct work_struct *work)
 {
@@ -616,9 +625,18 @@ static void ak4114_stats(struct work_struct *work)
                 schedule_delayed_work(&chip->work, HZ / 10);
 }
 
-EXPORT_SYMBOL(snd_ak4114_create);
-EXPORT_SYMBOL(snd_ak4114_reg_write);
-EXPORT_SYMBOL(snd_ak4114_reinit);
-EXPORT_SYMBOL(snd_ak4114_build);
-EXPORT_SYMBOL(snd_ak4114_external_rate);
-EXPORT_SYMBOL(snd_ak4114_check_rate_and_errors);
+#ifdef CONFIG_PM
+void snd_ak4114_suspend(struct ak4114 *chip)
+{
+        atomic_inc(&chip->wq_processing); /* don't schedule new work */
+        cancel_delayed_work_sync(&chip->work);
+}
+EXPORT_SYMBOL(snd_ak4114_suspend);
+
+void snd_ak4114_resume(struct ak4114 *chip)
+{
+        atomic_dec(&chip->wq_processing);
+        snd_ak4114_reinit(chip);
+}
+EXPORT_SYMBOL(snd_ak4114_resume);
+#endif
diff --git a/sound/i2c/other/ak4117.c b/sound/i2c/other/ak4117.c
index 88452e899bd9..48848909a5a9 100644
--- a/sound/i2c/other/ak4117.c
+++ b/sound/i2c/other/ak4117.c
@@ -91,9 +91,7 @@ int snd_ak4117_create(struct snd_card *card, ak4117_read_t *read, ak4117_write_t
         chip->read = read;
         chip->write = write;
         chip->private_data = private_data;
-        init_timer(&chip->timer);
-        chip->timer.data = (unsigned long)chip;
-        chip->timer.function = snd_ak4117_timer;
+        setup_timer(&chip->timer, snd_ak4117_timer, (unsigned long)chip);
 
         for (reg = 0; reg < 5; reg++)
                 chip->regmap[reg] = pgm[reg];
@@ -139,8 +137,7 @@ void snd_ak4117_reinit(struct ak4117 *chip)
         /* release powerdown, everything is initialized now */
         reg_write(chip, AK4117_REG_PWRDN, old | AK4117_RST | AK4117_PWN);
         chip->init = 0;
-        chip->timer.expires = 1 + jiffies;
-        add_timer(&chip->timer);
+        mod_timer(&chip->timer, 1 + jiffies);
 }
 
 static unsigned int external_rate(unsigned char rcs1)
@@ -540,8 +537,7 @@ static void snd_ak4117_timer(unsigned long data)
         if (chip->init)
                 return;
         snd_ak4117_check_rate_and_errors(chip, 0);
-        chip->timer.expires = 1 + jiffies;
-        add_timer(&chip->timer);
+        mod_timer(&chip->timer, 1 + jiffies);
 }
 
 EXPORT_SYMBOL(snd_ak4117_create);
diff --git a/sound/i2c/other/ak4xxx-adda.c b/sound/i2c/other/ak4xxx-adda.c
index 67dbfde837ab..c65731088aa2 100644
--- a/sound/i2c/other/ak4xxx-adda.c
+++ b/sound/i2c/other/ak4xxx-adda.c
@@ -21,7 +21,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
diff --git a/sound/isa/ad1816a/ad1816a.c b/sound/isa/ad1816a/ad1816a.c
index f481a41e027e..769226515f0d 100644
--- a/sound/isa/ad1816a/ad1816a.c
+++ b/sound/isa/ad1816a/ad1816a.c
@@ -142,7 +142,6 @@ static int snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard,
         struct snd_card *card;
         struct snd_ad1816a *chip;
         struct snd_opl3 *opl3;
-        struct snd_timer *timer;
 
         error = snd_card_new(&pcard->card->dev,
                              index[dev], id[dev], THIS_MODULE,
@@ -172,7 +171,7 @@ static int snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard,
         sprintf(card->longname, "%s, SS at 0x%lx, irq %d, dma %d&%d",
                 card->shortname, chip->port, irq[dev], dma1[dev], dma2[dev]);
 
-        if ((error = snd_ad1816a_pcm(chip, 0, NULL)) < 0) {
+        if ((error = snd_ad1816a_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return error;
         }
@@ -182,7 +181,7 @@ static int snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard,
                 return error;
         }
 
-        error = snd_ad1816a_timer(chip, 0, &timer);
+        error = snd_ad1816a_timer(chip, 0);
         if (error < 0) {
                 snd_card_free(card);
                 return error;
diff --git a/sound/isa/ad1816a/ad1816a_lib.c b/sound/isa/ad1816a/ad1816a_lib.c
index 01a07986f4a3..5c815f5fb044 100644
--- a/sound/isa/ad1816a/ad1816a_lib.c
+++ b/sound/isa/ad1816a/ad1816a_lib.c
@@ -22,11 +22,11 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/ioport.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/tlv.h>
 #include <sound/ad1816a.h>
 
-#include <asm/io.h>
 #include <asm/dma.h>
 
 static inline int snd_ad1816a_busy_wait(struct snd_ad1816a *chip)
@@ -675,7 +675,7 @@ static struct snd_pcm_ops snd_ad1816a_capture_ops = {
         .pointer =      snd_ad1816a_capture_pointer,
 };
 
-int snd_ad1816a_pcm(struct snd_ad1816a *chip, int device, struct snd_pcm **rpcm)
+int snd_ad1816a_pcm(struct snd_ad1816a *chip, int device)
 {
         int error;
         struct snd_pcm *pcm;
@@ -697,13 +697,10 @@ int snd_ad1816a_pcm(struct snd_ad1816a *chip, int device, struct snd_pcm **rpcm)
                                               64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
 
         chip->pcm = pcm;
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
-int snd_ad1816a_timer(struct snd_ad1816a *chip, int device,
-                      struct snd_timer **rtimer)
+int snd_ad1816a_timer(struct snd_ad1816a *chip, int device)
 {
         struct snd_timer *timer;
         struct snd_timer_id tid;
@@ -720,8 +717,6 @@ int snd_ad1816a_timer(struct snd_ad1816a *chip, int device,
         timer->private_data = chip;
         chip->timer = timer;
         timer->hw = snd_ad1816a_timer_table;
-        if (rtimer)
-                *rtimer = timer;
         return 0;
 }
 
diff --git a/sound/isa/ad1848/ad1848.c b/sound/isa/ad1848/ad1848.c
index 093f22a464d7..f159da4ec890 100644
--- a/sound/isa/ad1848/ad1848.c
+++ b/sound/isa/ad1848/ad1848.c
@@ -88,7 +88,6 @@ static int snd_ad1848_probe(struct device *dev, unsigned int n)
 {
         struct snd_card *card;
         struct snd_wss *chip;
-        struct snd_pcm *pcm;
         int error;
 
         error = snd_card_new(dev, index[n], id[n], THIS_MODULE, 0, &card);
@@ -103,7 +102,7 @@ static int snd_ad1848_probe(struct device *dev, unsigned int n)
 
         card->private_data = chip;
 
-        error = snd_wss_pcm(chip, 0, &pcm);
+        error = snd_wss_pcm(chip, 0);
         if (error < 0)
                 goto out;
 
@@ -112,10 +111,10 @@ static int snd_ad1848_probe(struct device *dev, unsigned int n)
                 goto out;
 
         strcpy(card->driver, "AD1848");
-        strcpy(card->shortname, pcm->name);
+        strcpy(card->shortname, chip->pcm->name);
 
         sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
-                pcm->name, chip->port, irq[n], dma1[n]);
+                chip->pcm->name, chip->port, irq[n], dma1[n]);
         if (thinkpad[n])
                 strcat(card->longname, " [Thinkpad]");
 
diff --git a/sound/isa/als100.c b/sound/isa/als100.c
index 32d01525211d..bc9ea306ee02 100644
--- a/sound/isa/als100.c
+++ b/sound/isa/als100.c
@@ -233,7 +233,7 @@ static int snd_card_als100_probe(int dev,
                         irq[dev], dma8[dev], dma16[dev]);
         }
 
-        if ((error = snd_sb16dsp_pcm(chip, 0, &chip->pcm)) < 0) {
+        if ((error = snd_sb16dsp_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return error;
         }
diff --git a/sound/isa/azt2320.c b/sound/isa/azt2320.c
index 0ea75fc62072..fff186fa621e 100644
--- a/sound/isa/azt2320.c
+++ b/sound/isa/azt2320.c
@@ -29,7 +29,7 @@
     activation method (full-duplex audio!).
 */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/time.h>
@@ -215,7 +215,7 @@ static int snd_card_azt2320_probe(int dev,
         sprintf(card->longname, "%s, WSS at 0x%lx, irq %i, dma %i&%i",
                 card->shortname, chip->port, irq[dev], dma1[dev], dma2[dev]);
 
-        error = snd_wss_pcm(chip, 0, NULL);
+        error = snd_wss_pcm(chip, 0);
         if (error < 0) {
                 snd_card_free(card);
                 return error;
@@ -225,7 +225,7 @@ static int snd_card_azt2320_probe(int dev,
                 snd_card_free(card);
                 return error;
         }
-        error = snd_wss_timer(chip, 0, NULL);
+        error = snd_wss_timer(chip, 0);
         if (error < 0) {
                 snd_card_free(card);
                 return error;
diff --git a/sound/isa/cmi8328.c b/sound/isa/cmi8328.c
index 4778852a1201..2c89d95da674 100644
--- a/sound/isa/cmi8328.c
+++ b/sound/isa/cmi8328.c
@@ -307,7 +307,7 @@ static int snd_cmi8328_probe(struct device *pdev, unsigned int ndev)
         if (err < 0)
                 goto error;
 
-        err = snd_wss_pcm(cmi->wss, 0, NULL);
+        err = snd_wss_pcm(cmi->wss, 0);
         if (err < 0)
                 goto error;
 
@@ -318,7 +318,7 @@ static int snd_cmi8328_probe(struct device *pdev, unsigned int ndev)
         if (err < 0)
                 goto error;
 
-        if (snd_wss_timer(cmi->wss, 0, NULL) < 0)
+        if (snd_wss_timer(cmi->wss, 0) < 0)
                 snd_printk(KERN_WARNING "error initializing WSS timer\n");
 
         if (mpuport[ndev] == SNDRV_AUTO_PORT) {
diff --git a/sound/isa/cs423x/cs4231.c b/sound/isa/cs423x/cs4231.c
index 7dba07a4343a..282cd75d2235 100644
--- a/sound/isa/cs423x/cs4231.c
+++ b/sound/isa/cs423x/cs4231.c
@@ -92,7 +92,6 @@ static int snd_cs4231_probe(struct device *dev, unsigned int n)
 {
         struct snd_card *card;
         struct snd_wss *chip;
-        struct snd_pcm *pcm;
         int error;
 
         error = snd_card_new(dev, index[n], id[n], THIS_MODULE, 0, &card);
@@ -106,15 +105,15 @@ static int snd_cs4231_probe(struct device *dev, unsigned int n)
 
         card->private_data = chip;
 
-        error = snd_wss_pcm(chip, 0, &pcm);
+        error = snd_wss_pcm(chip, 0);
         if (error < 0)
                 goto out;
 
         strcpy(card->driver, "CS4231");
-        strcpy(card->shortname, pcm->name);
+        strcpy(card->shortname, chip->pcm->name);
 
         sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
-                pcm->name, chip->port, irq[n], dma1[n]);
+                chip->pcm->name, chip->port, irq[n], dma1[n]);
         if (dma2[n] >= 0)
                 sprintf(card->longname + strlen(card->longname), "&%d", dma2[n]);
 
@@ -122,7 +121,7 @@ static int snd_cs4231_probe(struct device *dev, unsigned int n)
         if (error < 0)
                 goto out;
 
-        error = snd_wss_timer(chip, 0, NULL);
+        error = snd_wss_timer(chip, 0);
         if (error < 0)
                 goto out;
 
diff --git a/sound/isa/cs423x/cs4236.c b/sound/isa/cs423x/cs4236.c
index 750f51c904fc..9d7582c90a95 100644
--- a/sound/isa/cs423x/cs4236.c
+++ b/sound/isa/cs423x/cs4236.c
@@ -382,7 +382,6 @@ static int snd_cs423x_card_new(struct device *pdev, int dev,
 static int snd_cs423x_probe(struct snd_card *card, int dev)
 {
         struct snd_card_cs4236 *acard;
-        struct snd_pcm *pcm;
         struct snd_wss *chip;
         struct snd_opl3 *opl3;
         int err;
@@ -404,7 +403,7 @@ static int snd_cs423x_probe(struct snd_card *card, int dev)
         acard->chip = chip;
         if (chip->hardware & WSS_HW_CS4236B_MASK) {
 
-                err = snd_cs4236_pcm(chip, 0, &pcm);
+                err = snd_cs4236_pcm(chip, 0);
                 if (err < 0)
                         return err;
 
@@ -412,7 +411,7 @@ static int snd_cs423x_probe(struct snd_card *card, int dev)
                 if (err < 0)
                         return err;
         } else {
-                err = snd_wss_pcm(chip, 0, &pcm);
+                err = snd_wss_pcm(chip, 0);
                 if (err < 0)
                         return err;
 
@@ -420,17 +419,17 @@ static int snd_cs423x_probe(struct snd_card *card, int dev)
                 if (err < 0)
                         return err;
         }
-        strcpy(card->driver, pcm->name);
-        strcpy(card->shortname, pcm->name);
+        strcpy(card->driver, chip->pcm->name);
+        strcpy(card->shortname, chip->pcm->name);
         sprintf(card->longname, "%s at 0x%lx, irq %i, dma %i",
-                pcm->name,
+                chip->pcm->name,
                 chip->port,
                 irq[dev],
                 dma1[dev]);
         if (dma2[dev] >= 0)
                 sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]);
 
-        err = snd_wss_timer(chip, 0, NULL);
+        err = snd_wss_timer(chip, 0);
         if (err < 0)
                 return err;
 
diff --git a/sound/isa/cs423x/cs4236_lib.c b/sound/isa/cs423x/cs4236_lib.c
index c5adca300632..2b7cc596f4c6 100644
--- a/sound/isa/cs423x/cs4236_lib.c
+++ b/sound/isa/cs423x/cs4236_lib.c
@@ -79,7 +79,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/time.h>
@@ -376,17 +376,14 @@ int snd_cs4236_create(struct snd_card *card,
         return 0;
 }
 
-int snd_cs4236_pcm(struct snd_wss *chip, int device, struct snd_pcm **rpcm)
+int snd_cs4236_pcm(struct snd_wss *chip, int device)
 {
-        struct snd_pcm *pcm;
         int err;
         
-        err = snd_wss_pcm(chip, device, &pcm);
+        err = snd_wss_pcm(chip, device);
         if (err < 0)
                 return err;
-        pcm->info_flags &= ~SNDRV_PCM_INFO_JOINT_DUPLEX;
-        if (rpcm)
-                *rpcm = pcm;
+        chip->pcm->info_flags &= ~SNDRV_PCM_INFO_JOINT_DUPLEX;
         return 0;
 }
 
diff --git a/sound/isa/es1688/es1688.c b/sound/isa/es1688/es1688.c
index 76001fe0579d..1901c2bb6c3b 100644
--- a/sound/isa/es1688/es1688.c
+++ b/sound/isa/es1688/es1688.c
@@ -138,10 +138,9 @@ static int snd_es1688_probe(struct snd_card *card, unsigned int n)
 {
         struct snd_es1688 *chip = card->private_data;
         struct snd_opl3 *opl3;
-        struct snd_pcm *pcm;
         int error;
 
-        error = snd_es1688_pcm(card, chip, 0, &pcm);
+        error = snd_es1688_pcm(card, chip, 0);
         if (error < 0)
                 return error;
 
@@ -150,9 +149,9 @@ static int snd_es1688_probe(struct snd_card *card, unsigned int n)
                 return error;
 
         strlcpy(card->driver, "ES1688", sizeof(card->driver));
-        strlcpy(card->shortname, pcm->name, sizeof(card->shortname));
+        strlcpy(card->shortname, chip->pcm->name, sizeof(card->shortname));
         snprintf(card->longname, sizeof(card->longname),
-                "%s at 0x%lx, irq %i, dma %i", pcm->name, chip->port,
+                "%s at 0x%lx, irq %i, dma %i", chip->pcm->name, chip->port,
                  chip->irq, chip->dma8);
 
         if (fm_port[n] == SNDRV_AUTO_PORT)
diff --git a/sound/isa/es1688/es1688_lib.c b/sound/isa/es1688/es1688_lib.c
index b5450143407b..e2cf508841b1 100644
--- a/sound/isa/es1688/es1688_lib.c
+++ b/sound/isa/es1688/es1688_lib.c
@@ -25,11 +25,11 @@
 #include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/module.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/es1688.h>
 #include <sound/initval.h>
 
-#include <asm/io.h>
 #include <asm/dma.h>
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
@@ -728,8 +728,7 @@ static struct snd_pcm_ops snd_es1688_capture_ops = {
         .pointer =              snd_es1688_capture_pointer,
 };
 
-int snd_es1688_pcm(struct snd_card *card, struct snd_es1688 *chip,
-                   int device, struct snd_pcm **rpcm)
+int snd_es1688_pcm(struct snd_card *card, struct snd_es1688 *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
@@ -749,9 +748,6 @@ int snd_es1688_pcm(struct snd_card *card, struct snd_es1688 *chip,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_isa_data(),
                                               64*1024, 64*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
diff --git a/sound/isa/es18xx.c b/sound/isa/es18xx.c
index b481bb8c31bc..5094b62d8f77 100644
--- a/sound/isa/es18xx.c
+++ b/sound/isa/es18xx.c
@@ -84,8 +84,8 @@
 #include <linux/isapnp.h>
 #include <linux/module.h>
 #include <linux/delay.h>
+#include <linux/io.h>
 
-#include <asm/io.h>
 #include <asm/dma.h>
 #include <sound/core.h>
 #include <sound/control.h>
@@ -1687,16 +1687,13 @@ static struct snd_pcm_ops snd_es18xx_capture_ops = {
         .pointer =      snd_es18xx_capture_pointer,
 };
 
-static int snd_es18xx_pcm(struct snd_card *card, int device,
-                          struct snd_pcm **rpcm)
+static int snd_es18xx_pcm(struct snd_card *card, int device)
 {
         struct snd_es18xx *chip = card->private_data;
         struct snd_pcm *pcm;
         char str[16];
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         sprintf(str, "ES%x", chip->version);
         if (chip->caps & ES18XX_PCM2)
                 err = snd_pcm_new(card, str, device, 2, 1, &pcm);
@@ -1722,9 +1719,6 @@ static int snd_es18xx_pcm(struct snd_card *card, int device,
                                               snd_dma_isa_data(),
                                               64*1024,
                                               chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -2154,7 +2148,7 @@ static int snd_audiodrive_probe(struct snd_card *card, int dev)
                         chip->port,
                         irq[dev], dma1[dev]);
 
-        err = snd_es18xx_pcm(card, 0, NULL);
+        err = snd_es18xx_pcm(card, 0);
         if (err < 0)
                 return err;
 
diff --git a/sound/isa/galaxy/galaxy.c b/sound/isa/galaxy/galaxy.c
index 1eb2b1ec0fd9..32278847884f 100644
--- a/sound/isa/galaxy/galaxy.c
+++ b/sound/isa/galaxy/galaxy.c
@@ -569,7 +569,7 @@ static int snd_galaxy_probe(struct device *dev, unsigned int n)
         if (err < 0)
                 goto error;
 
-        err = snd_wss_pcm(chip, 0, NULL);
+        err = snd_wss_pcm(chip, 0);
         if (err < 0)
                 goto error;
 
@@ -577,7 +577,7 @@ static int snd_galaxy_probe(struct device *dev, unsigned int n)
         if (err < 0)
                 goto error;
 
-        err = snd_wss_timer(chip, 0, NULL);
+        err = snd_wss_timer(chip, 0);
         if (err < 0)
                 goto error;
 
diff --git a/sound/isa/gus/gus_instr.c b/sound/isa/gus/gus_instr.c
deleted file mode 100644
index 4dc9caf8ddcf..000000000000
--- a/sound/isa/gus/gus_instr.c
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- *  Routines for Gravis UltraSound soundcards - Synthesizer
- *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
- *
- *
- *   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/time.h>
-#include <sound/core.h>
-#include <sound/gus.h>
-
-/*
- *
- */
-
-int snd_gus_iwffff_put_sample(void *private_data, struct iwffff_wave *wave,
-                              char __user *data, long len, int atomic)
-{
-        struct snd_gus_card *gus = private_data;
-        struct snd_gf1_mem_block *block;
-        int err;
-
-        if (wave->format & IWFFFF_WAVE_ROM)
-                return 0;       /* it's probably ok - verify the address? */
-        if (wave->format & IWFFFF_WAVE_STEREO)
-                return -EINVAL; /* not supported */
-        block = snd_gf1_mem_alloc(&gus->gf1.mem_alloc,
-                                  SNDRV_GF1_MEM_OWNER_WAVE_IWFFFF,
-                                  NULL, wave->size,
-                                  wave->format & IWFFFF_WAVE_16BIT, 1,
-                                  wave->share_id);
-        if (block == NULL)
-                return -ENOMEM;
-        err = snd_gus_dram_write(gus, data,
-                                 block->ptr, wave->size);
-        if (err < 0) {
-                snd_gf1_mem_lock(&gus->gf1.mem_alloc, 0);
-                snd_gf1_mem_xfree(&gus->gf1.mem_alloc, block);
-                snd_gf1_mem_lock(&gus->gf1.mem_alloc, 1);
-                return err;
-        }
-        wave->address.memory = block->ptr;
-        return 0;
-}
-
-int snd_gus_iwffff_get_sample(void *private_data, struct iwffff_wave *wave,
-                              char __user *data, long len, int atomic)
-{
-        struct snd_gus_card *gus = private_data;
-
-        return snd_gus_dram_read(gus, data, wave->address.memory, wave->size,
-                                 wave->format & IWFFFF_WAVE_ROM ? 1 : 0);
-}
-
-int snd_gus_iwffff_remove_sample(void *private_data, struct iwffff_wave *wave,
-                                 int atomic)
-{
-        struct snd_gus_card *gus = private_data;
-
-        if (wave->format & IWFFFF_WAVE_ROM)
-                return 0;       /* it's probably ok - verify the address? */    
-        return snd_gf1_mem_free(&gus->gf1.mem_alloc, wave->address.memory);
-}
-
-/*
- *
- */
-
-int snd_gus_gf1_put_sample(void *private_data, struct gf1_wave *wave,
-                           char __user *data, long len, int atomic)
-{
-        struct snd_gus_card *gus = private_data;
-        struct snd_gf1_mem_block *block;
-        int err;
-
-        if (wave->format & GF1_WAVE_STEREO)
-                return -EINVAL; /* not supported */
-        block = snd_gf1_mem_alloc(&gus->gf1.mem_alloc,
-                                  SNDRV_GF1_MEM_OWNER_WAVE_GF1,
-                                  NULL, wave->size,
-                                  wave->format & GF1_WAVE_16BIT, 1,
-                                  wave->share_id);
-        if (block == NULL)
-                return -ENOMEM;
-        err = snd_gus_dram_write(gus, data,
-                                 block->ptr, wave->size);
-        if (err < 0) {
-                snd_gf1_mem_lock(&gus->gf1.mem_alloc, 0);
-                snd_gf1_mem_xfree(&gus->gf1.mem_alloc, block);
-                snd_gf1_mem_lock(&gus->gf1.mem_alloc, 1);
-                return err;
-        }
-        wave->address.memory = block->ptr;
-        return 0;
-}
-
-int snd_gus_gf1_get_sample(void *private_data, struct gf1_wave *wave,
-                           char __user *data, long len, int atomic)
-{
-        struct snd_gus_card *gus = private_data;
-
-        return snd_gus_dram_read(gus, data, wave->address.memory, wave->size, 0);
-}
-
-int snd_gus_gf1_remove_sample(void *private_data, struct gf1_wave *wave,
-                              int atomic)
-{
-        struct snd_gus_card *gus = private_data;
-
-        return snd_gf1_mem_free(&gus->gf1.mem_alloc, wave->address.memory);
-}
-
-/*
- *
- */
-
-int snd_gus_simple_put_sample(void *private_data, struct simple_instrument *instr,
-                              char __user *data, long len, int atomic)
-{
-        struct snd_gus_card *gus = private_data;
-        struct snd_gf1_mem_block *block;
-        int err;
-
-        if (instr->format & SIMPLE_WAVE_STEREO)
-                return -EINVAL; /* not supported */
-        block = snd_gf1_mem_alloc(&gus->gf1.mem_alloc,
-                                  SNDRV_GF1_MEM_OWNER_WAVE_SIMPLE,
-                                  NULL, instr->size,
-                                  instr->format & SIMPLE_WAVE_16BIT, 1,
-                                  instr->share_id);
-        if (block == NULL)
-                return -ENOMEM;
-        err = snd_gus_dram_write(gus, data, block->ptr, instr->size);
-        if (err < 0) {
-                snd_gf1_mem_lock(&gus->gf1.mem_alloc, 0);
-                snd_gf1_mem_xfree(&gus->gf1.mem_alloc, block);
-                snd_gf1_mem_lock(&gus->gf1.mem_alloc, 1);
-                return err;
-        }
-        instr->address.memory = block->ptr;
-        return 0;
-}
-
-int snd_gus_simple_get_sample(void *private_data, struct simple_instrument *instr,
-                              char __user *data, long len, int atomic)
-{
-        struct snd_gus_card *gus = private_data;
-
-        return snd_gus_dram_read(gus, data, instr->address.memory, instr->size, 0);
-}
-
-int snd_gus_simple_remove_sample(void *private_data, struct simple_instrument *instr,
-                                 int atomic)
-{
-        struct snd_gus_card *gus = private_data;
-
-        return snd_gf1_mem_free(&gus->gf1.mem_alloc, instr->address.memory);
-}
diff --git a/sound/isa/gus/gus_pcm.c b/sound/isa/gus/gus_pcm.c
index 2dcf45bf7293..25f6788ccef3 100644
--- a/sound/isa/gus/gus_pcm.c
+++ b/sound/isa/gus/gus_pcm.c
@@ -849,7 +849,7 @@ static struct snd_pcm_ops snd_gf1_pcm_capture_ops = {
         .pointer =      snd_gf1_pcm_capture_pointer,
 };
 
-int snd_gf1_pcm_new(struct snd_gus_card * gus, int pcm_dev, int control_index, struct snd_pcm ** rpcm)
+int snd_gf1_pcm_new(struct snd_gus_card *gus, int pcm_dev, int control_index)
 {
         struct snd_card *card;
         struct snd_kcontrol *kctl;
@@ -857,8 +857,6 @@ int snd_gf1_pcm_new(struct snd_gus_card * gus, int pcm_dev, int control_index, s
         struct snd_pcm_substream *substream;
         int capture, err;
 
-        if (rpcm)
-                *rpcm = NULL;
         card = gus->card;
         capture = !gus->interwave && !gus->ess_flag && !gus->ace_flag ? 1 : 0;
         err = snd_pcm_new(card,
@@ -903,8 +901,6 @@ int snd_gf1_pcm_new(struct snd_gus_card * gus, int pcm_dev, int control_index, s
                 return err;
         kctl->id.index = control_index;
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
diff --git a/sound/isa/gus/gus_uart.c b/sound/isa/gus/gus_uart.c
index 21cc42e4c4be..3992912743f5 100644
--- a/sound/isa/gus/gus_uart.c
+++ b/sound/isa/gus/gus_uart.c
@@ -241,13 +241,11 @@ static struct snd_rawmidi_ops snd_gf1_uart_input =
         .trigger =      snd_gf1_uart_input_trigger,
 };
 
-int snd_gf1_rawmidi_new(struct snd_gus_card * gus, int device, struct snd_rawmidi ** rrawmidi)
+int snd_gf1_rawmidi_new(struct snd_gus_card *gus, int device)
 {
         struct snd_rawmidi *rmidi;
         int err;
 
-        if (rrawmidi)
-                *rrawmidi = NULL;
         if ((err = snd_rawmidi_new(gus->card, "GF1", device, 1, 1, &rmidi)) < 0)
                 return err;
         strcpy(rmidi->name, gus->interwave ? "AMD InterWave" : "GF1");
@@ -256,7 +254,5 @@ int snd_gf1_rawmidi_new(struct snd_gus_card * gus, int device, struct snd_rawmid
         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
         rmidi->private_data = gus;
         gus->midi_uart = rmidi;
-        if (rrawmidi)
-                *rrawmidi = rmidi;
         return err;
 }
diff --git a/sound/isa/gus/gusclassic.c b/sound/isa/gus/gusclassic.c
index 7ce29ffa1af9..f0019715d82e 100644
--- a/sound/isa/gus/gusclassic.c
+++ b/sound/isa/gus/gusclassic.c
@@ -181,12 +181,12 @@ static int snd_gusclassic_probe(struct device *dev, unsigned int n)
         if (error < 0)
                 goto out;
 
-        error = snd_gf1_pcm_new(gus, 0, 0, NULL);
+        error = snd_gf1_pcm_new(gus, 0, 0);
         if (error < 0)
                 goto out;
 
         if (!gus->ace_flag) {
-                error = snd_gf1_rawmidi_new(gus, 0, NULL);
+                error = snd_gf1_rawmidi_new(gus, 0);
                 if (error < 0)
                         goto out;
         }
diff --git a/sound/isa/gus/gusextreme.c b/sound/isa/gus/gusextreme.c
index 28a16936a397..693d95f46804 100644
--- a/sound/isa/gus/gusextreme.c
+++ b/sound/isa/gus/gusextreme.c
@@ -284,7 +284,7 @@ static int snd_gusextreme_probe(struct device *dev, unsigned int n)
         }
         gus->codec_flag = 1;
 
-        error = snd_es1688_pcm(card, es1688, 0, NULL);
+        error = snd_es1688_pcm(card, es1688, 0);
         if (error < 0)
                 goto out;
 
@@ -295,7 +295,7 @@ static int snd_gusextreme_probe(struct device *dev, unsigned int n)
         snd_component_add(card, "ES1688");
 
         if (pcm_channels[n] > 0) {
-                error = snd_gf1_pcm_new(gus, 1, 1, NULL);
+                error = snd_gf1_pcm_new(gus, 1, 1);
                 if (error < 0)
                         goto out;
         }
diff --git a/sound/isa/gus/gusmax.c b/sound/isa/gus/gusmax.c
index 39df36ca3acb..8216e8d8f017 100644
--- a/sound/isa/gus/gusmax.c
+++ b/sound/isa/gus/gusmax.c
@@ -309,7 +309,7 @@ static int snd_gusmax_probe(struct device *pdev, unsigned int dev)
         if (err < 0)
                 goto _err;
 
-        err = snd_wss_pcm(wss, 0, NULL);
+        err = snd_wss_pcm(wss, 0);
         if (err < 0)
                 goto _err;
 
@@ -317,19 +317,19 @@ static int snd_gusmax_probe(struct device *pdev, unsigned int dev)
         if (err < 0)
                 goto _err;
 
-        err = snd_wss_timer(wss, 2, NULL);
+        err = snd_wss_timer(wss, 2);
         if (err < 0)
                 goto _err;
 
         if (pcm_channels[dev] > 0) {
-                if ((err = snd_gf1_pcm_new(gus, 1, 1, NULL)) < 0)
+                if ((err = snd_gf1_pcm_new(gus, 1, 1)) < 0)
                         goto _err;
         }
         err = snd_gusmax_mixer(wss);
         if (err < 0)
                 goto _err;
 
-        err = snd_gf1_rawmidi_new(gus, 0, NULL);
+        err = snd_gf1_rawmidi_new(gus, 0);
         if (err < 0)
                 goto _err;
 
diff --git a/sound/isa/gus/interwave.c b/sound/isa/gus/interwave.c
index ad55e5cb8e94..70d0040484c8 100644
--- a/sound/isa/gus/interwave.c
+++ b/sound/isa/gus/interwave.c
@@ -647,7 +647,6 @@ static int snd_interwave_probe(struct snd_card *card, int dev)
 #ifdef SNDRV_STB
         struct snd_i2c_bus *i2c_bus;
 #endif
-        struct snd_pcm *pcm;
         char *str;
         int err;
 
@@ -695,14 +694,15 @@ static int snd_interwave_probe(struct snd_card *card, int dev)
         if (err < 0)
                 return err;
 
-        err = snd_wss_pcm(wss, 0, &pcm);
+        err = snd_wss_pcm(wss, 0);
         if (err < 0)
                 return err;
 
-        sprintf(pcm->name + strlen(pcm->name), " rev %c", gus->revision + 'A');
-        strcat(pcm->name, " (codec)");
+        sprintf(wss->pcm->name + strlen(wss->pcm->name), " rev %c",
+                gus->revision + 'A');
+        strcat(wss->pcm->name, " (codec)");
 
-        err = snd_wss_timer(wss, 2, NULL);
+        err = snd_wss_timer(wss, 2);
         if (err < 0)
                 return err;
 
@@ -711,7 +711,7 @@ static int snd_interwave_probe(struct snd_card *card, int dev)
                 return err;
 
         if (pcm_channels[dev] > 0) {
-                err = snd_gf1_pcm_new(gus, 1, 1, NULL);
+                err = snd_gf1_pcm_new(gus, 1, 1);
                 if (err < 0)
                         return err;
         }
@@ -740,7 +740,7 @@ static int snd_interwave_probe(struct snd_card *card, int dev)
 #endif
 
         gus->uart_enable = midi[dev];
-        if ((err = snd_gf1_rawmidi_new(gus, 0, NULL)) < 0)
+        if ((err = snd_gf1_rawmidi_new(gus, 0)) < 0)
                 return err;
 
 #ifndef SNDRV_STB
diff --git a/sound/isa/msnd/msnd.c b/sound/isa/msnd/msnd.c
index 1cee18fb28a8..835d4aa26761 100644
--- a/sound/isa/msnd/msnd.c
+++ b/sound/isa/msnd/msnd.c
@@ -679,8 +679,7 @@ static struct snd_pcm_ops snd_msnd_capture_ops = {
 };
 
 
-int snd_msnd_pcm(struct snd_card *card, int device,
-                        struct snd_pcm **rpcm)
+int snd_msnd_pcm(struct snd_card *card, int device)
 {
         struct snd_msnd *chip = card->private_data;
         struct snd_pcm  *pcm;
@@ -696,9 +695,6 @@ int snd_msnd_pcm(struct snd_card *card, int device,
         pcm->private_data = chip;
         strcpy(pcm->name, "Hurricane");
 
-
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 EXPORT_SYMBOL(snd_msnd_pcm);
diff --git a/sound/isa/msnd/msnd.h b/sound/isa/msnd/msnd.h
index dbac3a42347b..5f3c7dcd9f9d 100644
--- a/sound/isa/msnd/msnd.h
+++ b/sound/isa/msnd/msnd.h
@@ -297,7 +297,7 @@ int snd_msnd_disable_irq(struct snd_msnd *chip);
 void snd_msnd_dsp_halt(struct snd_msnd *chip, struct file *file);
 int snd_msnd_DAPQ(struct snd_msnd *chip, int start);
 int snd_msnd_DARQ(struct snd_msnd *chip, int start);
-int snd_msnd_pcm(struct snd_card *card, int device, struct snd_pcm **rpcm);
+int snd_msnd_pcm(struct snd_card *card, int device);
 
 int snd_msndmidi_new(struct snd_card *card, int device);
 void snd_msndmidi_input_read(void *mpu);
diff --git a/sound/isa/msnd/msnd_pinnacle.c b/sound/isa/msnd/msnd_pinnacle.c
index 5016bf957f51..4c072666115d 100644
--- a/sound/isa/msnd/msnd_pinnacle.c
+++ b/sound/isa/msnd/msnd_pinnacle.c
@@ -582,7 +582,7 @@ static int snd_msnd_attach(struct snd_card *card)
         if (err < 0)
                 goto err_release_region;
 
-        err = snd_msnd_pcm(card, 0, NULL);
+        err = snd_msnd_pcm(card, 0);
         if (err < 0) {
                 printk(KERN_ERR LOGNAME ": error creating new PCM device\n");
                 goto err_release_region;
@@ -627,8 +627,7 @@ static int snd_msnd_attach(struct snd_card *card)
         return 0;
 
 err_release_region:
-        if (chip->mappedbase)
-                iounmap(chip->mappedbase);
+        iounmap(chip->mappedbase);
         release_mem_region(chip->base, BUFFSIZE);
         release_region(chip->io, DSP_NUMIO);
         free_irq(chip->irq, chip);
diff --git a/sound/isa/opl3sa2.c b/sound/isa/opl3sa2.c
index a219bc37816b..ae133633a420 100644
--- a/sound/isa/opl3sa2.c
+++ b/sound/isa/opl3sa2.c
@@ -26,6 +26,7 @@
 #include <linux/pm.h>
 #include <linux/pnp.h>
 #include <linux/module.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/wss.h>
 #include <sound/mpu401.h>
@@ -33,8 +34,6 @@
 #include <sound/initval.h>
 #include <sound/tlv.h>
 
-#include <asm/io.h>
-
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 MODULE_DESCRIPTION("Yamaha OPL3SA2+");
 MODULE_LICENSE("GPL");
@@ -684,7 +683,7 @@ static int snd_opl3sa2_probe(struct snd_card *card, int dev)
                 return err;
         }
         chip->wss = wss;
-        err = snd_wss_pcm(wss, 0, NULL);
+        err = snd_wss_pcm(wss, 0);
         if (err < 0)
                 return err;
         err = snd_wss_mixer(wss);
@@ -693,7 +692,7 @@ static int snd_opl3sa2_probe(struct snd_card *card, int dev)
         err = snd_opl3sa2_mixer(card);
         if (err < 0)
                 return err;
-        err = snd_wss_timer(wss, 0, NULL);
+        err = snd_wss_timer(wss, 0);
         if (err < 0)
                 return err;
         if (fm_port[dev] >= 0x340 && fm_port[dev] < 0x400) {
diff --git a/sound/isa/opti9xx/miro.c b/sound/isa/opti9xx/miro.c
index c2ca681ac51b..3a9067db1a84 100644
--- a/sound/isa/opti9xx/miro.c
+++ b/sound/isa/opti9xx/miro.c
@@ -29,7 +29,7 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/dma.h>
 #include <sound/core.h>
 #include <sound/wss.h>
@@ -1270,8 +1270,6 @@ static int snd_miro_probe(struct snd_card *card)
         int error;
         struct snd_miro *miro = card->private_data;
         struct snd_wss *codec;
-        struct snd_timer *timer;
-        struct snd_pcm *pcm;
         struct snd_rawmidi *rmidi;
 
         if (!miro->res_mc_base) {
@@ -1310,7 +1308,7 @@ static int snd_miro_probe(struct snd_card *card)
         if (error < 0)
                 return error;
 
-        error = snd_wss_pcm(codec, 0, &pcm);
+        error = snd_wss_pcm(codec, 0);
         if (error < 0)
                 return error;
 
@@ -1318,11 +1316,11 @@ static int snd_miro_probe(struct snd_card *card)
         if (error < 0)
                 return error;
 
-        error = snd_wss_timer(codec, 0, &timer);
+        error = snd_wss_timer(codec, 0);
         if (error < 0)
                 return error;
 
-        miro->pcm = pcm;
+        miro->pcm = codec->pcm;
 
         error = snd_miro_mixer(card, miro);
         if (error < 0)
@@ -1356,8 +1354,8 @@ static int snd_miro_probe(struct snd_card *card)
 
         strcpy(card->driver, "miro");
         sprintf(card->longname, "%s: OPTi%s, %s at 0x%lx, irq %d, dma %d&%d",
-                card->shortname, miro->name, pcm->name, miro->wss_base + 4,
-                miro->irq, miro->dma1, miro->dma2);
+                card->shortname, miro->name, codec->pcm->name,
+                miro->wss_base + 4, miro->irq, miro->dma1, miro->dma2);
 
         if (mpu_port <= 0 || mpu_port == SNDRV_AUTO_PORT)
                 rmidi = NULL;
diff --git a/sound/isa/opti9xx/opti92x-ad1848.c b/sound/isa/opti9xx/opti92x-ad1848.c
index c9b582848603..0a5266003786 100644
--- a/sound/isa/opti9xx/opti92x-ad1848.c
+++ b/sound/isa/opti9xx/opti92x-ad1848.c
@@ -29,7 +29,7 @@
 #include <linux/delay.h>
 #include <linux/pnp.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/dma.h>
 #include <sound/core.h>
 #include <sound/tlv.h>
@@ -820,10 +820,6 @@ static int snd_opti9xx_probe(struct snd_card *card)
         int xdma2;
         struct snd_opti9xx *chip = card->private_data;
         struct snd_wss *codec;
-#ifdef CS4231
-        struct snd_timer *timer;
-#endif
-        struct snd_pcm *pcm;
         struct snd_rawmidi *rmidi;
         struct snd_hwdep *synth;
 
@@ -855,7 +851,7 @@ static int snd_opti9xx_probe(struct snd_card *card)
         if (error < 0)
                 return error;
         chip->codec = codec;
-        error = snd_wss_pcm(codec, 0, &pcm);
+        error = snd_wss_pcm(codec, 0);
         if (error < 0)
                 return error;
         error = snd_wss_mixer(codec);
@@ -867,7 +863,7 @@ static int snd_opti9xx_probe(struct snd_card *card)
                 return error;
 #endif
 #ifdef CS4231
-        error = snd_wss_timer(codec, 0, &timer);
+        error = snd_wss_timer(codec, 0);
         if (error < 0)
                 return error;
 #endif
@@ -884,11 +880,12 @@ static int snd_opti9xx_probe(struct snd_card *card)
         sprintf(card->shortname, "OPTi %s", card->driver);
 #if defined(CS4231) || defined(OPTi93X)
         sprintf(card->longname, "%s, %s at 0x%lx, irq %d, dma %d&%d",
-                card->shortname, pcm->name,
+                card->shortname, codec->pcm->name,
                 chip->wss_base + 4, irq, dma1, xdma2);
 #else
         sprintf(card->longname, "%s, %s at 0x%lx, irq %d, dma %d",
-                card->shortname, pcm->name, chip->wss_base + 4, irq, dma1);
+                card->shortname, codec->pcm->name, chip->wss_base + 4, irq,
+                dma1);
 #endif  /* CS4231 || OPTi93X */
 
         if (mpu_port <= 0 || mpu_port == SNDRV_AUTO_PORT)
diff --git a/sound/isa/sb/emu8000.c b/sound/isa/sb/emu8000.c
index 45fcdff611f9..94c411299e5a 100644
--- a/sound/isa/sb/emu8000.c
+++ b/sound/isa/sb/emu8000.c
@@ -26,11 +26,11 @@
 #include <linux/ioport.h>
 #include <linux/export.h>
 #include <linux/delay.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/emu8000.h>
 #include <sound/emu8000_reg.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/init.h>
 #include <sound/control.h>
 #include <sound/initval.h>
@@ -378,13 +378,12 @@ init_arrays(struct snd_emu8000 *emu)
 static void
 size_dram(struct snd_emu8000 *emu)
 {
-        int i, size, detected_size;
+        int i, size;
 
         if (emu->dram_checked)
                 return;
 
         size = 0;
-        detected_size = 0;
 
         /* write out a magic number */
         snd_emu8000_dma_chan(emu, 0, EMU8000_RAM_WRITE);
@@ -392,10 +391,19 @@ size_dram(struct snd_emu8000 *emu)
         EMU8000_SMALW_WRITE(emu, EMU8000_DRAM_OFFSET);
         EMU8000_SMLD_WRITE(emu, UNIQUE_ID1);
         snd_emu8000_init_fm(emu); /* This must really be here and not 2 lines back even */
+        snd_emu8000_write_wait(emu);
 
-        while (size < EMU8000_MAX_DRAM) {
+        /*
+         * Detect first 512 KiB.  If a write succeeds at the beginning of a
+         * 512 KiB page we assume that the whole page is there.
+         */
+        EMU8000_SMALR_WRITE(emu, EMU8000_DRAM_OFFSET);
+        EMU8000_SMLD_READ(emu); /* discard stale data  */
+        if (EMU8000_SMLD_READ(emu) != UNIQUE_ID1)
+                goto skip_detect;   /* No RAM */
+        snd_emu8000_read_wait(emu);
 
-                size += 512 * 1024;  /* increment 512kbytes */
+        for (size = 512 * 1024; size < EMU8000_MAX_DRAM; size += 512 * 1024) {
 
                 /* Write a unique data on the test address.
                  * if the address is out of range, the data is written on
@@ -431,18 +439,9 @@ size_dram(struct snd_emu8000 *emu)
                 snd_emu8000_read_wait(emu);
 
                 /* Otherwise, it's valid memory. */
-                detected_size = size + 512 * 1024;
-        }
-
-        /* Distinguish 512 KiB from 0. */
-        if (detected_size == 0) {
-                snd_emu8000_read_wait(emu);
-                EMU8000_SMALR_WRITE(emu, EMU8000_DRAM_OFFSET);
-                EMU8000_SMLD_READ(emu); /* discard stale data  */
-                if (EMU8000_SMLD_READ(emu) == UNIQUE_ID1)
-                        detected_size = 512 * 1024;
         }
 
+skip_detect:
         /* wait until FULL bit in SMAxW register is false */
         for (i = 0; i < 10000; i++) {
                 if ((EMU8000_SMALW_READ(emu) & 0x80000000) == 0)
@@ -454,10 +453,10 @@ size_dram(struct snd_emu8000 *emu)
         snd_emu8000_dma_chan(emu, 0, EMU8000_RAM_CLOSE);
         snd_emu8000_dma_chan(emu, 1, EMU8000_RAM_CLOSE);
 
-        snd_printdd("EMU8000 [0x%lx]: %d Kb on-board memory detected\n",
-                    emu->port1, detected_size/1024);
+        pr_info("EMU8000 [0x%lx]: %d KiB on-board DRAM detected\n",
+                    emu->port1, size/1024);
 
-        emu->mem_size = detected_size;
+        emu->mem_size = size;
         emu->dram_checked = 1;
 }
 
diff --git a/sound/isa/sb/emu8000_patch.c b/sound/isa/sb/emu8000_patch.c
index c99c6078be33..71d13c0bb746 100644
--- a/sound/isa/sb/emu8000_patch.c
+++ b/sound/isa/sb/emu8000_patch.c
@@ -20,7 +20,7 @@
  */
 
 #include "emu8000_local.h"
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/moduleparam.h>
 
 static int emu8000_reset_addr;
diff --git a/sound/isa/sb/emu8000_pcm.c b/sound/isa/sb/emu8000_pcm.c
index 2f85c66f8e38..250fd0006b53 100644
--- a/sound/isa/sb/emu8000_pcm.c
+++ b/sound/isa/sb/emu8000_pcm.c
@@ -207,8 +207,7 @@ static void emu8k_pcm_timer_func(unsigned long data)
         rec->last_ptr = ptr;
 
         /* reprogram timer */
-        rec->timer.expires = jiffies + 1;
-        add_timer(&rec->timer);
+        mod_timer(&rec->timer, jiffies + 1);
 
         /* update period */
         if (rec->period_pos >= (int)rec->period_size) {
@@ -240,9 +239,7 @@ static int emu8k_pcm_open(struct snd_pcm_substream *subs)
         runtime->private_data = rec;
 
         spin_lock_init(&rec->timer_lock);
-        init_timer(&rec->timer);
-        rec->timer.function = emu8k_pcm_timer_func;
-        rec->timer.data = (unsigned long)rec;
+        setup_timer(&rec->timer, emu8k_pcm_timer_func, (unsigned long)rec);
 
         runtime->hw = emu8k_pcm_hw;
         runtime->hw.buffer_bytes_max = emu->mem_size - LOOP_BLANK_SIZE * 3;
@@ -359,8 +356,7 @@ static void start_voice(struct snd_emu8k_pcm *rec, int ch)
         /* start timer */
         spin_lock_irqsave(&rec->timer_lock, flags);
         if (! rec->timer_running) {
-                rec->timer.expires = jiffies + 1;
-                add_timer(&rec->timer);
+                mod_timer(&rec->timer, jiffies + 1);
                 rec->timer_running = 1;
         }
         spin_unlock_irqrestore(&rec->timer_lock, flags);
diff --git a/sound/isa/sb/emu8000_synth.c b/sound/isa/sb/emu8000_synth.c
index 95b39beb61c1..72332dfada9a 100644
--- a/sound/isa/sb/emu8000_synth.c
+++ b/sound/isa/sb/emu8000_synth.c
@@ -103,8 +103,7 @@ static int snd_emu8000_delete_device(struct snd_seq_device *dev)
         hw = dev->driver_data;
         if (hw->pcm)
                 snd_device_free(dev->card, hw->pcm);
-        if (hw->emu)
-                snd_emux_free(hw->emu);
+        snd_emux_free(hw->emu);
         snd_util_memhdr_free(hw->memhdr);
         hw->emu = NULL;
         hw->memhdr = NULL;
diff --git a/sound/isa/sb/jazz16.c b/sound/isa/sb/jazz16.c
index 90d2eba549e9..6b4884d052a5 100644
--- a/sound/isa/sb/jazz16.c
+++ b/sound/isa/sb/jazz16.c
@@ -297,7 +297,7 @@ static int snd_jazz16_probe(struct device *devptr, unsigned int dev)
                 "Media Vision Jazz16 at 0x%lx, irq %d, dma8 %d, dma16 %d",
                 port[dev], xirq, xdma8, xdma16);
 
-        err = snd_sb8dsp_pcm(chip, 0, NULL);
+        err = snd_sb8dsp_pcm(chip, 0);
         if (err < 0)
                 goto err_free;
         err = snd_sbmixer_new(chip);
diff --git a/sound/isa/sb/sb16.c b/sound/isa/sb/sb16.c
index 3f694543a7ea..4a7d7c89808f 100644
--- a/sound/isa/sb/sb16.c
+++ b/sound/isa/sb/sb16.c
@@ -374,7 +374,7 @@ static int snd_sb16_probe(struct snd_card *card, int dev)
         if (! is_isapnp_selected(dev) && (err = snd_sb16dsp_configure(chip)) < 0)
                 return err;
 
-        if ((err = snd_sb16dsp_pcm(chip, 0, &chip->pcm)) < 0)
+        if ((err = snd_sb16dsp_pcm(chip, 0)) < 0)
                 return err;
 
         strcpy(card->driver,
diff --git a/sound/isa/sb/sb16_main.c b/sound/isa/sb/sb16_main.c
index 72b10f4f3e70..8b2d6c6bfe97 100644
--- a/sound/isa/sb/sb16_main.c
+++ b/sound/isa/sb/sb16_main.c
@@ -33,7 +33,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/dma.h>
 #include <linux/init.h>
 #include <linux/time.h>
@@ -860,19 +860,18 @@ static struct snd_pcm_ops snd_sb16_capture_ops = {
         .pointer =      snd_sb16_capture_pointer,
 };
 
-int snd_sb16dsp_pcm(struct snd_sb * chip, int device, struct snd_pcm ** rpcm)
+int snd_sb16dsp_pcm(struct snd_sb *chip, int device)
 {
         struct snd_card *card = chip->card;
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(card, "SB16 DSP", device, 1, 1, &pcm)) < 0)
                 return err;
         sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff);
         pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
         pcm->private_data = chip;
+        chip->pcm = pcm;
 
         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb16_playback_ops);
         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb16_capture_ops);
@@ -885,9 +884,6 @@ int snd_sb16dsp_pcm(struct snd_sb * chip, int device, struct snd_pcm ** rpcm)
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_isa_data(),
                                               64*1024, 128*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
diff --git a/sound/isa/sb/sb8.c b/sound/isa/sb/sb8.c
index 6c32b3aa34af..b8e2391c33ff 100644
--- a/sound/isa/sb/sb8.c
+++ b/sound/isa/sb/sb8.c
@@ -157,7 +157,7 @@ static int snd_sb8_probe(struct device *pdev, unsigned int dev)
                 goto _err;
         }
 
-        if ((err = snd_sb8dsp_pcm(chip, 0, NULL)) < 0)
+        if ((err = snd_sb8dsp_pcm(chip, 0)) < 0)
                 goto _err;
 
         if ((err = snd_sbmixer_new(chip)) < 0)
@@ -182,7 +182,7 @@ static int snd_sb8_probe(struct device *pdev, unsigned int dev)
                         goto _err;
         }
 
-        if ((err = snd_sb8dsp_midi(chip, 0, NULL)) < 0)
+        if ((err = snd_sb8dsp_midi(chip, 0)) < 0)
                 goto _err;
 
         strcpy(card->driver, chip->hardware == SB_HW_PRO ? "SB Pro" : "SB8");
diff --git a/sound/isa/sb/sb8_main.c b/sound/isa/sb/sb8_main.c
index 24d4121ab0e0..9043397fe62f 100644
--- a/sound/isa/sb/sb8_main.c
+++ b/sound/isa/sb/sb8_main.c
@@ -30,7 +30,7 @@
  *   Cleaned up and rewrote lowlevel routines.
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/dma.h>
 #include <linux/init.h>
 #include <linux/time.h>
@@ -594,15 +594,13 @@ static struct snd_pcm_ops snd_sb8_capture_ops = {
         .pointer =              snd_sb8_capture_pointer,
 };
 
-int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm)
+int snd_sb8dsp_pcm(struct snd_sb *chip, int device)
 {
         struct snd_card *card = chip->card;
         struct snd_pcm *pcm;
         int err;
         size_t max_prealloc = 64 * 1024;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(card, "SB8 DSP", device, 1, 1, &pcm)) < 0)
                 return err;
         sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff);
@@ -618,8 +616,6 @@ int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm)
                                               snd_dma_isa_data(),
                                               64*1024, max_prealloc);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
diff --git a/sound/isa/sb/sb8_midi.c b/sound/isa/sb/sb8_midi.c
index 988a8b73475f..d551c50e549f 100644
--- a/sound/isa/sb/sb8_midi.c
+++ b/sound/isa/sb/sb8_midi.c
@@ -26,7 +26,7 @@
  *   Added full duplex UART mode for DSP version 2.0 and later.
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/time.h>
 #include <sound/core.h>
 #include <sound/sb.h>
@@ -216,8 +216,7 @@ static void snd_sb8dsp_midi_output_timer(unsigned long data)
         unsigned long flags;
 
         spin_lock_irqsave(&chip->open_lock, flags);
-        chip->midi_timer.expires = 1 + jiffies;
-        add_timer(&chip->midi_timer);
+        mod_timer(&chip->midi_timer, 1 + jiffies);
         spin_unlock_irqrestore(&chip->open_lock, flags);        
         snd_sb8dsp_midi_output_write(substream);
 }
@@ -231,11 +230,10 @@ static void snd_sb8dsp_midi_output_trigger(struct snd_rawmidi_substream *substre
         spin_lock_irqsave(&chip->open_lock, flags);
         if (up) {
                 if (!(chip->open & SB_OPEN_MIDI_OUTPUT_TRIGGER)) {
-                        init_timer(&chip->midi_timer);
-                        chip->midi_timer.function = snd_sb8dsp_midi_output_timer;
-                        chip->midi_timer.data = (unsigned long) substream;
-                        chip->midi_timer.expires = 1 + jiffies;
-                        add_timer(&chip->midi_timer);
+                        setup_timer(&chip->midi_timer,
+                                    snd_sb8dsp_midi_output_timer,
+                                    (unsigned long) substream);
+                        mod_timer(&chip->midi_timer, 1 + jiffies);
                         chip->open |= SB_OPEN_MIDI_OUTPUT_TRIGGER;
                 }
         } else {
@@ -263,13 +261,11 @@ static struct snd_rawmidi_ops snd_sb8dsp_midi_input =
         .trigger =      snd_sb8dsp_midi_input_trigger,
 };
 
-int snd_sb8dsp_midi(struct snd_sb *chip, int device, struct snd_rawmidi ** rrawmidi)
+int snd_sb8dsp_midi(struct snd_sb *chip, int device)
 {
         struct snd_rawmidi *rmidi;
         int err;
 
-        if (rrawmidi)
-                *rrawmidi = NULL;
         if ((err = snd_rawmidi_new(chip->card, "SB8 MIDI", device, 1, 1, &rmidi)) < 0)
                 return err;
         strcpy(rmidi->name, "SB8 MIDI");
@@ -280,7 +276,5 @@ int snd_sb8dsp_midi(struct snd_sb *chip, int device, struct snd_rawmidi ** rrawm
                 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
         rmidi->private_data = chip;
         chip->rmidi = rmidi;
-        if (rrawmidi)
-                *rrawmidi = rmidi;
         return 0;
 }
diff --git a/sound/isa/sb/sb_common.c b/sound/isa/sb/sb_common.c
index f22b4480828e..787a4ade4afd 100644
--- a/sound/isa/sb/sb_common.c
+++ b/sound/isa/sb/sb_common.c
@@ -26,11 +26,11 @@
 #include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/module.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/sb.h>
 #include <sound/initval.h>
 
-#include <asm/io.h>
 #include <asm/dma.h>
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
diff --git a/sound/isa/sb/sb_mixer.c b/sound/isa/sb/sb_mixer.c
index e403334a19ad..add1d3f99609 100644
--- a/sound/isa/sb/sb_mixer.c
+++ b/sound/isa/sb/sb_mixer.c
@@ -19,7 +19,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/time.h>
 #include <sound/core.h>
diff --git a/sound/isa/sc6000.c b/sound/isa/sc6000.c
index 15a152eaa2e8..51cfa7615f72 100644
--- a/sound/isa/sc6000.c
+++ b/sound/isa/sc6000.c
@@ -625,7 +625,7 @@ static int snd_sc6000_probe(struct device *devptr, unsigned int dev)
         if (err < 0)
                 goto err_unmap2;
 
-        err = snd_wss_pcm(chip, 0, NULL);
+        err = snd_wss_pcm(chip, 0);
         if (err < 0) {
                 snd_printk(KERN_ERR PFX
                            "error creating new WSS PCM device\n");
diff --git a/sound/isa/sscape.c b/sound/isa/sscape.c
index 44405df7d4be..7b248cdf06e2 100644
--- a/sound/isa/sscape.c
+++ b/sound/isa/sscape.c
@@ -23,6 +23,7 @@
 
 #include <linux/init.h>
 #include <linux/err.h>
+#include <linux/io.h>
 #include <linux/isa.h>
 #include <linux/delay.h>
 #include <linux/firmware.h>
@@ -877,7 +878,6 @@ static int create_ad1845(struct snd_card *card, unsigned port,
                              codec_type, WSS_HWSHARE_DMA1, &chip);
         if (!err) {
                 unsigned long flags;
-                struct snd_pcm *pcm;
 
                 if (sscape->type != SSCAPE_VIVO) {
                         /*
@@ -893,7 +893,7 @@ static int create_ad1845(struct snd_card *card, unsigned port,
 
                 }
 
-                err = snd_wss_pcm(chip, 0, &pcm);
+                err = snd_wss_pcm(chip, 0);
                 if (err < 0) {
                         snd_printk(KERN_ERR "sscape: No PCM device "
                                             "for AD1845 chip\n");
@@ -907,7 +907,7 @@ static int create_ad1845(struct snd_card *card, unsigned port,
                         goto _error;
                 }
                 if (chip->hardware != WSS_HW_AD1848) {
-                        err = snd_wss_timer(chip, 0, NULL);
+                        err = snd_wss_timer(chip, 0);
                         if (err < 0) {
                                 snd_printk(KERN_ERR "sscape: No timer device "
                                                     "for AD1845 chip\n");
diff --git a/sound/isa/wavefront/wavefront.c b/sound/isa/wavefront/wavefront.c
index bfbf38cf9841..a0987a57c8a9 100644
--- a/sound/isa/wavefront/wavefront.c
+++ b/sound/isa/wavefront/wavefront.c
@@ -380,11 +380,11 @@ snd_wavefront_probe (struct snd_card *card, int dev)
                 return err;
         }
 
-        err = snd_wss_pcm(chip, 0, NULL);
+        err = snd_wss_pcm(chip, 0);
         if (err < 0)
                 return err;
 
-        err = snd_wss_timer(chip, 0, NULL);
+        err = snd_wss_timer(chip, 0);
         if (err < 0)
                 return err;
 
diff --git a/sound/isa/wavefront/wavefront_fx.c b/sound/isa/wavefront/wavefront_fx.c
index b77883c7ee76..b5a19708473a 100644
--- a/sound/isa/wavefront/wavefront_fx.c
+++ b/sound/isa/wavefront/wavefront_fx.c
@@ -16,7 +16,7 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/init.h>
 #include <linux/time.h>
 #include <linux/wait.h>
diff --git a/sound/isa/wavefront/wavefront_midi.c b/sound/isa/wavefront/wavefront_midi.c
index 7dc991682297..8a80fc6a616b 100644
--- a/sound/isa/wavefront/wavefront_midi.c
+++ b/sound/isa/wavefront/wavefront_midi.c
@@ -47,7 +47,7 @@
  *  
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/init.h>
 #include <linux/time.h>
 #include <linux/wait.h>
@@ -356,8 +356,7 @@ static void snd_wavefront_midi_output_timer(unsigned long data)
         unsigned long flags;
         
         spin_lock_irqsave (&midi->virtual, flags);
-        midi->timer.expires = 1 + jiffies;
-        add_timer(&midi->timer);
+        mod_timer(&midi->timer, 1 + jiffies);
         spin_unlock_irqrestore (&midi->virtual, flags);
         snd_wavefront_midi_output_write(card);
 }
@@ -384,11 +383,10 @@ static void snd_wavefront_midi_output_trigger(struct snd_rawmidi_substream *subs
         if (up) {
                 if ((midi->mode[mpu] & MPU401_MODE_OUTPUT_TRIGGER) == 0) {
                         if (!midi->istimer) {
-                                init_timer(&midi->timer);
-                                midi->timer.function = snd_wavefront_midi_output_timer;
-                                midi->timer.data = (unsigned long) substream->rmidi->card->private_data;
-                                midi->timer.expires = 1 + jiffies;
-                                add_timer(&midi->timer);
+                                setup_timer(&midi->timer,
+                                            snd_wavefront_midi_output_timer,
+                                            (unsigned long) substream->rmidi->card->private_data);
+                                mod_timer(&midi->timer, 1 + jiffies);
                         }
                         midi->istimer++;
                         midi->mode[mpu] |= MPU401_MODE_OUTPUT_TRIGGER;
diff --git a/sound/isa/wavefront/wavefront_synth.c b/sound/isa/wavefront/wavefront_synth.c
index e5db001363ee..33f5ec14fcfa 100644
--- a/sound/isa/wavefront/wavefront_synth.c
+++ b/sound/isa/wavefront/wavefront_synth.c
@@ -20,7 +20,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/delay.h>
diff --git a/sound/isa/wss/wss_lib.c b/sound/isa/wss/wss_lib.c
index 347bb1bda110..913b731d2236 100644
--- a/sound/isa/wss/wss_lib.c
+++ b/sound/isa/wss/wss_lib.c
@@ -31,12 +31,12 @@
 #include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/module.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/wss.h>
 #include <sound/pcm_params.h>
 #include <sound/tlv.h>
 
-#include <asm/io.h>
 #include <asm/dma.h>
 #include <asm/irq.h>
 
@@ -1923,7 +1923,7 @@ static struct snd_pcm_ops snd_wss_capture_ops = {
         .pointer =      snd_wss_capture_pointer,
 };
 
-int snd_wss_pcm(struct snd_wss *chip, int device, struct snd_pcm **rpcm)
+int snd_wss_pcm(struct snd_wss *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
@@ -1949,8 +1949,6 @@ int snd_wss_pcm(struct snd_wss *chip, int device, struct snd_pcm **rpcm)
                                               64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
 
         chip->pcm = pcm;
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 EXPORT_SYMBOL(snd_wss_pcm);
@@ -1961,7 +1959,7 @@ static void snd_wss_timer_free(struct snd_timer *timer)
         chip->timer = NULL;
 }
 
-int snd_wss_timer(struct snd_wss *chip, int device, struct snd_timer **rtimer)
+int snd_wss_timer(struct snd_wss *chip, int device)
 {
         struct snd_timer *timer;
         struct snd_timer_id tid;
@@ -1980,8 +1978,6 @@ int snd_wss_timer(struct snd_wss *chip, int device, struct snd_timer **rtimer)
         timer->private_free = snd_wss_timer_free;
         timer->hw = snd_wss_timer_table;
         chip->timer = timer;
-        if (rtimer)
-                *rtimer = timer;
         return 0;
 }
 EXPORT_SYMBOL(snd_wss_timer);
diff --git a/sound/oss/dmasound/dmasound_atari.c b/sound/oss/dmasound/dmasound_atari.c
index 13c214466d3b..1c56bf58eff9 100644
--- a/sound/oss/dmasound/dmasound_atari.c
+++ b/sound/oss/dmasound/dmasound_atari.c
@@ -851,7 +851,7 @@ static int __init AtaIrqInit(void)
         st_mfp.tim_dt_a = 1;    /* Cause interrupt after first event. */
         st_mfp.tim_ct_a = 8;    /* Turn on event counting. */
         /* Register interrupt handler. */
-        if (request_irq(IRQ_MFP_TIMA, AtaInterrupt, IRQ_TYPE_SLOW, "DMA sound",
+        if (request_irq(IRQ_MFP_TIMA, AtaInterrupt, 0, "DMA sound",
                         AtaInterrupt))
                 return 0;
         st_mfp.int_en_a |= 0x20;        /* Turn interrupt on. */
diff --git a/sound/oss/msnd_pinnacle.c b/sound/oss/msnd_pinnacle.c
index c23f9f95bfa5..a8ceef8d1a8d 100644
--- a/sound/oss/msnd_pinnacle.c
+++ b/sound/oss/msnd_pinnacle.c
@@ -675,7 +675,7 @@ static void dsp_write_flush(void)
                 timeout);
         clear_bit(F_WRITEFLUSH, &dev.flags);
         if (!signal_pending(current)) {
-                current->state = TASK_INTERRUPTIBLE;
+                __set_current_state(TASK_INTERRUPTIBLE);
                 schedule_timeout(get_play_delay_jiffies(DAP_BUFF_SIZE));
         }
         clear_bit(F_WRITING, &dev.flags);
@@ -1288,7 +1288,7 @@ static int __init calibrate_adc(WORD srate)
                        & ~0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
         if (msnd_send_word(&dev, 0, 0, HDEXAR_CAL_A_TO_D) == 0 &&
             chk_send_dsp_cmd(&dev, HDEX_AUX_REQ) == 0) {
-                current->state = TASK_INTERRUPTIBLE;
+                __set_current_state(TASK_INTERRUPTIBLE);
                 schedule_timeout(HZ / 3);
                 return 0;
         }
diff --git a/sound/oss/pss.c b/sound/oss/pss.c
index ca0d6e9f49f5..81314f9e2ccb 100644
--- a/sound/oss/pss.c
+++ b/sound/oss/pss.c
@@ -1228,7 +1228,7 @@ static void __exit cleanup_pss(void)
 {
         if(!pss_no_sound)
         {
-                if(fw_load && pss_synth)
+                if (fw_load)
                         vfree(pss_synth);
                 if(pssmss)
                         unload_pss_mss(&cfg2);
diff --git a/sound/oss/swarm_cs4297a.c b/sound/oss/swarm_cs4297a.c
index a33e8ce8085b..213a416b6e0b 100644
--- a/sound/oss/swarm_cs4297a.c
+++ b/sound/oss/swarm_cs4297a.c
@@ -1654,7 +1654,7 @@ static int drain_dac(struct cs4297a_state *s, int nonblock)
         s->dma_dac.hwptr = s->dma_dac.swptr = hwptr;
         spin_unlock_irqrestore(&s->lock, flags);
         remove_wait_queue(&s->dma_dac.wait, &wait);
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         return 0;
 }
 
diff --git a/sound/oss/trix.c b/sound/oss/trix.c
index 944e0c015485..3c494dc93b93 100644
--- a/sound/oss/trix.c
+++ b/sound/oss/trix.c
@@ -487,7 +487,7 @@ static int __init init_trix(void)
 
 static void __exit cleanup_trix(void)
 {
-        if (fw_load && trix_boot)
+        if (fw_load)
                 vfree(trix_boot);
         if (sb)
                 unload_trix_sb(&cfg2);
diff --git a/sound/parisc/harmony.c b/sound/parisc/harmony.c
index 29604a239c44..99b64cb3cef8 100644
--- a/sound/parisc/harmony.c
+++ b/sound/parisc/harmony.c
@@ -44,6 +44,7 @@
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <linux/dma-mapping.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -52,7 +53,6 @@
 #include <sound/initval.h>
 #include <sound/info.h>
 
-#include <asm/io.h>
 #include <asm/hardware.h>
 #include <asm/parisc-device.h>
 
@@ -893,9 +893,7 @@ snd_harmony_free(struct snd_harmony *h)
         if (h->irq >= 0)
                 free_irq(h->irq, h);
 
-        if (h->iobase)
-                iounmap(h->iobase);
-
+        iounmap(h->iobase);
         kfree(h);
         return 0;
 }
diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig
index 50dd0086cfb1..edfc1b8d553e 100644
--- a/sound/pci/Kconfig
+++ b/sound/pci/Kconfig
@@ -793,6 +793,15 @@ config SND_RME9652
           To compile this driver as a module, choose M here: the module
           will be called snd-rme9652.
 
+config SND_SE6X
+        tristate "Studio Evolution SE6X"
+        depends on SND_OXYGEN=n && SND_VIRTUOSO=n  # PCI ID conflict
+        select SND_OXYGEN_LIB
+        select SND_PCM
+        select SND_MPU401_UART
+        help
+          Say Y or M here only if you actually have this sound card.
+
 config SND_SIS7019
         tristate "SiS 7019 Audio Accelerator"
         depends on X86_32
diff --git a/sound/pci/ad1889.c b/sound/pci/ad1889.c
index 1610c38337af..850a8c984c25 100644
--- a/sound/pci/ad1889.c
+++ b/sound/pci/ad1889.c
@@ -40,14 +40,13 @@
 #include <linux/compiler.h>
 #include <linux/delay.h>
 #include <linux/module.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/initval.h>
 #include <sound/ac97_codec.h>
 
-#include <asm/io.h>
-
 #include "ad1889.h"
 #include "ac97/ac97_id.h"
 
@@ -623,14 +622,11 @@ snd_ad1889_interrupt(int irq, void *dev_id)
 }
 
 static int
-snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device, struct snd_pcm **rpcm)
+snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device)
 {
         int err;
         struct snd_pcm *pcm;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         err = snd_pcm_new(chip->card, chip->card->driver, device, 1, 1, &pcm);
         if (err < 0)
                 return err;
@@ -658,9 +654,6 @@ snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device, struct snd_pcm **rpcm)
                 return err;
         }
         
-        if (rpcm)
-                *rpcm = pcm;
-        
         return 0;
 }
 
@@ -859,12 +852,9 @@ snd_ad1889_free(struct snd_ad1889 *chip)
                 free_irq(chip->irq, chip);
 
 skip_hw:
-        if (chip->iobase)
-                iounmap(chip->iobase);
-
+        iounmap(chip->iobase);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
-
         kfree(chip);
         return 0;
 }
@@ -1016,7 +1006,7 @@ snd_ad1889_probe(struct pci_dev *pci,
         if (err < 0)
                 goto free_and_ret;
         
-        err = snd_ad1889_pcm_init(chip, 0, NULL);
+        err = snd_ad1889_pcm_init(chip, 0);
         if (err < 0)
                 goto free_and_ret;
 
diff --git a/sound/pci/ali5451/ali5451.c b/sound/pci/ali5451/ali5451.c
index af89e42b2160..c8d499575c01 100644
--- a/sound/pci/ali5451/ali5451.c
+++ b/sound/pci/ali5451/ali5451.c
@@ -25,7 +25,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1873,7 +1873,6 @@ static int snd_ali_mixer(struct snd_ali *codec)
 #ifdef CONFIG_PM_SLEEP
 static int ali_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ali *chip = card->private_data;
         struct snd_ali_image *im;
@@ -1914,16 +1913,11 @@ static int ali_suspend(struct device *dev)
         outl(0xffffffff, ALI_REG(chip, ALI_STOP));
 
         spin_unlock_irq(&chip->reg_lock);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int ali_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ali *chip = card->private_data;
         struct snd_ali_image *im;
@@ -1933,15 +1927,6 @@ static int ali_resume(struct device *dev)
         if (!im)
                 return 0;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         spin_lock_irq(&chip->reg_lock);
         
         for (i = 0; i < ALI_CHANNELS; i++) {
diff --git a/sound/pci/als300.c b/sound/pci/als300.c
index 7bb6ac565107..57e034f208dc 100644
--- a/sound/pci/als300.c
+++ b/sound/pci/als300.c
@@ -37,8 +37,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
-
-#include <asm/io.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -728,35 +727,20 @@ static int snd_als300_create(struct snd_card *card,
 #ifdef CONFIG_PM_SLEEP
 static int snd_als300_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_als300 *chip = card->private_data;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
         snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_als300_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_als300 *chip = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_als300_init(chip);
         snd_ac97_resume(chip->ac97);
 
diff --git a/sound/pci/als4000.c b/sound/pci/als4000.c
index d3e6424ee656..a3dea464134d 100644
--- a/sound/pci/als4000.c
+++ b/sound/pci/als4000.c
@@ -65,7 +65,7 @@
  * - power management? (card can do voice wakeup according to datasheet!!)
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/gameport.h>
@@ -988,7 +988,6 @@ static void snd_card_als4000_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_als4000_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_card_als4000 *acard = card->private_data;
         struct snd_sb *chip = acard->chip;
@@ -997,29 +996,15 @@ static int snd_als4000_suspend(struct device *dev)
         
         snd_pcm_suspend_all(chip->pcm);
         snd_sbmixer_suspend(chip);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_als4000_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_card_als4000 *acard = card->private_data;
         struct snd_sb *chip = acard->chip;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_als4000_configure(chip);
         snd_sbdsp_reset(chip);
         snd_sbmixer_resume(chip);
diff --git a/sound/pci/asihpi/asihpi.c b/sound/pci/asihpi/asihpi.c
index e9273fb2a505..e5cd7be85355 100644
--- a/sound/pci/asihpi/asihpi.c
+++ b/sound/pci/asihpi/asihpi.c
@@ -540,9 +540,8 @@ static void snd_card_asihpi_pcm_timer_start(struct snd_pcm_substream *
         expiry = HZ / 200;
 
         expiry = max(expiry, 1); /* don't let it be zero! */
-        dpcm->timer.expires = jiffies + expiry;
+        mod_timer(&dpcm->timer, jiffies + expiry);
         dpcm->respawn_timer = 1;
-        add_timer(&dpcm->timer);
 }
 
 static void snd_card_asihpi_pcm_timer_stop(struct snd_pcm_substream *substream)
@@ -1064,9 +1063,8 @@ static int snd_card_asihpi_playback_open(struct snd_pcm_substream *substream)
             If internal and other stream playing, can't switch
         */
 
-        init_timer(&dpcm->timer);
-        dpcm->timer.data = (unsigned long) dpcm;
-        dpcm->timer.function = snd_card_asihpi_timer_function;
+        setup_timer(&dpcm->timer, snd_card_asihpi_timer_function,
+                    (unsigned long) dpcm);
         dpcm->substream = substream;
         runtime->private_data = dpcm;
         runtime->private_free = snd_card_asihpi_runtime_free;
@@ -1246,9 +1244,8 @@ static int snd_card_asihpi_capture_open(struct snd_pcm_substream *substream)
         if (err)
                 return -EIO;
 
-        init_timer(&dpcm->timer);
-        dpcm->timer.data = (unsigned long) dpcm;
-        dpcm->timer.function = snd_card_asihpi_timer_function;
+        setup_timer(&dpcm->timer, snd_card_asihpi_timer_function,
+                    (unsigned long) dpcm);
         dpcm->substream = substream;
         runtime->private_data = dpcm;
         runtime->private_free = snd_card_asihpi_runtime_free;
@@ -2832,14 +2829,11 @@ static int snd_asihpi_hpi_ioctl(struct snd_hwdep *hw, struct file *file,
 /* results in /dev/snd/hwC#D0 file for each card with index #
    also /proc/asound/hwdep will contain '#-00: asihpi (HPI) for each card'
 */
-static int snd_asihpi_hpi_new(struct snd_card_asihpi *asihpi,
-                              int device, struct snd_hwdep **rhwdep)
+static int snd_asihpi_hpi_new(struct snd_card_asihpi *asihpi, int device)
 {
         struct snd_hwdep *hw;
         int err;
 
-        if (rhwdep)
-                *rhwdep = NULL;
         err = snd_hwdep_new(asihpi->card, "HPI", device, &hw);
         if (err < 0)
                 return err;
@@ -2849,8 +2843,6 @@ static int snd_asihpi_hpi_new(struct snd_card_asihpi *asihpi,
         hw->ops.ioctl = snd_asihpi_hpi_ioctl;
         hw->ops.release = snd_asihpi_hpi_release;
         hw->private_data = asihpi;
-        if (rhwdep)
-                *rhwdep = hw;
         return 0;
 }
 
@@ -2993,7 +2985,7 @@ static int snd_asihpi_probe(struct pci_dev *pci_dev,
 
         /* always create, can be enabled or disabled dynamically
             by enable_hwdep  module param*/
-        snd_asihpi_hpi_new(asihpi, 0, NULL);
+        snd_asihpi_hpi_new(asihpi, 0);
 
         strcpy(card->driver, "ASIHPI");
 
diff --git a/sound/pci/asihpi/hpi6000.c b/sound/pci/asihpi/hpi6000.c
index 2414d7a2239d..2d6364825d4d 100644
--- a/sound/pci/asihpi/hpi6000.c
+++ b/sound/pci/asihpi/hpi6000.c
@@ -47,7 +47,7 @@
 
 /* operational/messaging errors */
 #define HPI6000_ERROR_MSG_RESP_IDLE_TIMEOUT             901
-
+#define HPI6000_ERROR_RESP_GET_LEN                      902
 #define HPI6000_ERROR_MSG_RESP_GET_RESP_ACK             903
 #define HPI6000_ERROR_MSG_GET_ADR                       904
 #define HPI6000_ERROR_RESP_GET_ADR                      905
@@ -1365,7 +1365,10 @@ static short hpi6000_message_response_sequence(struct hpi_adapter_obj *pao,
                 length = hpi_read_word(pdo, HPI_HIF_ADDR(length));
         } while (hpi6000_check_PCI2040_error_flag(pao, H6READ) && --timeout);
         if (!timeout)
-                length = sizeof(struct hpi_response);
+                return HPI6000_ERROR_RESP_GET_LEN;
+
+        if (length > phr->size)
+                return HPI_ERROR_RESPONSE_BUFFER_TOO_SMALL;
 
         /* get the response */
         p_data = (u32 *)phr;
diff --git a/sound/pci/asihpi/hpioctl.c b/sound/pci/asihpi/hpioctl.c
index 6aa677e60555..6610bd096fc9 100644
--- a/sound/pci/asihpi/hpioctl.c
+++ b/sound/pci/asihpi/hpioctl.c
@@ -28,7 +28,7 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/moduleparam.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/pci.h>
 #include <linux/stringify.h>
 #include <linux/module.h>
@@ -153,6 +153,8 @@ long asihpi_hpi_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 goto out;
         }
 
+        res_max_size = min_t(size_t, res_max_size, sizeof(*hr));
+
         switch (hm->h.function) {
         case HPI_SUBSYS_CREATE_ADAPTER:
         case HPI_ADAPTER_DELETE:
@@ -539,10 +541,8 @@ void asihpi_adapter_remove(struct pci_dev *pci_dev)
         hpi_send_recv_ex(&hm, &hr, HOWNER_KERNEL);
 
         /* unmap PCI memory space, mapped during device init. */
-        for (idx = 0; idx < HPI_MAX_ADAPTER_MEM_SPACES; idx++) {
-                if (pci.ap_mem_base[idx])
-                        iounmap(pci.ap_mem_base[idx]);
-        }
+        for (idx = 0; idx < HPI_MAX_ADAPTER_MEM_SPACES; ++idx)
+                iounmap(pci.ap_mem_base[idx]);
 
         if (pa->irq)
                 free_irq(pa->irq, pa);
diff --git a/sound/pci/atiixp.c b/sound/pci/atiixp.c
index 9c1c4452a8ee..d5f15c9bbeda 100644
--- a/sound/pci/atiixp.c
+++ b/sound/pci/atiixp.c
@@ -19,7 +19,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1474,7 +1474,6 @@ static int snd_atiixp_mixer_new(struct atiixp *chip, int clock,
  */
 static int snd_atiixp_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct atiixp *chip = card->private_data;
         int i;
@@ -1492,29 +1491,15 @@ static int snd_atiixp_suspend(struct device *dev)
                 snd_ac97_suspend(chip->ac97[i]);
         snd_atiixp_aclink_down(chip);
         snd_atiixp_chip_stop(chip);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_atiixp_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct atiixp *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_atiixp_aclink_reset(chip);
         snd_atiixp_chip_start(chip);
 
@@ -1585,8 +1570,7 @@ static int snd_atiixp_free(struct atiixp *chip)
       __hw_end:
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
-        if (chip->remap_addr)
-                iounmap(chip->remap_addr);
+        iounmap(chip->remap_addr);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
         kfree(chip);
diff --git a/sound/pci/atiixp_modem.c b/sound/pci/atiixp_modem.c
index b2f63e0727de..0a38e08164ab 100644
--- a/sound/pci/atiixp_modem.c
+++ b/sound/pci/atiixp_modem.c
@@ -19,7 +19,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1120,7 +1120,6 @@ static int snd_atiixp_mixer_new(struct atiixp_modem *chip, int clock)
  */
 static int snd_atiixp_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct atiixp_modem *chip = card->private_data;
         int i;
@@ -1132,29 +1131,15 @@ static int snd_atiixp_suspend(struct device *dev)
                 snd_ac97_suspend(chip->ac97[i]);
         snd_atiixp_aclink_down(chip);
         snd_atiixp_chip_stop(chip);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_atiixp_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct atiixp_modem *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_atiixp_aclink_reset(chip);
         snd_atiixp_chip_start(chip);
 
@@ -1211,8 +1196,7 @@ static int snd_atiixp_free(struct atiixp_modem *chip)
       __hw_end:
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
-        if (chip->remap_addr)
-                iounmap(chip->remap_addr);
+        iounmap(chip->remap_addr);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
         kfree(chip);
diff --git a/sound/pci/au88x0/au88x0.h b/sound/pci/au88x0/au88x0.h
index 3a8fefefea77..bcc648bf6478 100644
--- a/sound/pci/au88x0/au88x0.h
+++ b/sound/pci/au88x0/au88x0.h
@@ -17,9 +17,8 @@
 #ifndef __SOUND_AU88X0_H
 #define __SOUND_AU88X0_H
 
-#ifdef __KERNEL__
 #include <linux/pci.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/rawmidi.h>
@@ -27,7 +26,6 @@
 #include <sound/hwdep.h>
 #include <sound/ac97_codec.h>
 #include <sound/tlv.h>
-#endif
 
 #ifndef CHIP_AU8820
 #include "au88x0_eq.h"
diff --git a/sound/pci/aw2/aw2-alsa.c b/sound/pci/aw2/aw2-alsa.c
index e1cf01949fda..8d2fee7b33bd 100644
--- a/sound/pci/aw2/aw2-alsa.c
+++ b/sound/pci/aw2/aw2-alsa.c
@@ -229,9 +229,7 @@ static int snd_aw2_dev_free(struct snd_device *device)
         if (chip->irq >= 0)
                 free_irq(chip->irq, (void *)chip);
         /* release the i/o ports & memory */
-        if (chip->iobase_virt)
-                iounmap(chip->iobase_virt);
-
+        iounmap(chip->iobase_virt);
         pci_release_regions(chip->pci);
         /* disable the PCI entry */
         pci_disable_device(chip->pci);
diff --git a/sound/pci/aw2/aw2-saa7146.c b/sound/pci/aw2/aw2-saa7146.c
index 6d24e9536777..1d7890459334 100644
--- a/sound/pci/aw2/aw2-saa7146.c
+++ b/sound/pci/aw2/aw2-saa7146.c
@@ -27,7 +27,7 @@
 #include <linux/pci.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/initval.h>
 #include <sound/pcm.h>
diff --git a/sound/pci/azt3328.c b/sound/pci/azt3328.c
index fdbb9c05c77b..a40a2b4c8fd7 100644
--- a/sound/pci/azt3328.c
+++ b/sound/pci/azt3328.c
@@ -179,7 +179,7 @@
  *  - use MMIO (memory-mapped I/O)? Slightly faster access, e.g. for gameport.
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/init.h>
 #include <linux/bug.h> /* WARN_ONCE */
 #include <linux/pci.h>
@@ -2694,7 +2694,6 @@ snd_azf3328_resume_ac97(const struct snd_azf3328 *chip)
 static int
 snd_azf3328_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_azf3328 *chip = card->private_data;
         u16 *saved_regs_ctrl_u16;
@@ -2720,29 +2719,15 @@ snd_azf3328_suspend(struct device *dev)
                 ARRAY_SIZE(chip->saved_regs_mpu), chip->saved_regs_mpu);
         snd_azf3328_suspend_regs(chip, chip->opl3_io,
                 ARRAY_SIZE(chip->saved_regs_opl3), chip->saved_regs_opl3);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int
 snd_azf3328_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         const struct snd_azf3328 *chip = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_azf3328_resume_regs(chip, chip->saved_regs_game, chip->game_io,
                                         ARRAY_SIZE(chip->saved_regs_game));
         snd_azf3328_resume_regs(chip, chip->saved_regs_mpu, chip->mpu_io,
diff --git a/sound/pci/bt87x.c b/sound/pci/bt87x.c
index 058b9973c09c..5925b7170e25 100644
--- a/sound/pci/bt87x.c
+++ b/sound/pci/bt87x.c
@@ -27,7 +27,7 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/bitops.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -690,8 +690,7 @@ static int snd_bt87x_free(struct snd_bt87x *chip)
                 snd_bt87x_stop(chip);
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
-        if (chip->mmio)
-                iounmap(chip->mmio);
+        iounmap(chip->mmio);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
         kfree(chip);
diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c
index 96af33965b51..dd75b7536fa2 100644
--- a/sound/pci/ca0106/ca0106_main.c
+++ b/sound/pci/ca0106/ca0106_main.c
@@ -1910,7 +1910,6 @@ static void snd_ca0106_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_ca0106_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ca0106 *chip = card->private_data;
         int i;
@@ -1923,30 +1922,15 @@ static int snd_ca0106_suspend(struct device *dev)
         snd_ca0106_mixer_suspend(chip);
 
         ca0106_stop_chip(chip);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_ca0106_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ca0106 *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
-        if (pci_enable_device(pci) < 0) {
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-
-        pci_set_master(pci);
-
         ca0106_init_chip(chip, 1);
 
         if (chip->details->ac97)
diff --git a/sound/pci/ca0106/ca0106_mixer.c b/sound/pci/ca0106/ca0106_mixer.c
index 68c0eb0a2807..025805cba779 100644
--- a/sound/pci/ca0106/ca0106_mixer.c
+++ b/sound/pci/ca0106/ca0106_mixer.c
@@ -70,7 +70,7 @@
 #include <sound/ac97_codec.h>
 #include <sound/info.h>
 #include <sound/tlv.h>
-#include <asm/io.h>
+#include <linux/io.h>
 
 #include "ca0106.h"
 
diff --git a/sound/pci/ca0106/ca0106_proc.c b/sound/pci/ca0106/ca0106_proc.c
index 4f9c2821bb31..2c5c28adbefd 100644
--- a/sound/pci/ca0106/ca0106_proc.c
+++ b/sound/pci/ca0106/ca0106_proc.c
@@ -64,13 +64,13 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/moduleparam.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/initval.h>
 #include <sound/pcm.h>
 #include <sound/ac97_codec.h>
 #include <sound/info.h>
 #include <sound/asoundef.h>
-#include <asm/io.h>
 
 #include "ca0106.h"
 
diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c
index 85ed40339db9..1d0f2cad2f5a 100644
--- a/sound/pci/cmipci.c
+++ b/sound/pci/cmipci.c
@@ -20,7 +20,7 @@
 /* Does not work. Warning may block system in capture mode */
 /* #define USE_VAR48KRATE */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -3347,7 +3347,6 @@ static unsigned char saved_mixers[] = {
 
 static int snd_cmipci_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cmipci *cm = card->private_data;
         int i;
@@ -3366,29 +3365,15 @@ static int snd_cmipci_suspend(struct device *dev)
 
         /* disable ints */
         snd_cmipci_write(cm, CM_REG_INT_HLDCLR, 0);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_cmipci_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cmipci *cm = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         /* reset / initialize to a sane state */
         snd_cmipci_write(cm, CM_REG_INT_HLDCLR, 0);
         snd_cmipci_ch_reset(cm, CM_CH_PLAY);
diff --git a/sound/pci/cs4281.c b/sound/pci/cs4281.c
index 4c49b5c8a7b3..c296fd0dbc9c 100644
--- a/sound/pci/cs4281.c
+++ b/sound/pci/cs4281.c
@@ -19,7 +19,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -973,14 +973,11 @@ static struct snd_pcm_ops snd_cs4281_capture_ops = {
         .pointer =      snd_cs4281_pointer,
 };
 
-static int snd_cs4281_pcm(struct cs4281 *chip, int device,
-                          struct snd_pcm **rpcm)
+static int snd_cs4281_pcm(struct cs4281 *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(chip->card, "CS4281", device, 1, 1, &pcm);
         if (err < 0)
                 return err;
@@ -996,8 +993,6 @@ static int snd_cs4281_pcm(struct cs4281 *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 512*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -1321,10 +1316,8 @@ static int snd_cs4281_free(struct cs4281 *chip)
 
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
-        if (chip->ba0)
-                iounmap(chip->ba0);
-        if (chip->ba1)
-                iounmap(chip->ba1);
+        iounmap(chip->ba0);
+        iounmap(chip->ba1);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
 
@@ -1788,14 +1781,11 @@ static struct snd_rawmidi_ops snd_cs4281_midi_input =
         .trigger =      snd_cs4281_midi_input_trigger,
 };
 
-static int snd_cs4281_midi(struct cs4281 *chip, int device,
-                           struct snd_rawmidi **rrawmidi)
+static int snd_cs4281_midi(struct cs4281 *chip, int device)
 {
         struct snd_rawmidi *rmidi;
         int err;
 
-        if (rrawmidi)
-                *rrawmidi = NULL;
         if ((err = snd_rawmidi_new(chip->card, "CS4281", device, 1, 1, &rmidi)) < 0)
                 return err;
         strcpy(rmidi->name, "CS4281");
@@ -1804,8 +1794,6 @@ static int snd_cs4281_midi(struct cs4281 *chip, int device,
         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
         rmidi->private_data = chip;
         chip->rmidi = rmidi;
-        if (rrawmidi)
-                *rrawmidi = rmidi;
         return 0;
 }
 
@@ -1941,11 +1929,11 @@ static int snd_cs4281_probe(struct pci_dev *pci,
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_cs4281_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs4281_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_cs4281_midi(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs4281_midi(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
@@ -2008,7 +1996,6 @@ static int saved_regs[SUSPEND_REGISTERS] = {
 
 static int cs4281_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cs4281 *chip = card->private_data;
         u32 ulCLK;
@@ -2047,30 +2034,16 @@ static int cs4281_suspend(struct device *dev)
         ulCLK = snd_cs4281_peekBA0(chip, BA0_CLKCR1);
         ulCLK &= ~CLKCR1_CKRA;
         snd_cs4281_pokeBA0(chip, BA0_CLKCR1, ulCLK);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int cs4281_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cs4281 *chip = card->private_data;
         unsigned int i;
         u32 ulCLK;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         ulCLK = snd_cs4281_peekBA0(chip, BA0_CLKCR1);
         ulCLK |= CLKCR1_CKRA;
         snd_cs4281_pokeBA0(chip, BA0_CLKCR1, ulCLK);
diff --git a/sound/pci/cs46xx/cs46xx.c b/sound/pci/cs46xx/cs46xx.c
index 6a6858c07826..655fbea1692c 100644
--- a/sound/pci/cs46xx/cs46xx.c
+++ b/sound/pci/cs46xx/cs46xx.c
@@ -100,16 +100,16 @@ static int snd_card_cs46xx_probe(struct pci_dev *pci,
         }
         card->private_data = chip;
         chip->accept_valid = mmap_valid[dev];
-        if ((err = snd_cs46xx_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs46xx_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
-        if ((err = snd_cs46xx_pcm_rear(chip,1, NULL)) < 0) {
+        if ((err = snd_cs46xx_pcm_rear(chip, 1)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_cs46xx_pcm_iec958(chip,2,NULL)) < 0) {
+        if ((err = snd_cs46xx_pcm_iec958(chip, 2)) < 0) {
                 snd_card_free(card);
                 return err;
         }
@@ -120,13 +120,13 @@ static int snd_card_cs46xx_probe(struct pci_dev *pci,
         }
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
         if (chip->nr_ac97_codecs ==2) {
-                if ((err = snd_cs46xx_pcm_center_lfe(chip,3,NULL)) < 0) {
+                if ((err = snd_cs46xx_pcm_center_lfe(chip, 3)) < 0) {
                         snd_card_free(card);
                         return err;
                 }
         }
 #endif
-        if ((err = snd_cs46xx_midi(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs46xx_midi(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
diff --git a/sound/pci/cs46xx/cs46xx.h b/sound/pci/cs46xx/cs46xx.h
index c49a082c378b..9c9f89a8be5f 100644
--- a/sound/pci/cs46xx/cs46xx.h
+++ b/sound/pci/cs46xx/cs46xx.h
@@ -1737,12 +1737,12 @@ int snd_cs46xx_create(struct snd_card *card,
                       struct snd_cs46xx **rcodec);
 extern const struct dev_pm_ops snd_cs46xx_pm;
 
-int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm);
-int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm);
-int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm);
-int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm);
+int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device);
+int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device);
+int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device);
+int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device);
 int snd_cs46xx_mixer(struct snd_cs46xx *chip, int spdif_device);
-int snd_cs46xx_midi(struct snd_cs46xx *chip, int device, struct snd_rawmidi **rmidi);
+int snd_cs46xx_midi(struct snd_cs46xx *chip, int device);
 int snd_cs46xx_start_dsp(struct snd_cs46xx *chip);
 int snd_cs46xx_gameport(struct snd_cs46xx *chip);
 
diff --git a/sound/pci/cs46xx/cs46xx_lib.c b/sound/pci/cs46xx/cs46xx_lib.c
index 32b44f25b5c8..8d74004b1ed2 100644
--- a/sound/pci/cs46xx/cs46xx_lib.c
+++ b/sound/pci/cs46xx/cs46xx_lib.c
@@ -57,6 +57,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/vmalloc.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -65,8 +66,6 @@
 #include <sound/pcm_params.h>
 #include "cs46xx.h"
 
-#include <asm/io.h>
-
 #include "cs46xx_lib.h"
 #include "dsp_spos.h"
 
@@ -1778,13 +1777,11 @@ static struct snd_pcm_ops snd_cs46xx_capture_indirect_ops = {
 #define MAX_PLAYBACK_CHANNELS   1
 #endif
 
-int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm)
+int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "CS46xx", device, MAX_PLAYBACK_CHANNELS, 1, &pcm)) < 0)
                 return err;
 
@@ -1801,23 +1798,16 @@ int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm)
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
 
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
-int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device,
-                        struct snd_pcm **rpcm)
+int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(chip->card, "CS46xx - Rear", device, MAX_PLAYBACK_CHANNELS, 0, &pcm)) < 0)
                 return err;
 
@@ -1833,21 +1823,14 @@ int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
-int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device,
-                              struct snd_pcm **rpcm)
+int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(chip->card, "CS46xx - Center LFE", device, MAX_PLAYBACK_CHANNELS, 0, &pcm)) < 0)
                 return err;
 
@@ -1863,21 +1846,14 @@ int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
-int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device,
-                          struct snd_pcm **rpcm)
+int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(chip->card, "CS46xx - IEC958", device, 1, 0, &pcm)) < 0)
                 return err;
 
@@ -1893,9 +1869,6 @@ int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 #endif
@@ -2724,13 +2697,11 @@ static struct snd_rawmidi_ops snd_cs46xx_midi_input =
         .trigger =      snd_cs46xx_midi_input_trigger,
 };
 
-int snd_cs46xx_midi(struct snd_cs46xx *chip, int device, struct snd_rawmidi **rrawmidi)
+int snd_cs46xx_midi(struct snd_cs46xx *chip, int device)
 {
         struct snd_rawmidi *rmidi;
         int err;
 
-        if (rrawmidi)
-                *rrawmidi = NULL;
         if ((err = snd_rawmidi_new(chip->card, "CS46XX", device, 1, 1, &rmidi)) < 0)
                 return err;
         strcpy(rmidi->name, "CS46XX");
@@ -2739,8 +2710,6 @@ int snd_cs46xx_midi(struct snd_cs46xx *chip, int device, struct snd_rawmidi **rr
         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
         rmidi->private_data = chip;
         chip->rmidi = rmidi;
-        if (rrawmidi)
-                *rrawmidi = NULL;
         return 0;
 }
 
@@ -2979,8 +2948,8 @@ static int snd_cs46xx_free(struct snd_cs46xx *chip)
 
         for (idx = 0; idx < 5; idx++) {
                 struct snd_cs46xx_region *region = &chip->region.idx[idx];
-                if (region->remap_addr)
-                        iounmap(region->remap_addr);
+
+                iounmap(region->remap_addr);
                 release_and_free_resource(region->resource);
         }
 
@@ -3804,7 +3773,6 @@ static unsigned int saved_regs[] = {
 
 static int snd_cs46xx_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_cs46xx *chip = card->private_data;
         int i, amp_saved;
@@ -3829,16 +3797,11 @@ static int snd_cs46xx_suspend(struct device *dev)
         /* disable CLKRUN */
         chip->active_ctrl(chip, -chip->amplifier);
         chip->amplifier = amp_saved; /* restore the status */
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_cs46xx_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_cs46xx *chip = card->private_data;
         int amp_saved;
@@ -3847,15 +3810,6 @@ static int snd_cs46xx_resume(struct device *dev)
 #endif
         unsigned int tmp;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         amp_saved = chip->amplifier;
         chip->amplifier = 0;
         chip->active_ctrl(chip, 1); /* force to on */
diff --git a/sound/pci/cs46xx/dsp_spos.c b/sound/pci/cs46xx/dsp_spos.c
index 1c4a0fb3ffef..5c99efb004c0 100644
--- a/sound/pci/cs46xx/dsp_spos.c
+++ b/sound/pci/cs46xx/dsp_spos.c
@@ -20,7 +20,7 @@
  */
 
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/init.h>
diff --git a/sound/pci/cs46xx/dsp_spos_scb_lib.c b/sound/pci/cs46xx/dsp_spos_scb_lib.c
index 8284bc9b5858..2c90c0bded69 100644
--- a/sound/pci/cs46xx/dsp_spos_scb_lib.c
+++ b/sound/pci/cs46xx/dsp_spos_scb_lib.c
@@ -21,7 +21,7 @@
  */
 
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/init.h>
diff --git a/sound/pci/cs5530.c b/sound/pci/cs5530.c
index b1025507a467..0a8cf94c4858 100644
--- a/sound/pci/cs5530.c
+++ b/sound/pci/cs5530.c
@@ -223,7 +223,7 @@ static int snd_cs5530_create(struct snd_card *card,
                 return err;
         }
 
-        err = snd_sb16dsp_pcm(chip->sb, 0, &chip->sb->pcm);
+        err = snd_sb16dsp_pcm(chip->sb, 0);
         if (err < 0) {
                 dev_err(card->dev, "Could not create PCM\n");
                 snd_cs5530_free(chip);
diff --git a/sound/pci/cs5535audio/cs5535audio.c b/sound/pci/cs5535audio/cs5535audio.c
index 16288e4d338a..802c33f1cc59 100644
--- a/sound/pci/cs5535audio/cs5535audio.c
+++ b/sound/pci/cs5535audio/cs5535audio.c
@@ -27,7 +27,7 @@
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/pcm.h>
diff --git a/sound/pci/cs5535audio/cs5535audio_pm.c b/sound/pci/cs5535audio/cs5535audio_pm.c
index 34cc60057d0c..06ac5d8da362 100644
--- a/sound/pci/cs5535audio/cs5535audio_pm.c
+++ b/sound/pci/cs5535audio/cs5535audio_pm.c
@@ -57,7 +57,6 @@ static void snd_cs5535audio_stop_hardware(struct cs5535audio *cs5535au)
 
 static int snd_cs5535audio_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cs5535audio *cs5535au = card->private_data;
         int i;
@@ -72,34 +71,17 @@ static int snd_cs5535audio_suspend(struct device *dev)
         }
         /* save important regs, then disable aclink in hw */
         snd_cs5535audio_stop_hardware(cs5535au);
-
-        if (pci_save_state(pci)) {
-                dev_err(dev, "pci_save_state failed!\n");
-                return -EIO;
-        }
-        pci_disable_device(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_cs5535audio_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cs5535audio *cs5535au = card->private_data;
         u32 tmp;
         int timeout;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         /* set LNK_WRM_RST to reset AC link */
         cs_writel(cs5535au, ACC_CODEC_CNTL, ACC_CODEC_CNTL_LNK_WRM_RST);
 
diff --git a/sound/pci/ctxfi/cthw20k1.c b/sound/pci/ctxfi/cthw20k1.c
index b425aa8ee578..1cac55fd1139 100644
--- a/sound/pci/ctxfi/cthw20k1.c
+++ b/sound/pci/ctxfi/cthw20k1.c
@@ -1985,10 +1985,7 @@ static int hw_card_shutdown(struct hw *hw)
                 free_irq(hw->irq, hw);
 
         hw->irq = -1;
-
-        if (hw->mem_base)
-                iounmap(hw->mem_base);
-
+        iounmap(hw->mem_base);
         hw->mem_base = NULL;
 
         if (hw->io_base)
@@ -2099,20 +2096,11 @@ static int hw_suspend(struct hw *hw)
                 pci_write_config_dword(pci, UAA_CFG_SPACE_FLAG, 0x0);
         }
 
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
-
         return 0;
 }
 
 static int hw_resume(struct hw *hw, struct card_conf *info)
 {
-        struct pci_dev *pci = hw->pci;
-
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
         /* Re-initialize card hardware. */
         return hw_card_init(hw, info);
 }
diff --git a/sound/pci/ctxfi/cthw20k2.c b/sound/pci/ctxfi/cthw20k2.c
index 253899d13790..955ad871e9a8 100644
--- a/sound/pci/ctxfi/cthw20k2.c
+++ b/sound/pci/ctxfi/cthw20k2.c
@@ -2110,10 +2110,7 @@ static int hw_card_shutdown(struct hw *hw)
                 free_irq(hw->irq, hw);
 
         hw->irq = -1;
-
-        if (hw->mem_base)
-                iounmap(hw->mem_base);
-
+        iounmap(hw->mem_base);
         hw->mem_base = NULL;
 
         if (hw->io_base)
@@ -2209,24 +2206,12 @@ static int hw_card_init(struct hw *hw, struct card_conf *info)
 #ifdef CONFIG_PM_SLEEP
 static int hw_suspend(struct hw *hw)
 {
-        struct pci_dev *pci = hw->pci;
-
         hw_card_stop(hw);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
-
         return 0;
 }
 
 static int hw_resume(struct hw *hw, struct card_conf *info)
 {
-        struct pci_dev *pci = hw->pci;
-
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
         /* Re-initialize card hardware. */
         return hw_card_init(hw, info);
 }
diff --git a/sound/pci/echoaudio/darla20.c b/sound/pci/echoaudio/darla20.c
index 4632946205a8..c95da6301677 100644
--- a/sound/pci/echoaudio/darla20.c
+++ b/sound/pci/echoaudio/darla20.c
@@ -43,6 +43,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -51,7 +52,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/darla24.c b/sound/pci/echoaudio/darla24.c
index f81c839cc887..3013b4daa19e 100644
--- a/sound/pci/echoaudio/darla24.c
+++ b/sound/pci/echoaudio/darla24.c
@@ -47,6 +47,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -55,7 +56,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/echo3g.c b/sound/pci/echoaudio/echo3g.c
index 3a5346c33d76..1f34a07b0b19 100644
--- a/sound/pci/echoaudio/echo3g.c
+++ b/sound/pci/echoaudio/echo3g.c
@@ -54,6 +54,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -63,7 +64,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index 21228adaa70c..a962de03ebb6 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -1872,12 +1872,8 @@ static int snd_echo_free(struct echoaudio *chip)
         if (chip->comm_page)
                 snd_dma_free_pages(&chip->commpage_dma_buf);
 
-        if (chip->dsp_registers)
-                iounmap(chip->dsp_registers);
-
+        iounmap(chip->dsp_registers);
         release_and_free_resource(chip->iores);
-
-
         pci_disable_device(chip->pci);
 
         /* release chip data */
@@ -2162,7 +2158,6 @@ ctl_error:
 
 static int snd_echo_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct echoaudio *chip = dev_get_drvdata(dev);
 
         snd_pcm_suspend_all(chip->analog_pcm);
@@ -2188,9 +2183,6 @@ static int snd_echo_suspend(struct device *dev)
         chip->dsp_code = NULL;
         free_irq(chip->irq, chip);
         chip->irq = -1;
-        pci_save_state(pci);
-        pci_disable_device(pci);
-
         return 0;
 }
 
@@ -2204,7 +2196,6 @@ static int snd_echo_resume(struct device *dev)
         u32 pipe_alloc_mask;
         int err;
 
-        pci_restore_state(pci);
         commpage_bak = kmalloc(sizeof(struct echoaudio), GFP_KERNEL);
         if (commpage_bak == NULL)
                 return -ENOMEM;
diff --git a/sound/pci/echoaudio/gina20.c b/sound/pci/echoaudio/gina20.c
index 9cb81c500824..4fa32a2e97db 100644
--- a/sound/pci/echoaudio/gina20.c
+++ b/sound/pci/echoaudio/gina20.c
@@ -47,6 +47,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -55,7 +56,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/gina24.c b/sound/pci/echoaudio/gina24.c
index 35d3e6eac990..b1bcacaef257 100644
--- a/sound/pci/echoaudio/gina24.c
+++ b/sound/pci/echoaudio/gina24.c
@@ -53,6 +53,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -61,7 +62,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/indigo.c b/sound/pci/echoaudio/indigo.c
index 8d91842d1268..175af9b1435f 100644
--- a/sound/pci/echoaudio/indigo.c
+++ b/sound/pci/echoaudio/indigo.c
@@ -45,6 +45,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -53,7 +54,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/indigodj.c b/sound/pci/echoaudio/indigodj.c
index 289cb969f5b9..8c60314e4901 100644
--- a/sound/pci/echoaudio/indigodj.c
+++ b/sound/pci/echoaudio/indigodj.c
@@ -45,6 +45,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -53,7 +54,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/indigoio.c b/sound/pci/echoaudio/indigoio.c
index 405a3f2e496f..f7618edfd79c 100644
--- a/sound/pci/echoaudio/indigoio.c
+++ b/sound/pci/echoaudio/indigoio.c
@@ -46,6 +46,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -54,7 +55,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/layla20.c b/sound/pci/echoaudio/layla20.c
index b392dd776b71..12e5d2164dc4 100644
--- a/sound/pci/echoaudio/layla20.c
+++ b/sound/pci/echoaudio/layla20.c
@@ -52,6 +52,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -61,7 +62,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/layla24.c b/sound/pci/echoaudio/layla24.c
index bc7f730b0ec6..6e4023728ef5 100644
--- a/sound/pci/echoaudio/layla24.c
+++ b/sound/pci/echoaudio/layla24.c
@@ -54,6 +54,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -63,7 +64,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/mia.c b/sound/pci/echoaudio/mia.c
index 27a9a6e5db2d..2f7562f1aefb 100644
--- a/sound/pci/echoaudio/mia.c
+++ b/sound/pci/echoaudio/mia.c
@@ -53,6 +53,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -62,7 +63,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/midi.c b/sound/pci/echoaudio/midi.c
index d913749d154a..a8fe58335ddc 100644
--- a/sound/pci/echoaudio/midi.c
+++ b/sound/pci/echoaudio/midi.c
@@ -257,9 +257,8 @@ static void snd_echo_midi_output_trigger(struct snd_rawmidi_substream *substream
         spin_lock_irq(&chip->lock);
         if (up) {
                 if (!chip->tinuse) {
-                        init_timer(&chip->timer);
-                        chip->timer.function = snd_echo_midi_output_write;
-                        chip->timer.data = (unsigned long)chip;
+                        setup_timer(&chip->timer, snd_echo_midi_output_write,
+                                    (unsigned long)chip);
                         chip->tinuse = 1;
                 }
         } else {
diff --git a/sound/pci/echoaudio/mona.c b/sound/pci/echoaudio/mona.c
index 3d13875c303d..34d499466393 100644
--- a/sound/pci/echoaudio/mona.c
+++ b/sound/pci/echoaudio/mona.c
@@ -51,6 +51,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -59,7 +60,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/emu10k1/emu10k1.c b/sound/pci/emu10k1/emu10k1.c
index 4c171636efcd..37d0220a094c 100644
--- a/sound/pci/emu10k1/emu10k1.c
+++ b/sound/pci/emu10k1/emu10k1.c
@@ -132,11 +132,11 @@ static int snd_card_emu10k1_probe(struct pci_dev *pci,
                 goto error;
         card->private_data = emu;
         emu->delay_pcm_irq = delay_pcm_irq[dev] & 0x1f;
-        if ((err = snd_emu10k1_pcm(emu, 0, NULL)) < 0)
+        if ((err = snd_emu10k1_pcm(emu, 0)) < 0)
                 goto error;
-        if ((err = snd_emu10k1_pcm_mic(emu, 1, NULL)) < 0)
+        if ((err = snd_emu10k1_pcm_mic(emu, 1)) < 0)
                 goto error;
-        if ((err = snd_emu10k1_pcm_efx(emu, 2, NULL)) < 0)
+        if ((err = snd_emu10k1_pcm_efx(emu, 2)) < 0)
                 goto error;
         /* This stores the periods table. */
         if (emu->card_capabilities->ca0151_chip) { /* P16V */   
@@ -151,10 +151,10 @@ static int snd_card_emu10k1_probe(struct pci_dev *pci,
         if ((err = snd_emu10k1_timer(emu, 0)) < 0)
                 goto error;
 
-        if ((err = snd_emu10k1_pcm_multi(emu, 3, NULL)) < 0)
+        if ((err = snd_emu10k1_pcm_multi(emu, 3)) < 0)
                 goto error;
         if (emu->card_capabilities->ca0151_chip) { /* P16V */
-                if ((err = snd_p16v_pcm(emu, 4, NULL)) < 0)
+                if ((err = snd_p16v_pcm(emu, 4)) < 0)
                         goto error;
         }
         if (emu->audigy) {
@@ -164,7 +164,7 @@ static int snd_card_emu10k1_probe(struct pci_dev *pci,
                 if ((err = snd_emu10k1_midi(emu)) < 0)
                         goto error;
         }
-        if ((err = snd_emu10k1_fx8010_new(emu, 0, NULL)) < 0)
+        if ((err = snd_emu10k1_fx8010_new(emu, 0)) < 0)
                 goto error;
 #ifdef ENABLE_SYNTH
         if (snd_seq_device_new(card, 1, SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH,
@@ -210,7 +210,6 @@ static void snd_card_emu10k1_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_emu10k1_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_emu10k1 *emu = card->private_data;
 
@@ -232,28 +231,14 @@ static int snd_emu10k1_suspend(struct device *dev)
                 snd_p16v_suspend(emu);
 
         snd_emu10k1_done(emu);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_emu10k1_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_emu10k1 *emu = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_emu10k1_resume_init(emu);
         snd_emu10k1_efx_resume(emu);
         snd_ac97_resume(emu->ac97);
diff --git a/sound/pci/emu10k1/emu10k1x.c b/sound/pci/emu10k1/emu10k1x.c
index 15933f92f63a..6d1b98d14327 100644
--- a/sound/pci/emu10k1/emu10k1x.c
+++ b/sound/pci/emu10k1/emu10k1x.c
@@ -847,15 +847,13 @@ static const struct snd_pcm_chmap_elem clfe_map[] = {
         { }
 };
 
-static int snd_emu10k1x_pcm(struct emu10k1x *emu, int device, struct snd_pcm **rpcm)
+static int snd_emu10k1x_pcm(struct emu10k1x *emu, int device)
 {
         struct snd_pcm *pcm;
         const struct snd_pcm_chmap_elem *map = NULL;
         int err;
         int capture = 0;
   
-        if (rpcm)
-                *rpcm = NULL;
         if (device == 0)
                 capture = 1;
         
@@ -896,15 +894,8 @@ static int snd_emu10k1x_pcm(struct emu10k1x *emu, int device, struct snd_pcm **r
                                               snd_dma_pci_data(emu->pci), 
                                               32*1024, 32*1024);
   
-        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, map, 2,
+        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, map, 2,
                                      1 << 2, NULL);
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-  
-        return 0;
 }
 
 static int snd_emu10k1x_create(struct snd_card *card,
@@ -1583,15 +1574,15 @@ static int snd_emu10k1x_probe(struct pci_dev *pci,
                 return err;
         }
 
-        if ((err = snd_emu10k1x_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_emu10k1x_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_emu10k1x_pcm(chip, 1, NULL)) < 0) {
+        if ((err = snd_emu10k1x_pcm(chip, 1)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_emu10k1x_pcm(chip, 2, NULL)) < 0) {
+        if ((err = snd_emu10k1x_pcm(chip, 2)) < 0) {
                 snd_card_free(card);
                 return err;
         }
diff --git a/sound/pci/emu10k1/emufx.c b/sound/pci/emu10k1/emufx.c
index eb5c0aba41c1..56fc47bd6dba 100644
--- a/sound/pci/emu10k1/emufx.c
+++ b/sound/pci/emu10k1/emufx.c
@@ -2641,14 +2641,11 @@ static int snd_emu10k1_fx8010_release(struct snd_hwdep * hw, struct file *file)
         return 0;
 }
 
-int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device,
-                           struct snd_hwdep **rhwdep)
+int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device)
 {
         struct snd_hwdep *hw;
         int err;
         
-        if (rhwdep)
-                *rhwdep = NULL;
         if ((err = snd_hwdep_new(emu->card, "FX8010", device, &hw)) < 0)
                 return err;
         strcpy(hw->name, "EMU10K1 (FX8010)");
@@ -2657,8 +2654,6 @@ int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device,
         hw->ops.ioctl = snd_emu10k1_fx8010_ioctl;
         hw->ops.release = snd_emu10k1_fx8010_release;
         hw->private_data = emu;
-        if (rhwdep)
-                *rhwdep = hw;
         return 0;
 }
 
diff --git a/sound/pci/emu10k1/emupcm.c b/sound/pci/emu10k1/emupcm.c
index f82481bd2542..0dc07385af0e 100644
--- a/sound/pci/emu10k1/emupcm.c
+++ b/sound/pci/emu10k1/emupcm.c
@@ -1400,15 +1400,12 @@ static struct snd_pcm_ops snd_emu10k1_efx_playback_ops = {
         .page =                 snd_pcm_sgbuf_ops_page,
 };
 
-int snd_emu10k1_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
+int snd_emu10k1_pcm(struct snd_emu10k1 *emu, int device)
 {
         struct snd_pcm *pcm;
         struct snd_pcm_substream *substream;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(emu->card, "emu10k1", device, 32, 1, &pcm)) < 0)
                 return err;
 
@@ -1429,22 +1426,15 @@ int snd_emu10k1_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
         for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; substream; substream = substream->next)
                 snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(emu->pci), 64*1024, 64*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
-int snd_emu10k1_pcm_multi(struct snd_emu10k1 *emu, int device,
-                          struct snd_pcm **rpcm)
+int snd_emu10k1_pcm_multi(struct snd_emu10k1 *emu, int device)
 {
         struct snd_pcm *pcm;
         struct snd_pcm_substream *substream;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(emu->card, "emu10k1", device, 1, 0, &pcm)) < 0)
                 return err;
 
@@ -1461,9 +1451,6 @@ int snd_emu10k1_pcm_multi(struct snd_emu10k1 *emu, int device,
                 if ((err = snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG, snd_dma_pci_data(emu->pci), 64*1024, 64*1024)) < 0)
                         return err;
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
@@ -1479,15 +1466,11 @@ static struct snd_pcm_ops snd_emu10k1_capture_mic_ops = {
         .pointer =              snd_emu10k1_capture_pointer,
 };
 
-int snd_emu10k1_pcm_mic(struct snd_emu10k1 *emu, int device,
-                        struct snd_pcm **rpcm)
+int snd_emu10k1_pcm_mic(struct snd_emu10k1 *emu, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(emu->card, "emu10k1 mic", device, 0, 1, &pcm)) < 0)
                 return err;
 
@@ -1501,8 +1484,6 @@ int snd_emu10k1_pcm_mic(struct snd_emu10k1 *emu, int device,
 
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(emu->pci), 64*1024, 64*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -1822,16 +1803,12 @@ static struct snd_pcm_ops snd_emu10k1_fx8010_playback_ops = {
         .ack =                  snd_emu10k1_fx8010_playback_transfer,
 };
 
-int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device,
-                        struct snd_pcm **rpcm)
+int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device)
 {
         struct snd_pcm *pcm;
         struct snd_kcontrol *kctl;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(emu->card, "emu10k1 efx", device, 8, 1, &pcm)) < 0)
                 return err;
 
@@ -1843,8 +1820,6 @@ int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device,
         pcm->info_flags = 0;
         strcpy(pcm->name, "Multichannel Capture/PT Playback");
         emu->pcm_efx = pcm;
-        if (rpcm)
-                *rpcm = pcm;
 
         /* EFX capture - record the "FXBUS2" channels, by default we connect the EXTINs 
          * to these
diff --git a/sound/pci/emu10k1/p16v.c b/sound/pci/emu10k1/p16v.c
index 7ef3898a7806..3c60b433de9f 100644
--- a/sound/pci/emu10k1/p16v.c
+++ b/sound/pci/emu10k1/p16v.c
@@ -166,11 +166,8 @@ static struct snd_pcm_hardware snd_p16v_capture_hw = {
 static void snd_p16v_pcm_free_substream(struct snd_pcm_runtime *runtime)
 {
         struct snd_emu10k1_pcm *epcm = runtime->private_data;
-  
-        if (epcm) {
-                /* dev_dbg(emu->card->dev, "epcm free: %p\n", epcm); */
-                kfree(epcm);
-        }
+
+        kfree(epcm);
 }
 
 /* open_playback callback */
@@ -640,7 +637,7 @@ int snd_p16v_free(struct snd_emu10k1 *chip)
         return 0;
 }
 
-int snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
+int snd_p16v_pcm(struct snd_emu10k1 *emu, int device)
 {
         struct snd_pcm *pcm;
         struct snd_pcm_substream *substream;
@@ -649,8 +646,6 @@ int snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
   
         /* dev_dbg(emu->card->dev, "snd_p16v_pcm called. device=%d\n", device); */
         emu->p16v_device_offset = device;
-        if (rpcm)
-                *rpcm = NULL;
 
         if ((err = snd_pcm_new(emu->card, "p16v", device, 1, capture, &pcm)) < 0)
                 return err;
@@ -694,9 +689,6 @@ int snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
                 */
         }
   
-        if (rpcm)
-                *rpcm = pcm;
-  
         return 0;
 }
 
diff --git a/sound/pci/ens1370.c b/sound/pci/ens1370.c
index d94cb3ca7a64..0dc44ebb0032 100644
--- a/sound/pci/ens1370.c
+++ b/sound/pci/ens1370.c
@@ -26,7 +26,7 @@
  * by Kurt J. Bosch
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1268,14 +1268,11 @@ static const struct snd_pcm_chmap_elem surround_map[] = {
         { }
 };
 
-static int snd_ensoniq_pcm(struct ensoniq *ensoniq, int device,
-                           struct snd_pcm **rpcm)
+static int snd_ensoniq_pcm(struct ensoniq *ensoniq, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(ensoniq->card, CHIP_NAME "/1", device, 1, 1, &pcm);
         if (err < 0)
                 return err;
@@ -1302,22 +1299,14 @@ static int snd_ensoniq_pcm(struct ensoniq *ensoniq, int device,
         err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                      snd_pcm_std_chmaps, 2, 0, NULL);
 #endif
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
+        return err;
 }
 
-static int snd_ensoniq_pcm2(struct ensoniq *ensoniq, int device,
-                            struct snd_pcm **rpcm)
+static int snd_ensoniq_pcm2(struct ensoniq *ensoniq, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(ensoniq->card, CHIP_NAME "/2", device, 1, 0, &pcm);
         if (err < 0)
                 return err;
@@ -1342,12 +1331,7 @@ static int snd_ensoniq_pcm2(struct ensoniq *ensoniq, int device,
         err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                      surround_map, 2, 0, NULL);
 #endif
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
+        return err;
 }
 
 /*
@@ -2049,7 +2033,6 @@ static void snd_ensoniq_chip_init(struct ensoniq *ensoniq)
 #ifdef CONFIG_PM_SLEEP
 static int snd_ensoniq_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct ensoniq *ensoniq = card->private_data;
         
@@ -2070,28 +2053,14 @@ static int snd_ensoniq_suspend(struct device *dev)
         udelay(100);
         snd_ak4531_suspend(ensoniq->u.es1370.ak4531);
 #endif  
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_ensoniq_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct ensoniq *ensoniq = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_ensoniq_chip_init(ensoniq);
 
 #ifdef CHIP1371 
@@ -2362,14 +2331,11 @@ static struct snd_rawmidi_ops snd_ensoniq_midi_input =
         .trigger =      snd_ensoniq_midi_input_trigger,
 };
 
-static int snd_ensoniq_midi(struct ensoniq *ensoniq, int device,
-                            struct snd_rawmidi **rrawmidi)
+static int snd_ensoniq_midi(struct ensoniq *ensoniq, int device)
 {
         struct snd_rawmidi *rmidi;
         int err;
 
-        if (rrawmidi)
-                *rrawmidi = NULL;
         if ((err = snd_rawmidi_new(ensoniq->card, "ES1370/1", device, 1, 1, &rmidi)) < 0)
                 return err;
         strcpy(rmidi->name, CHIP_NAME);
@@ -2379,8 +2345,6 @@ static int snd_ensoniq_midi(struct ensoniq *ensoniq, int device,
                 SNDRV_RAWMIDI_INFO_DUPLEX;
         rmidi->private_data = ensoniq;
         ensoniq->rmidi = rmidi;
-        if (rrawmidi)
-                *rrawmidi = rmidi;
         return 0;
 }
 
@@ -2462,15 +2426,15 @@ static int snd_audiopci_probe(struct pci_dev *pci,
                 return err;
         }
 #endif
-        if ((err = snd_ensoniq_pcm(ensoniq, 0, NULL)) < 0) {
+        if ((err = snd_ensoniq_pcm(ensoniq, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_ensoniq_pcm2(ensoniq, 1, NULL)) < 0) {
+        if ((err = snd_ensoniq_pcm2(ensoniq, 1)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_ensoniq_midi(ensoniq, 0, NULL)) < 0) {
+        if ((err = snd_ensoniq_midi(ensoniq, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
diff --git a/sound/pci/es1938.c b/sound/pci/es1938.c
index 0fc46eb4e251..e1858d9d23d8 100644
--- a/sound/pci/es1938.c
+++ b/sound/pci/es1938.c
@@ -55,6 +55,7 @@
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/dma-mapping.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/pcm.h>
@@ -63,8 +64,6 @@
 #include <sound/initval.h>
 #include <sound/tlv.h>
 
-#include <asm/io.h>
-
 MODULE_AUTHOR("Jaromir Koutek <miri@punknet.cz>");
 MODULE_DESCRIPTION("ESS Solo-1");
 MODULE_LICENSE("GPL");
@@ -1454,7 +1453,6 @@ static unsigned char saved_regs[SAVED_REG_SIZE+1] = {
 
 static int es1938_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct es1938 *chip = card->private_data;
         unsigned char *s, *d;
@@ -1471,9 +1469,6 @@ static int es1938_suspend(struct device *dev)
                 free_irq(chip->irq, chip);
                 chip->irq = -1;
         }
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
@@ -1484,14 +1479,6 @@ static int es1938_resume(struct device *dev)
         struct es1938 *chip = card->private_data;
         unsigned char *s, *d;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-
         if (request_irq(pci->irq, snd_es1938_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
                 dev_err(dev, "unable to grab IRQ %d, disabling device\n",
diff --git a/sound/pci/es1968.c b/sound/pci/es1968.c
index 6039700f8579..059f3846d7b8 100644
--- a/sound/pci/es1968.c
+++ b/sound/pci/es1968.c
@@ -94,7 +94,7 @@
  *      places.
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -2383,7 +2383,6 @@ static void snd_es1968_start_irq(struct es1968 *chip)
  */
 static int es1968_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct es1968 *chip = card->private_data;
 
@@ -2396,16 +2395,11 @@ static int es1968_suspend(struct device *dev)
         snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
         snd_es1968_bob_stop(chip);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int es1968_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct es1968 *chip = card->private_data;
         struct esschan *es;
@@ -2413,16 +2407,6 @@ static int es1968_resume(struct device *dev)
         if (! chip->do_pm)
                 return 0;
 
-        /* restore all our config */
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_es1968_chip_init(chip);
 
         /* need to restore the base pointers.. */ 
diff --git a/sound/pci/fm801.c b/sound/pci/fm801.c
index d167afffce5f..1fdd92b6f18f 100644
--- a/sound/pci/fm801.c
+++ b/sound/pci/fm801.c
@@ -2,8 +2,6 @@
  *  The driver for the ForteMedia FM801 based soundcards
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  *
- *  Support FM only card by Andy Shevchenko <andy@smile.org.ua>
- *
  *   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
@@ -14,10 +12,6 @@
  *   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/delay.h>
@@ -704,13 +698,11 @@ static struct snd_pcm_ops snd_fm801_capture_ops = {
         .pointer =      snd_fm801_capture_pointer,
 };
 
-static int snd_fm801_pcm(struct fm801 *chip, int device, struct snd_pcm **rpcm)
+static int snd_fm801_pcm(struct fm801 *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "FM801", device, 1, 1, &pcm)) < 0)
                 return err;
 
@@ -726,16 +718,10 @@ static int snd_fm801_pcm(struct fm801 *chip, int device, struct snd_pcm **rpcm)
                                               snd_dma_pci_data(chip->pci),
                                               chip->multichannel ? 128*1024 : 64*1024, 128*1024);
 
-        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                      snd_pcm_alt_chmaps,
                                      chip->multichannel ? 6 : 2, 0,
                                      NULL);
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
 }
 
 /*
@@ -1186,12 +1172,6 @@ static int snd_fm801_free(struct fm801 *chip)
                 v4l2_device_unregister(&chip->v4l2_dev);
         }
 #endif
-        if (chip->irq >= 0)
-                free_irq(chip->irq, chip);
-        pci_release_regions(chip->pci);
-        pci_disable_device(chip->pci);
-
-        kfree(chip);
         return 0;
 }
 
@@ -1214,28 +1194,23 @@ static int snd_fm801_create(struct snd_card *card,
         };
 
         *rchip = NULL;
-        if ((err = pci_enable_device(pci)) < 0)
+        if ((err = pcim_enable_device(pci)) < 0)
                 return err;
-        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
-        if (chip == NULL) {
-                pci_disable_device(pci);
+        chip = devm_kzalloc(&pci->dev, sizeof(*chip), GFP_KERNEL);
+        if (chip == NULL)
                 return -ENOMEM;
-        }
         spin_lock_init(&chip->reg_lock);
         chip->card = card;
         chip->pci = pci;
         chip->irq = -1;
         chip->tea575x_tuner = tea575x_tuner;
-        if ((err = pci_request_regions(pci, "FM801")) < 0) {
-                kfree(chip);
-                pci_disable_device(pci);
+        if ((err = pci_request_regions(pci, "FM801")) < 0)
                 return err;
-        }
         chip->port = pci_resource_start(pci, 0);
         if ((tea575x_tuner & TUNER_ONLY) == 0) {
-                if (request_irq(pci->irq, snd_fm801_interrupt, IRQF_SHARED,
-                                KBUILD_MODNAME, chip)) {
-                        dev_err(card->dev, "unable to grab IRQ %d\n", chip->irq);
+                if (devm_request_irq(&pci->dev, pci->irq, snd_fm801_interrupt,
+                                IRQF_SHARED, KBUILD_MODNAME, chip)) {
+                        dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                         snd_fm801_free(chip);
                         return -EBUSY;
                 }
@@ -1250,12 +1225,6 @@ static int snd_fm801_create(struct snd_card *card,
         /* init might set tuner access method */
         tea575x_tuner = chip->tea575x_tuner;
 
-        if (chip->irq >= 0 && (tea575x_tuner & TUNER_ONLY)) {
-                pci_clear_master(pci);
-                free_irq(chip->irq, chip);
-                chip->irq = -1;
-        }
-
         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
                 snd_fm801_free(chip);
                 return err;
@@ -1340,7 +1309,7 @@ static int snd_card_fm801_probe(struct pci_dev *pci,
         if (chip->tea575x_tuner & TUNER_ONLY)
                 goto __fm801_tuner_only;
 
-        if ((err = snd_fm801_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_fm801_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
@@ -1392,7 +1361,6 @@ static unsigned char saved_regs[] = {
 
 static int snd_fm801_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct fm801 *chip = card->private_data;
         int i;
@@ -1404,29 +1372,15 @@ static int snd_fm801_suspend(struct device *dev)
         for (i = 0; i < ARRAY_SIZE(saved_regs); i++)
                 chip->saved_regs[i] = inw(chip->port + saved_regs[i]);
         /* FIXME: tea575x suspend */
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_fm801_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct fm801 *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_fm801_chip_init(chip, 1);
         snd_ac97_resume(chip->ac97);
         snd_ac97_resume(chip->ac97_sec);
diff --git a/sound/pci/hda/Kconfig b/sound/pci/hda/Kconfig
index ebf4c2fb99df..7f0f2c5a4e97 100644
--- a/sound/pci/hda/Kconfig
+++ b/sound/pci/hda/Kconfig
@@ -107,6 +107,7 @@ config SND_HDA_PATCH_LOADER
 config SND_HDA_CODEC_REALTEK
         tristate "Build Realtek HD-audio codec support"
         select SND_HDA_GENERIC
+        select INPUT
         help
           Say Y or M here to include Realtek HD-audio codec support in
           snd-hda-intel driver, such as ALC880.
diff --git a/sound/pci/hda/hda_auto_parser.c b/sound/pci/hda/hda_auto_parser.c
index 1ede82200ee5..3f8706bb3d16 100644
--- a/sound/pci/hda/hda_auto_parser.c
+++ b/sound/pci/hda/hda_auto_parser.c
@@ -409,10 +409,10 @@ int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
         /*
          * debug prints of the parsed results
          */
-        codec_info(codec, "autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
-                   cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
-                   cfg->line_out_pins[2], cfg->line_out_pins[3],
-                   cfg->line_out_pins[4],
+        codec_info(codec, "autoconfig for %s: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
+                   codec->chip_name, cfg->line_outs, cfg->line_out_pins[0],
+                   cfg->line_out_pins[1], cfg->line_out_pins[2],
+                   cfg->line_out_pins[3], cfg->line_out_pins[4],
                    cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
                    (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
                     "speaker" : "line"));
@@ -920,6 +920,8 @@ void snd_hda_pick_pin_fixup(struct hda_codec *codec,
                         codec->fixup_id = pq->value;
 #ifdef CONFIG_SND_DEBUG_VERBOSE
                         codec->fixup_name = pq->name;
+                        codec_dbg(codec, "%s: picked fixup %s (pin match)\n",
+                                  codec->chip_name, codec->fixup_name);
 #endif
                         codec->fixup_list = fixlist;
                         return;
@@ -960,6 +962,8 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
                 codec->fixup_list = NULL;
                 codec->fixup_name = NULL;
                 codec->fixup_id = HDA_FIXUP_ID_NO_FIXUP;
+                codec_dbg(codec, "%s: picked no fixup (nofixup specified)\n",
+                          codec->chip_name);
                 return;
         }
 
@@ -969,6 +973,8 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
                                 codec->fixup_id = models->id;
                                 codec->fixup_name = models->name;
                                 codec->fixup_list = fixlist;
+                                codec_dbg(codec, "%s: picked fixup %s (model specified)\n",
+                                          codec->chip_name, codec->fixup_name);
                                 return;
                         }
                         models++;
@@ -980,6 +986,8 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
                         id = q->value;
 #ifdef CONFIG_SND_DEBUG_VERBOSE
                         name = q->name;
+                        codec_dbg(codec, "%s: picked fixup %s (PCI SSID%s)\n",
+                                  codec->chip_name, name, q->subdevice_mask ? "" : " - vendor generic");
 #endif
                 }
         }
@@ -992,6 +1000,8 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
                                 id = q->value;
 #ifdef CONFIG_SND_DEBUG_VERBOSE
                                 name = q->name;
+                                codec_dbg(codec, "%s: picked fixup %s (codec SSID)\n",
+                                          codec->chip_name, name);
 #endif
                                 break;
                         }
diff --git a/sound/pci/hda/hda_controller.c b/sound/pci/hda/hda_controller.c
index 0cfc9c8c4b4e..a2ce773bdc62 100644
--- a/sound/pci/hda/hda_controller.c
+++ b/sound/pci/hda/hda_controller.c
@@ -657,6 +657,9 @@ static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                 azx_writel(chip, SSYNC, azx_readl(chip, SSYNC) & ~sbits);
         if (start) {
                 azx_timecounter_init(substream, 0, 0);
+                snd_pcm_gettime(substream->runtime, &substream->runtime->trigger_tstamp);
+                substream->runtime->trigger_tstamp_latched = true;
+
                 if (nsync > 1) {
                         cycle_t cycle_last;
 
@@ -939,7 +942,8 @@ static int azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
                                               chip->card->dev,
                                               size, MAX_PREALLOC_SIZE);
         /* link to codec */
-        pcm->dev = &codec->dev;
+        for (s = 0; s < 2; s++)
+                pcm->streams[s].dev.parent = &codec->dev;
         return 0;
 }
 
@@ -957,7 +961,6 @@ static int azx_alloc_cmd_io(struct azx *chip)
                 dev_err(chip->card->dev, "cannot allocate CORB/RIRB\n");
         return err;
 }
-EXPORT_SYMBOL_GPL(azx_alloc_cmd_io);
 
 static void azx_init_cmd_io(struct azx *chip)
 {
@@ -1022,7 +1025,6 @@ static void azx_init_cmd_io(struct azx *chip)
         azx_writeb(chip, RIRBCTL, AZX_RBCTL_DMA_EN | AZX_RBCTL_IRQ_EN);
         spin_unlock_irq(&chip->reg_lock);
 }
-EXPORT_SYMBOL_GPL(azx_init_cmd_io);
 
 static void azx_free_cmd_io(struct azx *chip)
 {
@@ -1032,7 +1034,6 @@ static void azx_free_cmd_io(struct azx *chip)
         azx_writeb(chip, CORBCTL, 0);
         spin_unlock_irq(&chip->reg_lock);
 }
-EXPORT_SYMBOL_GPL(azx_free_cmd_io);
 
 static unsigned int azx_command_addr(u32 cmd)
 {
@@ -1312,7 +1313,6 @@ static int azx_send_cmd(struct hda_bus *bus, unsigned int val)
         else
                 return azx_corb_send_cmd(bus, val);
 }
-EXPORT_SYMBOL_GPL(azx_send_cmd);
 
 /* get a response */
 static unsigned int azx_get_response(struct hda_bus *bus,
@@ -1326,7 +1326,6 @@ static unsigned int azx_get_response(struct hda_bus *bus,
         else
                 return azx_rirb_get_response(bus, addr);
 }
-EXPORT_SYMBOL_GPL(azx_get_response);
 
 #ifdef CONFIG_SND_HDA_DSP_LOADER
 /*
@@ -1993,4 +1992,4 @@ void azx_notifier_unregister(struct azx *chip)
 EXPORT_SYMBOL_GPL(azx_notifier_unregister);
 
 MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Common HDA driver funcitons");
+MODULE_DESCRIPTION("Common HDA driver functions");
diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c
index 014a7849e8fd..11b5a42b4ec8 100644
--- a/sound/pci/hda/hda_hwdep.c
+++ b/sound/pci/hda/hda_hwdep.c
@@ -109,7 +109,6 @@ int snd_hda_create_hwdep(struct hda_codec *codec)
         hwdep->iface = SNDRV_HWDEP_IFACE_HDA;
         hwdep->private_data = codec;
         hwdep->exclusive = 1;
-        hwdep->groups = snd_hda_dev_attr_groups;
 
         hwdep->ops.open = hda_hwdep_open;
         hwdep->ops.ioctl = hda_hwdep_ioctl;
@@ -118,7 +117,11 @@ int snd_hda_create_hwdep(struct hda_codec *codec)
 #endif
 
         /* link to codec */
-        hwdep->dev = &codec->dev;
+        hwdep->dev.parent = &codec->dev;
+
+        /* for sysfs */
+        hwdep->dev.groups = snd_hda_dev_attr_groups;
+        dev_set_drvdata(&hwdep->dev, codec);
 
         return 0;
 }
diff --git a/sound/pci/hda/hda_i915.c b/sound/pci/hda/hda_i915.c
index d4d0375ac181..714894527e06 100644
--- a/sound/pci/hda/hda_i915.c
+++ b/sound/pci/hda/hda_i915.c
@@ -18,10 +18,12 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/component.h>
+#include <drm/i915_component.h>
 #include <sound/core.h>
-#include <drm/i915_powerwell.h>
 #include "hda_priv.h"
-#include "hda_i915.h"
+#include "hda_intel.h"
 
 /* Intel HSW/BDW display HDA controller Extended Mode registers.
  * EM4 (M value) and EM5 (N Value) are used to convert CDClk (Core Display
@@ -31,32 +33,33 @@
 #define AZX_REG_EM4                     0x100c
 #define AZX_REG_EM5                     0x1010
 
-static int (*get_power)(void);
-static int (*put_power)(void);
-static int (*get_cdclk)(void);
-
-int hda_display_power(bool enable)
+int hda_display_power(struct hda_intel *hda, bool enable)
 {
-        if (!get_power || !put_power)
+        struct i915_audio_component *acomp = &hda->audio_component;
+
+        if (!acomp->ops)
                 return -ENODEV;
 
-        pr_debug("HDA display power %s \n",
-                        enable ? "Enable" : "Disable");
+        dev_dbg(&hda->chip.pci->dev, "display power %s\n",
+                enable ? "enable" : "disable");
         if (enable)
-                return get_power();
+                acomp->ops->get_power(acomp->dev);
         else
-                return put_power();
+                acomp->ops->put_power(acomp->dev);
+
+        return 0;
 }
 
-void haswell_set_bclk(struct azx *chip)
+void haswell_set_bclk(struct hda_intel *hda)
 {
         int cdclk_freq;
         unsigned int bclk_m, bclk_n;
+        struct i915_audio_component *acomp = &hda->audio_component;
 
-        if (!get_cdclk)
+        if (!acomp->ops)
                 return;
 
-        cdclk_freq = get_cdclk();
+        cdclk_freq = acomp->ops->get_cdclk_freq(acomp->dev);
         switch (cdclk_freq) {
         case 337500:
                 bclk_m = 16;
@@ -80,51 +83,108 @@ void haswell_set_bclk(struct azx *chip)
                 break;
         }
 
-        azx_writew(chip, EM4, bclk_m);
-        azx_writew(chip, EM5, bclk_n);
+        azx_writew(&hda->chip, EM4, bclk_m);
+        azx_writew(&hda->chip, EM5, bclk_n);
 }
 
-
-int hda_i915_init(void)
+static int hda_component_master_bind(struct device *dev)
 {
-        int err = 0;
-
-        get_power = symbol_request(i915_request_power_well);
-        if (!get_power) {
-                pr_warn("hda-i915: get_power symbol get fail\n");
-                return -ENODEV;
+        struct snd_card *card = dev_get_drvdata(dev);
+        struct azx *chip = card->private_data;
+        struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
+        struct i915_audio_component *acomp = &hda->audio_component;
+        int ret;
+
+        ret = component_bind_all(dev, acomp);
+        if (ret < 0)
+                return ret;
+
+        if (WARN_ON(!(acomp->dev && acomp->ops && acomp->ops->get_power &&
+                      acomp->ops->put_power && acomp->ops->get_cdclk_freq))) {
+                ret = -EINVAL;
+                goto out_unbind;
         }
 
-        put_power = symbol_request(i915_release_power_well);
-        if (!put_power) {
-                symbol_put(i915_request_power_well);
-                get_power = NULL;
-                return -ENODEV;
+        /*
+         * Atm, we don't support dynamic unbinding initiated by the child
+         * component, so pin its containing module until we unbind.
+         */
+        if (!try_module_get(acomp->ops->owner)) {
+                ret = -ENODEV;
+                goto out_unbind;
         }
 
-        get_cdclk = symbol_request(i915_get_cdclk_freq);
-        if (!get_cdclk) /* may have abnormal BCLK and audio playback rate */
-                pr_warn("hda-i915: get_cdclk symbol get fail\n");
+        return 0;
 
-        pr_debug("HDA driver get symbol successfully from i915 module\n");
+out_unbind:
+        component_unbind_all(dev, acomp);
 
-        return err;
+        return ret;
 }
 
-int hda_i915_exit(void)
+static void hda_component_master_unbind(struct device *dev)
 {
-        if (get_power) {
-                symbol_put(i915_request_power_well);
-                get_power = NULL;
-        }
-        if (put_power) {
-                symbol_put(i915_release_power_well);
-                put_power = NULL;
-        }
-        if (get_cdclk) {
-                symbol_put(i915_get_cdclk_freq);
-                get_cdclk = NULL;
+        struct snd_card *card = dev_get_drvdata(dev);
+        struct azx *chip = card->private_data;
+        struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
+        struct i915_audio_component *acomp = &hda->audio_component;
+
+        module_put(acomp->ops->owner);
+        component_unbind_all(dev, acomp);
+        WARN_ON(acomp->ops || acomp->dev);
+}
+
+static const struct component_master_ops hda_component_master_ops = {
+        .bind = hda_component_master_bind,
+        .unbind = hda_component_master_unbind,
+};
+
+static int hda_component_master_match(struct device *dev, void *data)
+{
+        /* i915 is the only supported component */
+        return !strcmp(dev->driver->name, "i915");
+}
+
+int hda_i915_init(struct hda_intel *hda)
+{
+        struct component_match *match = NULL;
+        struct device *dev = &hda->chip.pci->dev;
+        struct i915_audio_component *acomp = &hda->audio_component;
+        int ret;
+
+        component_match_add(dev, &match, hda_component_master_match, hda);
+        ret = component_master_add_with_match(dev, &hda_component_master_ops,
+                                              match);
+        if (ret < 0)
+                goto out_err;
+
+        /*
+         * Atm, we don't support deferring the component binding, so make sure
+         * i915 is loaded and that the binding successfully completes.
+         */
+        request_module("i915");
+
+        if (!acomp->ops) {
+                ret = -ENODEV;
+                goto out_master_del;
         }
 
+        dev_dbg(dev, "bound to i915 component master\n");
+
+        return 0;
+out_master_del:
+        component_master_del(dev, &hda_component_master_ops);
+out_err:
+        dev_err(dev, "failed to add i915 component master (%d)\n", ret);
+
+        return ret;
+}
+
+int hda_i915_exit(struct hda_intel *hda)
+{
+        struct device *dev = &hda->chip.pci->dev;
+
+        component_master_del(dev, &hda_component_master_ops);
+
         return 0;
 }
diff --git a/sound/pci/hda/hda_i915.h b/sound/pci/hda/hda_i915.h
deleted file mode 100644
index e6072c627583..000000000000
--- a/sound/pci/hda/hda_i915.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- *  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.
- */
-#ifndef __SOUND_HDA_I915_H
-#define __SOUND_HDA_I915_H
-
-#ifdef CONFIG_SND_HDA_I915
-int hda_display_power(bool enable);
-void haswell_set_bclk(struct azx *chip);
-int hda_i915_init(void);
-int hda_i915_exit(void);
-#else
-static inline int hda_display_power(bool enable) { return 0; }
-static inline void haswell_set_bclk(struct azx *chip) { return; }
-static inline int hda_i915_init(void)
-{
-        return -ENODEV;
-}
-static inline int hda_i915_exit(void)
-{
-        return 0;
-}
-#endif
-
-#endif
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index d426a0bd6a5f..4ca3d5d02436 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -63,7 +63,7 @@
 #include "hda_codec.h"
 #include "hda_controller.h"
 #include "hda_priv.h"
-#include "hda_i915.h"
+#include "hda_intel.h"
 
 /* position fix mode */
 enum {
@@ -354,31 +354,6 @@ static char *driver_short_names[] = {
         [AZX_DRIVER_GENERIC] = "HD-Audio Generic",
 };
 
-struct hda_intel {
-        struct azx chip;
-
-        /* for pending irqs */
-        struct work_struct irq_pending_work;
-
-        /* sync probing */
-        struct completion probe_wait;
-        struct work_struct probe_work;
-
-        /* card list (for power_save trigger) */
-        struct list_head list;
-
-        /* extra flags */
-        unsigned int irq_pending_warned:1;
-
-        /* VGA-switcheroo setup */
-        unsigned int use_vga_switcheroo:1;
-        unsigned int vga_switcheroo_registered:1;
-        unsigned int init_failed:1; /* delayed init failed */
-
-        /* secondary power domain for hdmi audio under vga device */
-        struct dev_pm_domain hdmi_pm_domain;
-};
-
 #ifdef CONFIG_X86
 static void __mark_pages_wc(struct azx *chip, struct snd_dma_buffer *dmab, bool on)
 {
@@ -795,7 +770,6 @@ static int param_set_xint(const char *val, const struct kernel_param *kp)
  */
 static int azx_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct azx *chip;
         struct hda_intel *hda;
@@ -824,11 +798,8 @@ static int azx_suspend(struct device *dev)
 
         if (chip->msi)
                 pci_disable_msi(chip->pci);
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
-                hda_display_power(false);
+                hda_display_power(hda, false);
         return 0;
 }
 
@@ -848,18 +819,9 @@ static int azx_resume(struct device *dev)
                 return 0;
 
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
-                hda_display_power(true);
-                haswell_set_bclk(chip);
-        }
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(chip->card->dev,
-                        "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
+                hda_display_power(hda, true);
+                haswell_set_bclk(hda);
         }
-        pci_set_master(pci);
         if (chip->msi)
                 if (pci_enable_msi(pci) < 0)
                         chip->msi = 0;
@@ -901,7 +863,7 @@ static int azx_runtime_suspend(struct device *dev)
         azx_enter_link_reset(chip);
         azx_clear_irq_pending(chip);
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
-                hda_display_power(false);
+                hda_display_power(hda, false);
 
         return 0;
 }
@@ -927,8 +889,8 @@ static int azx_runtime_resume(struct device *dev)
                 return 0;
 
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
-                hda_display_power(true);
-                haswell_set_bclk(chip);
+                hda_display_power(hda, true);
+                haswell_set_bclk(hda);
         }
 
         /* Read STATESTS before controller reset */
@@ -1138,8 +1100,7 @@ static int azx_free(struct azx *chip)
                 free_irq(chip->irq, (void*)chip);
         if (chip->msi)
                 pci_disable_msi(chip->pci);
-        if (chip->remap_addr)
-                iounmap(chip->remap_addr);
+        iounmap(chip->remap_addr);
 
         azx_free_stream_pages(chip);
         if (chip->region_requested)
@@ -1150,8 +1111,8 @@ static int azx_free(struct azx *chip)
         release_firmware(chip->fw);
 #endif
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
-                hda_display_power(false);
-                hda_i915_exit();
+                hda_display_power(hda, false);
+                hda_i915_exit(hda);
         }
         kfree(hda);
 
@@ -1629,8 +1590,12 @@ static int azx_first_init(struct azx *chip)
         /* initialize chip */
         azx_init_pci(chip);
 
-        if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
-                haswell_set_bclk(chip);
+        if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
+                struct hda_intel *hda;
+
+                hda = container_of(chip, struct hda_intel, chip);
+                haswell_set_bclk(hda);
+        }
 
         azx_init_chip(chip, (probe_only[dev] & 2) == 0);
 
@@ -1910,13 +1875,10 @@ static int azx_probe_continue(struct azx *chip)
         /* Request power well for Haswell HDA controller and codec */
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
 #ifdef CONFIG_SND_HDA_I915
-                err = hda_i915_init();
-                if (err < 0) {
-                        dev_err(chip->card->dev,
-                                "Error request power-well from i915\n");
+                err = hda_i915_init(hda);
+                if (err < 0)
                         goto out_free;
-                }
-                err = hda_display_power(true);
+                err = hda_display_power(hda, true);
                 if (err < 0) {
                         dev_err(chip->card->dev,
                                 "Cannot turn on display power on i915\n");
@@ -2004,7 +1966,7 @@ static const struct pci_device_id azx_ids[] = {
           .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH_NOPM },
         /* Panther Point */
         { PCI_DEVICE(0x8086, 0x1e20),
-          .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
+          .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH_NOPM },
         /* Lynx Point */
         { PCI_DEVICE(0x8086, 0x8c20),
           .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
diff --git a/sound/pci/hda/hda_intel.h b/sound/pci/hda/hda_intel.h
new file mode 100644
index 000000000000..348611835476
--- /dev/null
+++ b/sound/pci/hda/hda_intel.h
@@ -0,0 +1,71 @@
+/*
+ *  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.
+ */
+#ifndef __SOUND_HDA_INTEL_H
+#define __SOUND_HDA_INTEL_H
+
+#include <drm/i915_component.h>
+#include "hda_priv.h"
+
+struct hda_intel {
+        struct azx chip;
+
+        /* for pending irqs */
+        struct work_struct irq_pending_work;
+
+        /* sync probing */
+        struct completion probe_wait;
+        struct work_struct probe_work;
+
+        /* card list (for power_save trigger) */
+        struct list_head list;
+
+        /* extra flags */
+        unsigned int irq_pending_warned:1;
+
+        /* VGA-switcheroo setup */
+        unsigned int use_vga_switcheroo:1;
+        unsigned int vga_switcheroo_registered:1;
+        unsigned int init_failed:1; /* delayed init failed */
+
+        /* secondary power domain for hdmi audio under vga device */
+        struct dev_pm_domain hdmi_pm_domain;
+
+        /* i915 component interface */
+        struct i915_audio_component audio_component;
+};
+
+#ifdef CONFIG_SND_HDA_I915
+int hda_display_power(struct hda_intel *hda, bool enable);
+void haswell_set_bclk(struct hda_intel *hda);
+int hda_i915_init(struct hda_intel *hda);
+int hda_i915_exit(struct hda_intel *hda);
+#else
+static inline int hda_display_power(struct hda_intel *hda, bool enable)
+{
+        return 0;
+}
+static inline void haswell_set_bclk(struct hda_intel *hda) { return; }
+static inline int hda_i915_init(struct hda_intel *hda)
+{
+        return -ENODEV;
+}
+static inline int hda_i915_exit(struct hda_intel *hda)
+{
+        return 0;
+}
+#endif
+
+#endif
diff --git a/sound/pci/hda/hda_priv.h b/sound/pci/hda/hda_priv.h
index 166e3e84b963..daf458299753 100644
--- a/sound/pci/hda/hda_priv.h
+++ b/sound/pci/hda/hda_priv.h
@@ -15,7 +15,7 @@
 #ifndef __SOUND_HDA_PRIV_H
 #define __SOUND_HDA_PRIV_H
 
-#include <linux/clocksource.h>
+#include <linux/timecounter.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 
diff --git a/sound/pci/hda/hda_tegra.c b/sound/pci/hda/hda_tegra.c
index 227990bc02e3..375e94f4cf52 100644
--- a/sound/pci/hda/hda_tegra.c
+++ b/sound/pci/hda/hda_tegra.c
@@ -329,8 +329,8 @@ static int hda_tegra_init_chip(struct azx *chip, struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         hda->regs = devm_ioremap_resource(dev, res);
-        if (IS_ERR(chip->remap_addr))
-                return PTR_ERR(chip->remap_addr);
+        if (IS_ERR(hda->regs))
+                return PTR_ERR(hda->regs);
 
         chip->remap_addr = hda->regs + HDA_BAR0;
         chip->addr = res->start + HDA_BAR0;
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index a9d78e275138..d285904cdb64 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -739,39 +739,6 @@ static int patch_ad1981(struct hda_codec *codec)
  *      E/F quad mic array
  */
 
-#ifdef ENABLE_AD_STATIC_QUIRKS
-static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
-                               struct snd_ctl_elem_info *uinfo)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct ad198x_spec *spec = codec->spec;
-        return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
-                                    spec->num_channel_mode);
-}
-
-static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
-                              struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct ad198x_spec *spec = codec->spec;
-        return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
-                                   spec->num_channel_mode, spec->multiout.max_channels);
-}
-
-static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
-                              struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct ad198x_spec *spec = codec->spec;
-        int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
-                                      spec->num_channel_mode,
-                                      &spec->multiout.max_channels);
-        if (err >= 0 && spec->need_dac_fix)
-                spec->multiout.num_dacs = spec->multiout.max_channels / 2;
-        return err;
-}
-#endif /* ENABLE_AD_STATIC_QUIRKS */
-
 static int ad1988_auto_smux_enum_info(struct snd_kcontrol *kcontrol,
                                       struct snd_ctl_elem_info *uinfo)
 {
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 65f1f4e18ea5..b2b24a8b3dac 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -29,6 +29,7 @@
 #include <linux/pci.h>
 #include <linux/dmi.h>
 #include <linux/module.h>
+#include <linux/input.h>
 #include <sound/core.h>
 #include <sound/jack.h>
 #include "hda_codec.h"
@@ -120,6 +121,7 @@ struct alc_spec {
         hda_nid_t pll_nid;
         unsigned int pll_coef_idx, pll_coef_bit;
         unsigned int coef0;
+        struct input_dev *kb_dev;
 };
 
 /*
@@ -3472,6 +3474,79 @@ static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
         }
 }
 
+static void gpio2_mic_hotkey_event(struct hda_codec *codec,
+                                   struct hda_jack_callback *event)
+{
+        struct alc_spec *spec = codec->spec;
+
+        /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
+           send both key on and key off event for every interrupt. */
+        input_report_key(spec->kb_dev, KEY_MICMUTE, 1);
+        input_sync(spec->kb_dev);
+        input_report_key(spec->kb_dev, KEY_MICMUTE, 0);
+        input_sync(spec->kb_dev);
+}
+
+static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
+                                             const struct hda_fixup *fix, int action)
+{
+        /* GPIO1 = set according to SKU external amp
+           GPIO2 = mic mute hotkey
+           GPIO3 = mute LED
+           GPIO4 = mic mute LED */
+        static const struct hda_verb gpio_init[] = {
+                { 0x01, AC_VERB_SET_GPIO_MASK, 0x1e },
+                { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x1a },
+                { 0x01, AC_VERB_SET_GPIO_DATA, 0x02 },
+                {}
+        };
+
+        struct alc_spec *spec = codec->spec;
+
+        if (action == HDA_FIXUP_ACT_PRE_PROBE) {
+                spec->kb_dev = input_allocate_device();
+                if (!spec->kb_dev) {
+                        codec_err(codec, "Out of memory (input_allocate_device)\n");
+                        return;
+                }
+                spec->kb_dev->name = "Microphone Mute Button";
+                spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
+                spec->kb_dev->keybit[BIT_WORD(KEY_MICMUTE)] = BIT_MASK(KEY_MICMUTE);
+                if (input_register_device(spec->kb_dev)) {
+                        codec_err(codec, "input_register_device failed\n");
+                        input_free_device(spec->kb_dev);
+                        spec->kb_dev = NULL;
+                        return;
+                }
+
+                snd_hda_add_verbs(codec, gpio_init);
+                snd_hda_codec_write_cache(codec, codec->afg, 0,
+                                          AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
+                snd_hda_jack_detect_enable_callback(codec, codec->afg,
+                                                    gpio2_mic_hotkey_event);
+
+                spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
+                spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
+                spec->gpio_led = 0;
+                spec->mute_led_polarity = 0;
+                spec->gpio_mute_led_mask = 0x08;
+                spec->gpio_mic_led_mask = 0x10;
+                return;
+        }
+
+        if (!spec->kb_dev)
+                return;
+
+        switch (action) {
+        case HDA_FIXUP_ACT_PROBE:
+                spec->init_amp = ALC_INIT_DEFAULT;
+                break;
+        case HDA_FIXUP_ACT_FREE:
+                input_unregister_device(spec->kb_dev);
+                spec->kb_dev = NULL;
+        }
+}
+
 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
                                 const struct hda_fixup *fix, int action)
 {
@@ -4341,6 +4416,8 @@ enum {
         ALC282_FIXUP_ASPIRE_V5_PINS,
         ALC280_FIXUP_HP_GPIO4,
         ALC286_FIXUP_HP_GPIO_LED,
+        ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
+        ALC280_FIXUP_HP_DOCK_PINS,
 };
 
 static const struct hda_fixup alc269_fixups[] = {
@@ -4814,6 +4891,21 @@ static const struct hda_fixup alc269_fixups[] = {
                 .type = HDA_FIXUP_FUNC,
                 .v.func = alc286_fixup_hp_gpio_led,
         },
+        [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
+        },
+        [ALC280_FIXUP_HP_DOCK_PINS] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        { 0x1b, 0x21011020 }, /* line-out */
+                        { 0x1a, 0x01a1903c }, /* headset mic */
+                        { 0x18, 0x2181103f }, /* line-in */
+                        { },
+                },
+                .chained = true,
+                .chain_id = ALC280_FIXUP_HP_GPIO4
+        },
 };
 
 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
@@ -4843,7 +4935,9 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
+        SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
         /* ALC282 */
+        SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
@@ -4856,6 +4950,8 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
+        SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
+        SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index 605d14003d25..87eff3173ce9 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -79,6 +79,7 @@ enum {
         STAC_ALIENWARE_M17X,
         STAC_92HD89XX_HP_FRONT_JACK,
         STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK,
+        STAC_92HD73XX_ASUS_MOBO,
         STAC_92HD73XX_MODELS
 };
 
@@ -99,6 +100,7 @@ enum {
         STAC_HP_ENVY_BASS,
         STAC_HP_BNB13_EQ,
         STAC_HP_ENVY_TS_BASS,
+        STAC_92HD83XXX_GPIO10_EAPD,
         STAC_92HD83XXX_MODELS
 };
 
@@ -1910,7 +1912,18 @@ static const struct hda_fixup stac92hd73xx_fixups[] = {
         [STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK] = {
                 .type = HDA_FIXUP_PINS,
                 .v.pins = stac92hd89xx_hp_z1_g2_right_mic_jack_pin_configs,
-        }
+        },
+        [STAC_92HD73XX_ASUS_MOBO] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        /* enable 5.1 and SPDIF out */
+                        { 0x0c, 0x01014411 },
+                        { 0x0d, 0x01014410 },
+                        { 0x0e, 0x01014412 },
+                        { 0x22, 0x014b1180 },
+                        { }
+                }
+        },
 };
 
 static const struct hda_model_fixup stac92hd73xx_models[] = {
@@ -1922,6 +1935,7 @@ static const struct hda_model_fixup stac92hd73xx_models[] = {
         { .id = STAC_DELL_M6_BOTH, .name = "dell-m6" },
         { .id = STAC_DELL_EQ, .name = "dell-eq" },
         { .id = STAC_ALIENWARE_M17X, .name = "alienware" },
+        { .id = STAC_92HD73XX_ASUS_MOBO, .name = "asus-mobo" },
         {}
 };
 
@@ -1974,6 +1988,8 @@ static const struct snd_pci_quirk stac92hd73xx_fixup_tbl[] = {
                                 "HP Z1 G2", STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK),
         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2b17,
                                 "unknown HP", STAC_92HD89XX_HP_FRONT_JACK),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_ASUSTEK, 0x83f8, "ASUS AT4NM10",
+                      STAC_92HD73XX_ASUS_MOBO),
         {} /* terminator */
 };
 
@@ -2141,6 +2157,19 @@ static void stac92hd83xxx_fixup_headset_jack(struct hda_codec *codec,
                 spec->headset_jack = 1;
 }
 
+static void stac92hd83xxx_fixup_gpio10_eapd(struct hda_codec *codec,
+                                            const struct hda_fixup *fix,
+                                            int action)
+{
+        struct sigmatel_spec *spec = codec->spec;
+
+        if (action != HDA_FIXUP_ACT_PRE_PROBE)
+                return;
+        spec->eapd_mask = spec->gpio_mask = spec->gpio_dir =
+                spec->gpio_data = 0x10;
+        spec->eapd_switch = 0;
+}
+
 static const struct hda_verb hp_bnb13_eq_verbs[] = {
         /* 44.1KHz base */
         { 0x22, 0x7A6, 0x3E },
@@ -2656,6 +2685,10 @@ static const struct hda_fixup stac92hd83xxx_fixups[] = {
                         {}
                 },
         },
+        [STAC_92HD83XXX_GPIO10_EAPD] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = stac92hd83xxx_fixup_gpio10_eapd,
+        },
 };
 
 static const struct hda_model_fixup stac92hd83xxx_models[] = {
@@ -2861,6 +2894,8 @@ static const struct snd_pci_quirk stac92hd83xxx_fixup_tbl[] = {
         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x148a,
                       "HP Mini", STAC_92HD83XXX_HP_LED),
         SND_PCI_QUIRK_VENDOR(PCI_VENDOR_ID_HP, "HP", STAC_92HD83XXX_HP),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_TOSHIBA, 0xfa91,
+                      "Toshiba Satellite S50D", STAC_92HD83XXX_GPIO10_EAPD),
         {} /* terminator */
 };
 
diff --git a/sound/pci/ice1712/ak4xxx.c b/sound/pci/ice1712/ak4xxx.c
index 3981823f9094..179ef7a5f0d1 100644
--- a/sound/pci/ice1712/ak4xxx.c
+++ b/sound/pci/ice1712/ak4xxx.c
@@ -21,7 +21,7 @@
  *
  */      
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c
index b039b46152c6..f7b1523e8a82 100644
--- a/sound/pci/ice1712/ice1712.c
+++ b/sound/pci/ice1712/ice1712.c
@@ -880,13 +880,11 @@ static struct snd_pcm_ops snd_ice1712_capture_ops = {
         .pointer =      snd_ice1712_capture_pointer,
 };
 
-static int snd_ice1712_pcm(struct snd_ice1712 *ice, int device, struct snd_pcm **rpcm)
+static int snd_ice1712_pcm(struct snd_ice1712 *ice, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(ice->card, "ICE1712 consumer", device, 1, 1, &pcm);
         if (err < 0)
                 return err;
@@ -902,22 +900,17 @@ static int snd_ice1712_pcm(struct snd_ice1712 *ice, int device, struct snd_pcm *
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(ice->pci), 64*1024, 64*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         dev_warn(ice->card->dev,
                  "Consumer PCM code does not work well at the moment --jk\n");
 
         return 0;
 }
 
-static int snd_ice1712_pcm_ds(struct snd_ice1712 *ice, int device, struct snd_pcm **rpcm)
+static int snd_ice1712_pcm_ds(struct snd_ice1712 *ice, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(ice->card, "ICE1712 consumer (DS)", device, 6, 0, &pcm);
         if (err < 0)
                 return err;
@@ -932,9 +925,6 @@ static int snd_ice1712_pcm_ds(struct snd_ice1712 *ice, int device, struct snd_pc
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(ice->pci), 64*1024, 128*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
@@ -1260,13 +1250,11 @@ static struct snd_pcm_ops snd_ice1712_capture_pro_ops = {
         .pointer =      snd_ice1712_capture_pro_pointer,
 };
 
-static int snd_ice1712_pcm_profi(struct snd_ice1712 *ice, int device, struct snd_pcm **rpcm)
+static int snd_ice1712_pcm_profi(struct snd_ice1712 *ice, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(ice->card, "ICE1712 multi", device, 1, 1, &pcm);
         if (err < 0)
                 return err;
@@ -1282,8 +1270,6 @@ static int snd_ice1712_pcm_profi(struct snd_ice1712 *ice, int device, struct snd
                                               snd_dma_pci_data(ice->pci), 256*1024, 256*1024);
 
         ice->pcm_pro = pcm;
-        if (rpcm)
-                *rpcm = pcm;
 
         if (ice->cs8427) {
                 /* assign channels to iec958 */
@@ -2691,14 +2677,14 @@ static int snd_ice1712_probe(struct pci_dev *pci,
         c = &no_matched;
  __found:
 
-        err = snd_ice1712_pcm_profi(ice, pcm_dev++, NULL);
+        err = snd_ice1712_pcm_profi(ice, pcm_dev++);
         if (err < 0) {
                 snd_card_free(card);
                 return err;
         }
 
         if (ice_has_con_ac97(ice)) {
-                err = snd_ice1712_pcm(ice, pcm_dev++, NULL);
+                err = snd_ice1712_pcm(ice, pcm_dev++);
                 if (err < 0) {
                         snd_card_free(card);
                         return err;
@@ -2726,7 +2712,7 @@ static int snd_ice1712_probe(struct pci_dev *pci,
         }
 
         if (ice_has_con_ac97(ice)) {
-                err = snd_ice1712_pcm_ds(ice, pcm_dev++, NULL);
+                err = snd_ice1712_pcm_ds(ice, pcm_dev++);
                 if (err < 0) {
                         snd_card_free(card);
                         return err;
@@ -2798,7 +2784,6 @@ static void snd_ice1712_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_ice1712_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ice1712 *ice = card->private_data;
 
@@ -2820,16 +2805,11 @@ static int snd_ice1712_suspend(struct device *dev)
 
         if (ice->pm_suspend)
                 ice->pm_suspend(ice);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_ice1712_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ice1712 *ice = card->private_data;
         int rate;
@@ -2837,16 +2817,6 @@ static int snd_ice1712_resume(struct device *dev)
         if (!ice->pm_suspend_enabled)
                 return 0;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
-        if (pci_enable_device(pci) < 0) {
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-
-        pci_set_master(pci);
-
         if (ice->cur_rate)
                 rate = ice->cur_rate;
         else
diff --git a/sound/pci/ice1712/ice1724.c b/sound/pci/ice1712/ice1724.c
index d73da157ea14..0b22c00642bb 100644
--- a/sound/pci/ice1712/ice1724.c
+++ b/sound/pci/ice1712/ice1724.c
@@ -2798,7 +2798,6 @@ static void snd_vt1724_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_vt1724_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ice1712 *ice = card->private_data;
 
@@ -2821,32 +2820,17 @@ static int snd_vt1724_suspend(struct device *dev)
 
         if (ice->pm_suspend)
                 ice->pm_suspend(ice);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_vt1724_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ice1712 *ice = card->private_data;
 
         if (!ice->pm_suspend_enabled)
                 return 0;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
-        if (pci_enable_device(pci) < 0) {
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-
-        pci_set_master(pci);
-
         snd_vt1724_chip_reset(ice);
 
         if (snd_vt1724_chip_init(ice) < 0) {
diff --git a/sound/pci/ice1712/juli.c b/sound/pci/ice1712/juli.c
index a1536c1a7ed4..4f0213427152 100644
--- a/sound/pci/ice1712/juli.c
+++ b/sound/pci/ice1712/juli.c
@@ -491,15 +491,17 @@ static int juli_resume(struct snd_ice1712 *ice)
         /* akm4358 un-reset, un-mute */
         snd_akm4xxx_reset(ak, 0);
         /* reinit ak4114 */
-        snd_ak4114_reinit(spec->ak4114);
+        snd_ak4114_resume(spec->ak4114);
         return 0;
 }
 
 static int juli_suspend(struct snd_ice1712 *ice)
 {
         struct snd_akm4xxx *ak = ice->akm;
+        struct juli_spec *spec = ice->spec;
         /* akm4358 reset and soft-mute */
         snd_akm4xxx_reset(ak, 1);
+        snd_ak4114_suspend(spec->ak4114);
         return 0;
 }
 #endif
diff --git a/sound/pci/ice1712/wm8766.c b/sound/pci/ice1712/wm8766.c
index 21b373b2e260..f7ac8d5e862c 100644
--- a/sound/pci/ice1712/wm8766.c
+++ b/sound/pci/ice1712/wm8766.c
@@ -183,22 +183,6 @@ void snd_wm8766_set_if(struct snd_wm8766 *wm, u16 dac)
         snd_wm8766_write(wm, WM8766_REG_IFCTRL, val | dac);
 }
 
-void snd_wm8766_set_master_mode(struct snd_wm8766 *wm, u16 mode)
-{
-        u16 val = wm->regs[WM8766_REG_DACCTRL3] & ~WM8766_DAC3_MSTR_MASK;
-
-        mode &= WM8766_DAC3_MSTR_MASK;
-        snd_wm8766_write(wm, WM8766_REG_DACCTRL3, val | mode);
-}
-
-void snd_wm8766_set_power(struct snd_wm8766 *wm, u16 power)
-{
-        u16 val = wm->regs[WM8766_REG_DACCTRL3] & ~WM8766_DAC3_POWER_MASK;
-
-        power &= WM8766_DAC3_POWER_MASK;
-        snd_wm8766_write(wm, WM8766_REG_DACCTRL3, val | power);
-}
-
 void snd_wm8766_volume_restore(struct snd_wm8766 *wm)
 {
         u16 val = wm->regs[WM8766_REG_DACR1];
diff --git a/sound/pci/ice1712/wm8766.h b/sound/pci/ice1712/wm8766.h
index c119f84bd2c2..18c8d9d47b38 100644
--- a/sound/pci/ice1712/wm8766.h
+++ b/sound/pci/ice1712/wm8766.h
@@ -155,8 +155,6 @@ struct snd_wm8766 {
 void snd_wm8766_init(struct snd_wm8766 *wm);
 void snd_wm8766_resume(struct snd_wm8766 *wm);
 void snd_wm8766_set_if(struct snd_wm8766 *wm, u16 dac);
-void snd_wm8766_set_master_mode(struct snd_wm8766 *wm, u16 mode);
-void snd_wm8766_set_power(struct snd_wm8766 *wm, u16 power);
 void snd_wm8766_volume_restore(struct snd_wm8766 *wm);
 int snd_wm8766_build_controls(struct snd_wm8766 *wm);
 
diff --git a/sound/pci/ice1712/wm8776.c b/sound/pci/ice1712/wm8776.c
index e66c0da62014..ebd2fe4b4a57 100644
--- a/sound/pci/ice1712/wm8776.c
+++ b/sound/pci/ice1712/wm8776.c
@@ -452,21 +452,6 @@ void snd_wm8776_resume(struct snd_wm8776 *wm)
                 snd_wm8776_write(wm, i, wm->regs[i]);
 }
 
-void snd_wm8776_set_dac_if(struct snd_wm8776 *wm, u16 dac)
-{
-        snd_wm8776_write(wm, WM8776_REG_DACIFCTRL, dac);
-}
-
-void snd_wm8776_set_adc_if(struct snd_wm8776 *wm, u16 adc)
-{
-        snd_wm8776_write(wm, WM8776_REG_ADCIFCTRL, adc);
-}
-
-void snd_wm8776_set_master_mode(struct snd_wm8776 *wm, u16 mode)
-{
-        snd_wm8776_write(wm, WM8776_REG_MSTRCTRL, mode);
-}
-
 void snd_wm8776_set_power(struct snd_wm8776 *wm, u16 power)
 {
         snd_wm8776_write(wm, WM8776_REG_PWRDOWN, power);
diff --git a/sound/pci/ice1712/wm8776.h b/sound/pci/ice1712/wm8776.h
index 93a2d6971154..42acef05540c 100644
--- a/sound/pci/ice1712/wm8776.h
+++ b/sound/pci/ice1712/wm8776.h
@@ -216,9 +216,6 @@ struct snd_wm8776 {
 
 void snd_wm8776_init(struct snd_wm8776 *wm);
 void snd_wm8776_resume(struct snd_wm8776 *wm);
-void snd_wm8776_set_dac_if(struct snd_wm8776 *wm, u16 dac);
-void snd_wm8776_set_adc_if(struct snd_wm8776 *wm, u16 adc);
-void snd_wm8776_set_master_mode(struct snd_wm8776 *wm, u16 mode);
 void snd_wm8776_set_power(struct snd_wm8776 *wm, u16 power);
 void snd_wm8776_volume_restore(struct snd_wm8776 *wm);
 int snd_wm8776_build_controls(struct snd_wm8776 *wm);
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index 4a28252a42b9..2c5484eeb963 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -26,7 +26,7 @@
  *
  */      
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -2654,7 +2654,6 @@ static int snd_intel8x0_free(struct intel8x0 *chip)
  */
 static int intel8x0_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct intel8x0 *chip = card->private_data;
         int i;
@@ -2682,12 +2681,6 @@ static int intel8x0_suspend(struct device *dev)
                 free_irq(chip->irq, chip);
                 chip->irq = -1;
         }
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        /* The call below may disable built-in speaker on some laptops
-         * after S2RAM.  So, don't touch it.
-         */
-        /* pci_set_power_state(pci, PCI_D3hot); */
         return 0;
 }
 
@@ -2698,14 +2691,6 @@ static int intel8x0_resume(struct device *dev)
         struct intel8x0 *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
         snd_intel8x0_chip_init(chip, 0);
         if (request_irq(pci->irq, snd_intel8x0_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
diff --git a/sound/pci/intel8x0m.c b/sound/pci/intel8x0m.c
index 6b40235be13c..7577f31cd504 100644
--- a/sound/pci/intel8x0m.c
+++ b/sound/pci/intel8x0m.c
@@ -23,7 +23,7 @@
  *
  */      
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1023,7 +1023,6 @@ static int snd_intel8x0m_free(struct intel8x0m *chip)
  */
 static int intel8x0m_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct intel8x0m *chip = card->private_data;
         int i;
@@ -1036,9 +1035,6 @@ static int intel8x0m_suspend(struct device *dev)
                 free_irq(chip->irq, chip);
                 chip->irq = -1;
         }
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
@@ -1048,14 +1044,6 @@ static int intel8x0m_resume(struct device *dev)
         struct snd_card *card = dev_get_drvdata(dev);
         struct intel8x0m *chip = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
         if (request_irq(pci->irq, snd_intel8x0m_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
                 dev_err(dev, "unable to grab IRQ %d, disabling device\n",
diff --git a/sound/pci/korg1212/korg1212.c b/sound/pci/korg1212/korg1212.c
index 59d21c9401d2..7acbc21d642a 100644
--- a/sound/pci/korg1212/korg1212.c
+++ b/sound/pci/korg1212/korg1212.c
@@ -28,6 +28,7 @@
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/firmware.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/info.h>
@@ -36,8 +37,6 @@
 #include <sound/pcm_params.h>
 #include <sound/initval.h>
 
-#include <asm/io.h>
-
 // ----------------------------------------------------------------------------
 // Debug Stuff
 // ----------------------------------------------------------------------------
@@ -585,8 +584,7 @@ static void snd_korg1212_SendStop(struct snd_korg1212 *korg1212)
                 korg1212->sharedBufferPtr->cardCommand = 0xffffffff;
                 /* program the timer */
                 korg1212->stop_pending_cnt = HZ;
-                korg1212->timer.expires = jiffies + 1;
-                add_timer(&korg1212->timer);
+                mod_timer(&korg1212->timer, jiffies + 1);
         }
 }
 
@@ -617,8 +615,7 @@ static void snd_korg1212_timer_func(unsigned long data)
         } else {
                 if (--korg1212->stop_pending_cnt > 0) {
                         /* reprogram timer */
-                        korg1212->timer.expires = jiffies + 1;
-                        add_timer(&korg1212->timer);
+                        mod_timer(&korg1212->timer, jiffies + 1);
                 } else {
                         snd_printd("korg1212_timer_func timeout\n");
                         korg1212->sharedBufferPtr->cardCommand = 0;
@@ -2172,9 +2169,8 @@ static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci,
         init_waitqueue_head(&korg1212->wait);
         spin_lock_init(&korg1212->lock);
         mutex_init(&korg1212->open_mutex);
-        init_timer(&korg1212->timer);
-        korg1212->timer.function = snd_korg1212_timer_func;
-        korg1212->timer.data = (unsigned long)korg1212;
+        setup_timer(&korg1212->timer, snd_korg1212_timer_func,
+                    (unsigned long)korg1212);
 
         korg1212->irq = -1;
         korg1212->clkSource = K1212_CLKIDX_Local;
diff --git a/sound/pci/lola/lola.c b/sound/pci/lola/lola.c
index 4cf4be5ef82a..9ff600084973 100644
--- a/sound/pci/lola/lola.c
+++ b/sound/pci/lola/lola.c
@@ -551,10 +551,8 @@ static void lola_free(struct lola *chip)
         lola_free_mixer(chip);
         if (chip->irq >= 0)
                 free_irq(chip->irq, (void *)chip);
-        if (chip->bar[0].remap_addr)
-                iounmap(chip->bar[0].remap_addr);
-        if (chip->bar[1].remap_addr)
-                iounmap(chip->bar[1].remap_addr);
+        iounmap(chip->bar[0].remap_addr);
+        iounmap(chip->bar[1].remap_addr);
         if (chip->rb.area)
                 snd_dma_free_pages(&chip->rb);
         pci_release_regions(chip->pci);
diff --git a/sound/pci/maestro3.c b/sound/pci/maestro3.c
index 98823d11d485..9be660993bd0 100644
--- a/sound/pci/maestro3.c
+++ b/sound/pci/maestro3.c
@@ -31,7 +31,7 @@
 #define CARD_NAME "ESS Maestro3/Allegro/Canyon3D-2"
 #define DRIVER_NAME "Maestro3"
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -2395,7 +2395,6 @@ static int snd_m3_free(struct snd_m3 *chip)
 #ifdef CONFIG_PM_SLEEP
 static int m3_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_m3 *chip = card->private_data;
         int i, dsp_index;
@@ -2421,16 +2420,11 @@ static int m3_suspend(struct device *dev)
         for (i = REV_B_DATA_MEMORY_BEGIN ; i <= REV_B_DATA_MEMORY_END; i++)
                 chip->suspend_mem[dsp_index++] =
                         snd_m3_assp_read(chip, MEMTYPE_INTERNAL_DATA, i);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int m3_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_m3 *chip = card->private_data;
         int i, dsp_index;
@@ -2438,15 +2432,6 @@ static int m3_resume(struct device *dev)
         if (chip->suspend_mem == NULL)
                 return 0;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         /* first lets just bring everything back. .*/
         snd_m3_outw(chip, 0, 0x54);
         snd_m3_outw(chip, 0, 0x56);
diff --git a/sound/pci/mixart/mixart.c b/sound/pci/mixart/mixart.c
index 1faf47e81570..c3a9f39f8d61 100644
--- a/sound/pci/mixart/mixart.c
+++ b/sound/pci/mixart/mixart.c
@@ -1114,10 +1114,9 @@ static int snd_mixart_free(struct mixart_mgr *mgr)
         }
 
         /* release the i/o ports */
-        for (i = 0; i < 2; i++) {
-                if (mgr->mem[i].virt)
-                        iounmap(mgr->mem[i].virt);
-        }
+        for (i = 0; i < 2; ++i)
+                iounmap(mgr->mem[i].virt);
+
         pci_release_regions(mgr->pci);
 
         /* free flowarray */
diff --git a/sound/pci/mixart/mixart_core.c b/sound/pci/mixart/mixart_core.c
index fe80313674d9..dccf3db48fe0 100644
--- a/sound/pci/mixart/mixart_core.c
+++ b/sound/pci/mixart/mixart_core.c
@@ -23,8 +23,8 @@
 #include <linux/interrupt.h>
 #include <linux/mutex.h>
 #include <linux/pci.h>
+#include <linux/io.h>
 
-#include <asm/io.h>
 #include <sound/core.h>
 #include "mixart.h"
 #include "mixart_hwdep.h"
diff --git a/sound/pci/mixart/mixart_hwdep.c b/sound/pci/mixart/mixart_hwdep.c
index 9996a4dead0f..5bfd3ac80db5 100644
--- a/sound/pci/mixart/mixart_hwdep.c
+++ b/sound/pci/mixart/mixart_hwdep.c
@@ -26,7 +26,7 @@
 #include <linux/vmalloc.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include "mixart.h"
 #include "mixart_mixer.h"
diff --git a/sound/pci/nm256/nm256.c b/sound/pci/nm256/nm256.c
index 4e41a4e29a1e..4735e27cc773 100644
--- a/sound/pci/nm256/nm256.c
+++ b/sound/pci/nm256/nm256.c
@@ -24,7 +24,7 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
   
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1392,7 +1392,6 @@ snd_nm256_peek_for_sig(struct nm256 *chip)
  */
 static int nm256_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct nm256 *chip = card->private_data;
 
@@ -1400,15 +1399,11 @@ static int nm256_suspend(struct device *dev)
         snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
         chip->coeffs_current = 0;
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int nm256_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct nm256 *chip = card->private_data;
         int i;
@@ -1416,15 +1411,6 @@ static int nm256_resume(struct device *dev)
         /* Perform a full reset on the hardware */
         chip->in_resume = 1;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_nm256_init_chip(chip);
 
         /* restore ac97 */
@@ -1460,10 +1446,8 @@ static int snd_nm256_free(struct nm256 *chip)
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
 
-        if (chip->cport)
-                iounmap(chip->cport);
-        if (chip->buffer)
-                iounmap(chip->buffer);
+        iounmap(chip->cport);
+        iounmap(chip->buffer);
         release_and_free_resource(chip->res_cport);
         release_and_free_resource(chip->res_buffer);
 
diff --git a/sound/pci/oxygen/Makefile b/sound/pci/oxygen/Makefile
index 8f4c409f7e45..ab085d753661 100644
--- a/sound/pci/oxygen/Makefile
+++ b/sound/pci/oxygen/Makefile
@@ -1,8 +1,10 @@
 snd-oxygen-lib-objs := oxygen_io.o oxygen_lib.o oxygen_mixer.o oxygen_pcm.o
 snd-oxygen-objs := oxygen.o xonar_dg_mixer.o xonar_dg.o
+snd-se6x-objs := se6x.o
 snd-virtuoso-objs := virtuoso.o xonar_lib.o \
         xonar_pcm179x.o xonar_cs43xx.o xonar_wm87x6.o xonar_hdmi.o
 
 obj-$(CONFIG_SND_OXYGEN_LIB) += snd-oxygen-lib.o
 obj-$(CONFIG_SND_OXYGEN) += snd-oxygen.o
+obj-$(CONFIG_SND_SE6X) += snd-se6x.o
 obj-$(CONFIG_SND_VIRTUOSO) += snd-virtuoso.o
diff --git a/sound/pci/oxygen/oxygen.h b/sound/pci/oxygen/oxygen.h
index c10ab077afd8..293d0b9a50c3 100644
--- a/sound/pci/oxygen/oxygen.h
+++ b/sound/pci/oxygen/oxygen.h
@@ -35,7 +35,7 @@
 #define CAPTURE_1_FROM_SPDIF    0x0080
 #define CAPTURE_2_FROM_I2S_2    0x0100
 #define CAPTURE_2_FROM_AC97_1   0x0200
-     /* CAPTURE_3_FROM_I2S_3            not implemented */
+#define CAPTURE_3_FROM_I2S_3    0x0400
 #define MIDI_OUTPUT             0x0800
 #define MIDI_INPUT              0x1000
 #define AC97_CD_INPUT           0x2000
diff --git a/sound/pci/oxygen/oxygen_io.c b/sound/pci/oxygen/oxygen_io.c
index 4b8a32c37e31..c7851da37749 100644
--- a/sound/pci/oxygen/oxygen_io.c
+++ b/sound/pci/oxygen/oxygen_io.c
@@ -20,9 +20,9 @@
 #include <linux/delay.h>
 #include <linux/sched.h>
 #include <linux/export.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/mpu401.h>
-#include <asm/io.h>
 #include "oxygen.h"
 
 u8 oxygen_read8(struct oxygen *chip, unsigned int reg)
diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c
index b67e30602473..ffff3b25fd73 100644
--- a/sound/pci/oxygen/oxygen_lib.c
+++ b/sound/pci/oxygen/oxygen_lib.c
@@ -319,11 +319,12 @@ static void oxygen_restore_eeprom(struct oxygen *chip,
 
 static void configure_pcie_bridge(struct pci_dev *pci)
 {
-        enum { PEX811X, PI7C9X110 };
+        enum { PEX811X, PI7C9X110, XIO2001 };
         static const struct pci_device_id bridge_ids[] = {
                 { PCI_VDEVICE(PLX, 0x8111), .driver_data = PEX811X },
                 { PCI_VDEVICE(PLX, 0x8112), .driver_data = PEX811X },
                 { PCI_DEVICE(0x12d8, 0xe110), .driver_data = PI7C9X110 },
+                { PCI_VDEVICE(TI, 0x8240), .driver_data = XIO2001 },
                 { }
         };
         struct pci_dev *bridge;
@@ -357,6 +358,14 @@ static void configure_pcie_bridge(struct pci_dev *pci)
                 tmp |= 1;       /* park the PCI arbiter to the sound chip */
                 pci_write_config_dword(bridge, 0x40, tmp);
                 break;
+
+        case XIO2001: /* Texas Instruments XIO2001 PCIe/PCI bridge */
+                pci_read_config_dword(bridge, 0xe8, &tmp);
+                tmp &= ~0xf;    /* request length limit: 64 bytes */
+                tmp &= ~(0xf << 8);
+                tmp |= 1 << 8;  /* request count limit: one buffer */
+                pci_write_config_dword(bridge, 0xe8, tmp);
+                break;
         }
 }
 
@@ -441,9 +450,18 @@ static void oxygen_init(struct oxygen *chip)
                 oxygen_write16(chip, OXYGEN_I2S_B_FORMAT,
                                OXYGEN_I2S_MASTER |
                                OXYGEN_I2S_MUTE_MCLK);
-        oxygen_write16(chip, OXYGEN_I2S_C_FORMAT,
-                       OXYGEN_I2S_MASTER |
-                       OXYGEN_I2S_MUTE_MCLK);
+        if (chip->model.device_config & CAPTURE_3_FROM_I2S_3)
+                oxygen_write16(chip, OXYGEN_I2S_C_FORMAT,
+                               OXYGEN_RATE_48000 |
+                               chip->model.adc_i2s_format |
+                               OXYGEN_I2S_MCLK(chip->model.adc_mclks) |
+                               OXYGEN_I2S_BITS_16 |
+                               OXYGEN_I2S_MASTER |
+                               OXYGEN_I2S_BCLK_64);
+        else
+                oxygen_write16(chip, OXYGEN_I2S_C_FORMAT,
+                               OXYGEN_I2S_MASTER |
+                               OXYGEN_I2S_MUTE_MCLK);
         oxygen_clear_bits32(chip, OXYGEN_SPDIF_CONTROL,
                             OXYGEN_SPDIF_OUT_ENABLE |
                             OXYGEN_SPDIF_LOOPBACK);
@@ -728,7 +746,6 @@ EXPORT_SYMBOL(oxygen_pci_remove);
 #ifdef CONFIG_PM_SLEEP
 static int oxygen_pci_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct oxygen *chip = card->private_data;
         unsigned int i, saved_interrupt_mask;
@@ -736,8 +753,7 @@ static int oxygen_pci_suspend(struct device *dev)
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 
         for (i = 0; i < PCM_COUNT; ++i)
-                if (chip->streams[i])
-                        snd_pcm_suspend(chip->streams[i]);
+                snd_pcm_suspend(chip->streams[i]);
 
         if (chip->model.suspend)
                 chip->model.suspend(chip);
@@ -753,10 +769,6 @@ static int oxygen_pci_suspend(struct device *dev)
         flush_work(&chip->spdif_input_bits_work);
         flush_work(&chip->gpio_work);
         chip->interrupt_mask = saved_interrupt_mask;
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
@@ -788,20 +800,10 @@ static void oxygen_restore_ac97(struct oxygen *chip, unsigned int codec)
 
 static int oxygen_pci_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct oxygen *chip = card->private_data;
         unsigned int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "cannot reenable device");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         oxygen_write16(chip, OXYGEN_DMA_STATUS, 0);
         oxygen_write16(chip, OXYGEN_INTERRUPT_MASK, 0);
         for (i = 0; i < OXYGEN_IO_SIZE; ++i)
diff --git a/sound/pci/oxygen/oxygen_mixer.c b/sound/pci/oxygen/oxygen_mixer.c
index 5988e044c519..6492bca8c70f 100644
--- a/sound/pci/oxygen/oxygen_mixer.c
+++ b/sound/pci/oxygen/oxygen_mixer.c
@@ -786,6 +786,9 @@ static const struct snd_kcontrol_new controls[] = {
                 .get = upmix_get,
                 .put = upmix_put,
         },
+};
+
+static const struct snd_kcontrol_new spdif_output_controls[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
@@ -938,6 +941,33 @@ static const struct {
                 },
         },
         {
+                .pcm_dev = CAPTURE_3_FROM_I2S_3,
+                .controls = {
+                        {
+                                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                                .name = "Analog Input Monitor Playback Switch",
+                                .index = 2,
+                                .info = snd_ctl_boolean_mono_info,
+                                .get = monitor_get,
+                                .put = monitor_put,
+                                .private_value = OXYGEN_ADC_MONITOR_C,
+                        },
+                        {
+                                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                                .name = "Analog Input Monitor Playback Volume",
+                                .index = 2,
+                                .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                                          SNDRV_CTL_ELEM_ACCESS_TLV_READ,
+                                .info = monitor_volume_info,
+                                .get = monitor_get,
+                                .put = monitor_put,
+                                .private_value = OXYGEN_ADC_MONITOR_C_HALF_VOL
+                                                | (1 << 8),
+                                .tlv = { .p = monitor_db_scale, },
+                        },
+                },
+        },
+        {
                 .pcm_dev = CAPTURE_1_FROM_SPDIF,
                 .controls = {
                         {
@@ -1073,6 +1103,12 @@ int oxygen_mixer_init(struct oxygen *chip)
         err = add_controls(chip, controls, ARRAY_SIZE(controls));
         if (err < 0)
                 return err;
+        if (chip->model.device_config & PLAYBACK_1_TO_SPDIF) {
+                err = add_controls(chip, spdif_output_controls,
+                                   ARRAY_SIZE(spdif_output_controls));
+                if (err < 0)
+                        return err;
+        }
         if (chip->model.device_config & CAPTURE_1_FROM_SPDIF) {
                 err = add_controls(chip, spdif_input_controls,
                                    ARRAY_SIZE(spdif_input_controls));
diff --git a/sound/pci/oxygen/oxygen_pcm.c b/sound/pci/oxygen/oxygen_pcm.c
index 02828240ba15..aa2ebd1d6d12 100644
--- a/sound/pci/oxygen/oxygen_pcm.c
+++ b/sound/pci/oxygen/oxygen_pcm.c
@@ -144,9 +144,11 @@ static int oxygen_open(struct snd_pcm_substream *substream,
                 runtime->hw = *oxygen_hardware[channel];
         switch (channel) {
         case PCM_C:
-                runtime->hw.rates &= ~(SNDRV_PCM_RATE_32000 |
-                                       SNDRV_PCM_RATE_64000);
-                runtime->hw.rate_min = 44100;
+                if (chip->model.device_config & CAPTURE_1_FROM_SPDIF) {
+                        runtime->hw.rates &= ~(SNDRV_PCM_RATE_32000 |
+                                               SNDRV_PCM_RATE_64000);
+                        runtime->hw.rate_min = 44100;
+                }
                 /* fall through */
         case PCM_A:
         case PCM_B:
@@ -430,17 +432,36 @@ static int oxygen_rec_c_hw_params(struct snd_pcm_substream *substream,
                                   struct snd_pcm_hw_params *hw_params)
 {
         struct oxygen *chip = snd_pcm_substream_chip(substream);
+        bool is_spdif;
         int err;
 
         err = oxygen_hw_params(substream, hw_params);
         if (err < 0)
                 return err;
 
+        is_spdif = chip->model.device_config & CAPTURE_1_FROM_SPDIF;
+
         spin_lock_irq(&chip->reg_lock);
         oxygen_write8_masked(chip, OXYGEN_REC_FORMAT,
                              oxygen_format(hw_params) << OXYGEN_REC_FORMAT_C_SHIFT,
                              OXYGEN_REC_FORMAT_C_MASK);
+        if (!is_spdif)
+                oxygen_write16_masked(chip, OXYGEN_I2S_C_FORMAT,
+                                      oxygen_rate(hw_params) |
+                                      chip->model.adc_i2s_format |
+                                      get_mclk(chip, PCM_B, hw_params) |
+                                      oxygen_i2s_bits(hw_params),
+                                      OXYGEN_I2S_RATE_MASK |
+                                      OXYGEN_I2S_FORMAT_MASK |
+                                      OXYGEN_I2S_MCLK_MASK |
+                                      OXYGEN_I2S_BITS_MASK);
         spin_unlock_irq(&chip->reg_lock);
+
+        if (!is_spdif) {
+                mutex_lock(&chip->mutex);
+                chip->model.set_adc_params(chip, hw_params);
+                mutex_unlock(&chip->mutex);
+        }
         return 0;
 }
 
@@ -676,11 +697,6 @@ static struct snd_pcm_ops oxygen_ac97_ops = {
         .pointer   = oxygen_pointer,
 };
 
-static void oxygen_pcm_free(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 int oxygen_pcm_init(struct oxygen *chip)
 {
         struct snd_pcm *pcm;
@@ -705,7 +721,6 @@ int oxygen_pcm_init(struct oxygen *chip)
                         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
                                         &oxygen_rec_b_ops);
                 pcm->private_data = chip;
-                pcm->private_free = oxygen_pcm_free;
                 strcpy(pcm->name, "Multichannel");
                 if (outs)
                         snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream,
@@ -734,7 +749,6 @@ int oxygen_pcm_init(struct oxygen *chip)
                         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
                                         &oxygen_rec_c_ops);
                 pcm->private_data = chip;
-                pcm->private_free = oxygen_pcm_free;
                 strcpy(pcm->name, "Digital");
                 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                                       snd_dma_pci_data(chip->pci),
@@ -765,12 +779,29 @@ int oxygen_pcm_init(struct oxygen *chip)
                         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
                                         &oxygen_rec_b_ops);
                 pcm->private_data = chip;
-                pcm->private_free = oxygen_pcm_free;
                 strcpy(pcm->name, outs ? "Front Panel" : "Analog 2");
                 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                                       snd_dma_pci_data(chip->pci),
                                                       DEFAULT_BUFFER_BYTES,
                                                       BUFFER_BYTES_MAX);
         }
+
+        ins = !!(chip->model.device_config & CAPTURE_3_FROM_I2S_3);
+        if (ins) {
+                err = snd_pcm_new(chip->card, "Analog3", 3, 0, ins, &pcm);
+                if (err < 0)
+                        return err;
+                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
+                                &oxygen_rec_c_ops);
+                oxygen_write8_masked(chip, OXYGEN_REC_ROUTING,
+                                     OXYGEN_REC_C_ROUTE_I2S_ADC_3,
+                                     OXYGEN_REC_C_ROUTE_MASK);
+                pcm->private_data = chip;
+                strcpy(pcm->name, "Analog 3");
+                snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                                      snd_dma_pci_data(chip->pci),
+                                                      DEFAULT_BUFFER_BYTES,
+                                                      BUFFER_BYTES_MAX);
+        }
         return 0;
 }
diff --git a/sound/pci/oxygen/se6x.c b/sound/pci/oxygen/se6x.c
new file mode 100644
index 000000000000..f70d514c1084
--- /dev/null
+++ b/sound/pci/oxygen/se6x.c
@@ -0,0 +1,160 @@
+/*
+ * C-Media CMI8787 driver for the Studio Evolution SE6X
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ *
+ *  This driver is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License, version 2.
+ *
+ *  This driver 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 driver; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * CMI8787:
+ *
+ *   SPI    -> microcontroller (not actually used)
+ *   GPIO 0 -> do.
+ *   GPIO 2 -> do.
+ *
+ *   DAC0   -> both PCM1792A (L+R, each in mono mode)
+ *   ADC1  <-  1st PCM1804
+ *   ADC2  <-  2nd PCM1804
+ *   ADC3  <-  3rd PCM1804
+ */
+
+#include <linux/pci.h>
+#include <linux/module.h>
+#include <sound/core.h>
+#include <sound/control.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include "oxygen.h"
+
+MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
+MODULE_DESCRIPTION("Studio Evolution SE6X driver");
+MODULE_LICENSE("GPL v2");
+MODULE_SUPPORTED_DEVICE("{{Studio Evolution,SE6X}}");
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
+static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
+static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
+
+module_param_array(index, int, NULL, 0444);
+MODULE_PARM_DESC(index, "card index");
+module_param_array(id, charp, NULL, 0444);
+MODULE_PARM_DESC(id, "ID string");
+module_param_array(enable, bool, NULL, 0444);
+MODULE_PARM_DESC(enable, "enable card");
+
+static const struct pci_device_id se6x_ids[] = {
+        { OXYGEN_PCI_SUBID(0x13f6, 0x8788) },
+        { }
+};
+MODULE_DEVICE_TABLE(pci, se6x_ids);
+
+static void se6x_init(struct oxygen *chip)
+{
+        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, 0x005);
+
+        snd_component_add(chip->card, "PCM1792A");
+        snd_component_add(chip->card, "PCM1804");
+}
+
+static int se6x_control_filter(struct snd_kcontrol_new *template)
+{
+        /* no DAC volume/mute */
+        if (!strncmp(template->name, "Master Playback ", 16))
+                return 1;
+        return 0;
+}
+
+static void se6x_cleanup(struct oxygen *chip)
+{
+}
+
+static void set_pcm1792a_params(struct oxygen *chip,
+                                struct snd_pcm_hw_params *params)
+{
+        /* nothing to do (the microcontroller monitors DAC_LRCK) */
+}
+
+static void set_pcm1804_params(struct oxygen *chip,
+                               struct snd_pcm_hw_params *params)
+{
+}
+
+static unsigned int se6x_adjust_dac_routing(struct oxygen *chip,
+                                            unsigned int play_routing)
+{
+        /* route the same stereo pair to DAC0 and DAC1 */
+        return ( play_routing       & OXYGEN_PLAY_DAC0_SOURCE_MASK) |
+               ((play_routing << 2) & OXYGEN_PLAY_DAC1_SOURCE_MASK);
+}
+
+static const struct oxygen_model model_se6x = {
+        .shortname = "Studio Evolution SE6X",
+        .longname = "C-Media Oxygen HD Audio",
+        .chip = "CMI8787",
+        .init = se6x_init,
+        .control_filter = se6x_control_filter,
+        .cleanup = se6x_cleanup,
+        .set_dac_params = set_pcm1792a_params,
+        .set_adc_params = set_pcm1804_params,
+        .adjust_dac_routing = se6x_adjust_dac_routing,
+        .device_config = PLAYBACK_0_TO_I2S |
+                         CAPTURE_0_FROM_I2S_1 |
+                         CAPTURE_2_FROM_I2S_2 |
+                         CAPTURE_3_FROM_I2S_3,
+        .dac_channels_pcm = 2,
+        .function_flags = OXYGEN_FUNCTION_SPI,
+        .dac_mclks = OXYGEN_MCLKS(256, 128, 128),
+        .adc_mclks = OXYGEN_MCLKS(256, 256, 128),
+        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+        .adc_i2s_format = OXYGEN_I2S_FORMAT_I2S,
+};
+
+static int se6x_get_model(struct oxygen *chip,
+                          const struct pci_device_id *pci_id)
+{
+        chip->model = model_se6x;
+        return 0;
+}
+
+static int se6x_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
+{
+        static int dev;
+        int err;
+
+        if (dev >= SNDRV_CARDS)
+                return -ENODEV;
+        if (!enable[dev]) {
+                ++dev;
+                return -ENOENT;
+        }
+        err = oxygen_pci_probe(pci, index[dev], id[dev], THIS_MODULE,
+                               se6x_ids, se6x_get_model);
+        if (err >= 0)
+                ++dev;
+        return err;
+}
+
+static struct pci_driver se6x_driver = {
+        .name = KBUILD_MODNAME,
+        .id_table = se6x_ids,
+        .probe = se6x_probe,
+        .remove = oxygen_pci_remove,
+#ifdef CONFIG_PM_SLEEP
+        .driver = {
+                .pm = &oxygen_pci_pm,
+        },
+#endif
+        .shutdown = oxygen_pci_shutdown,
+};
+
+module_pci_driver(se6x_driver);
diff --git a/sound/pci/pcxhr/pcxhr_core.c b/sound/pci/pcxhr/pcxhr_core.c
index 181f7729d409..c5194f5b150a 100644
--- a/sound/pci/pcxhr/pcxhr_core.c
+++ b/sound/pci/pcxhr/pcxhr_core.c
@@ -24,7 +24,7 @@
 #include <linux/firmware.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include "pcxhr.h"
 #include "pcxhr_mixer.h"
diff --git a/sound/pci/pcxhr/pcxhr_hwdep.c b/sound/pci/pcxhr/pcxhr_hwdep.c
index 15a8ce5f1f48..80633055e17e 100644
--- a/sound/pci/pcxhr/pcxhr_hwdep.c
+++ b/sound/pci/pcxhr/pcxhr_hwdep.c
@@ -25,7 +25,7 @@
 #include <linux/firmware.h>
 #include <linux/pci.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/hwdep.h>
 #include "pcxhr.h"
diff --git a/sound/pci/riptide/riptide.c b/sound/pci/riptide/riptide.c
index 6abc2ac8fffb..94639d6b5fb5 100644
--- a/sound/pci/riptide/riptide.c
+++ b/sound/pci/riptide/riptide.c
@@ -99,7 +99,7 @@
 #include <linux/firmware.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -1153,7 +1153,6 @@ static void riptide_handleirq(unsigned long dev_id)
 #ifdef CONFIG_PM_SLEEP
 static int riptide_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_riptide *chip = card->private_data;
 
@@ -1161,27 +1160,14 @@ static int riptide_suspend(struct device *dev)
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
         snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int riptide_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_riptide *chip = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "riptide: pci_enable_device failed, "
-                       "disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
         snd_riptide_initialize(chip);
         snd_ac97_resume(chip->ac97);
         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
@@ -1706,14 +1692,11 @@ static struct snd_pcm_ops snd_riptide_capture_ops = {
         .pointer = snd_riptide_pointer,
 };
 
-static int
-snd_riptide_pcm(struct snd_riptide *chip, int device, struct snd_pcm **rpcm)
+static int snd_riptide_pcm(struct snd_riptide *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err =
              snd_pcm_new(chip->card, "RIPTIDE", device, PLAYBACK_SUBSTREAMS, 1,
                          &pcm)) < 0)
@@ -1729,8 +1712,6 @@ snd_riptide_pcm(struct snd_riptide *chip, int device, struct snd_pcm **rpcm)
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
                                               snd_dma_pci_data(chip->pci),
                                               64 * 1024, 128 * 1024);
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -2030,32 +2011,43 @@ snd_riptide_joystick_probe(struct pci_dev *pci, const struct pci_device_id *id)
 {
         static int dev;
         struct gameport *gameport;
+        int ret;
 
         if (dev >= SNDRV_CARDS)
                 return -ENODEV;
+
         if (!enable[dev]) {
-                dev++;
-                return -ENOENT;
+                ret = -ENOENT;
+                goto inc_dev;
         }
 
-        if (!joystick_port[dev++])
-                return 0;
+        if (!joystick_port[dev]) {
+                ret = 0;
+                goto inc_dev;
+        }
 
         gameport = gameport_allocate_port();
-        if (!gameport)
-                return -ENOMEM;
+        if (!gameport) {
+                ret = -ENOMEM;
+                goto inc_dev;
+        }
         if (!request_region(joystick_port[dev], 8, "Riptide gameport")) {
                 snd_printk(KERN_WARNING
                            "Riptide: cannot grab gameport 0x%x\n",
                            joystick_port[dev]);
                 gameport_free_port(gameport);
-                return -EBUSY;
+                ret = -EBUSY;
+                goto inc_dev;
         }
 
         gameport->io = joystick_port[dev];
         gameport_register_port(gameport);
         pci_set_drvdata(pci, gameport);
-        return 0;
+
+        ret = 0;
+inc_dev:
+        dev++;
+        return ret;
 }
 
 static void snd_riptide_joystick_remove(struct pci_dev *pci)
@@ -2092,7 +2084,7 @@ snd_card_riptide_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
         if (err < 0)
                 goto error;
         card->private_data = chip;
-        err = snd_riptide_pcm(chip, 0, NULL);
+        err = snd_riptide_pcm(chip, 0);
         if (err < 0)
                 goto error;
         err = snd_riptide_mixer(chip);
diff --git a/sound/pci/rme32.c b/sound/pci/rme32.c
index 6c60dcd2e5a1..23d7f5d30c41 100644
--- a/sound/pci/rme32.c
+++ b/sound/pci/rme32.c
@@ -75,6 +75,7 @@
 #include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/module.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/info.h>
@@ -85,8 +86,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 
-#include <asm/io.h>
-
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;     /* Enable this card */
@@ -632,7 +631,7 @@ snd_rme32_setframelog(struct rme32 * rme32, int n_channels, int is_playback)
         }
 }
 
-static int snd_rme32_setformat(struct rme32 * rme32, int format)
+static int snd_rme32_setformat(struct rme32 *rme32, snd_pcm_format_t format)
 {
         switch (format) {
         case SNDRV_PCM_FORMAT_S16_LE:
diff --git a/sound/pci/rme96.c b/sound/pci/rme96.c
index 2f1a85185a16..2306ccf7281e 100644
--- a/sound/pci/rme96.c
+++ b/sound/pci/rme96.c
@@ -29,6 +29,7 @@
 #include <linux/pci.h>
 #include <linux/module.h>
 #include <linux/vmalloc.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/info.h>
@@ -38,8 +39,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 
-#include <asm/io.h>
-
 /* note, two last pcis should be equal, it is not a bug */
 
 MODULE_AUTHOR("Anders Torger <torger@ludd.luth.se>");
@@ -922,8 +921,7 @@ snd_rme96_setframelog(struct rme96 *rme96,
 }
 
 static int
-snd_rme96_playback_setformat(struct rme96 *rme96,
-                             int format)
+snd_rme96_playback_setformat(struct rme96 *rme96, snd_pcm_format_t format)
 {
         switch (format) {
         case SNDRV_PCM_FORMAT_S16_LE:
@@ -940,8 +938,7 @@ snd_rme96_playback_setformat(struct rme96 *rme96,
 }
 
 static int
-snd_rme96_capture_setformat(struct rme96 *rme96,
-                            int format)
+snd_rme96_capture_setformat(struct rme96 *rme96, snd_pcm_format_t format)
 {
         switch (format) {
         case SNDRV_PCM_FORMAT_S16_LE:
@@ -2358,7 +2355,6 @@ snd_rme96_create_switches(struct snd_card *card,
 
 static int rme96_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct rme96 *rme96 = card->private_data;
 
@@ -2381,26 +2377,14 @@ static int rme96_suspend(struct device *dev)
         /* disable the DAC  */
         rme96->areg &= ~RME96_AR_DAC_EN;
         writel(rme96->areg, rme96->iobase + RME96_IO_ADDITIONAL_REG);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-
         return 0;
 }
 
 static int rme96_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct rme96 *rme96 = card->private_data;
 
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-
         /* reset playback and record buffer pointers */
         writel(0, rme96->iobase + RME96_IO_SET_PLAY_POS
                   + rme96->playback_pointer);
diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c
index cf5a6c8b9a63..c19e021ccf66 100644
--- a/sound/pci/rme9652/hdsp.c
+++ b/sound/pci/rme9652/hdsp.c
@@ -29,6 +29,7 @@
 #include <linux/module.h>
 #include <linux/math64.h>
 #include <linux/vmalloc.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -42,7 +43,6 @@
 
 #include <asm/byteorder.h>
 #include <asm/current.h>
-#include <asm/io.h>
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
@@ -1428,10 +1428,8 @@ static void snd_hdsp_midi_output_timer(unsigned long data)
            leaving istimer wherever it was set before.
         */
 
-        if (hmidi->istimer) {
-                hmidi->timer.expires = 1 + jiffies;
-                add_timer(&hmidi->timer);
-        }
+        if (hmidi->istimer)
+                mod_timer(&hmidi->timer, 1 + jiffies);
 
         spin_unlock_irqrestore (&hmidi->lock, flags);
 }
@@ -1445,11 +1443,9 @@ static void snd_hdsp_midi_output_trigger(struct snd_rawmidi_substream *substream
         spin_lock_irqsave (&hmidi->lock, flags);
         if (up) {
                 if (!hmidi->istimer) {
-                        init_timer(&hmidi->timer);
-                        hmidi->timer.function = snd_hdsp_midi_output_timer;
-                        hmidi->timer.data = (unsigned long) hmidi;
-                        hmidi->timer.expires = 1 + jiffies;
-                        add_timer(&hmidi->timer);
+                        setup_timer(&hmidi->timer, snd_hdsp_midi_output_timer,
+                                    (unsigned long) hmidi);
+                        mod_timer(&hmidi->timer, 1 + jiffies);
                         hmidi->istimer++;
                 }
         } else {
@@ -5309,9 +5305,7 @@ static int snd_hdsp_free(struct hdsp *hdsp)
 
         release_firmware(hdsp->firmware);
         vfree(hdsp->fw_uploaded);
-
-        if (hdsp->iobase)
-                iounmap(hdsp->iobase);
+        iounmap(hdsp->iobase);
 
         if (hdsp->port)
                 pci_release_regions(hdsp->pci);
diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index 3342705a5715..ca67f896d117 100644
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -136,7 +136,7 @@
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/math64.h>
-#include <asm/io.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -1957,10 +1957,8 @@ static void snd_hdspm_midi_output_timer(unsigned long data)
            leaving istimer wherever it was set before.
         */
 
-        if (hmidi->istimer) {
-                hmidi->timer.expires = 1 + jiffies;
-                add_timer(&hmidi->timer);
-        }
+        if (hmidi->istimer)
+                mod_timer(&hmidi->timer, 1 + jiffies);
 
         spin_unlock_irqrestore (&hmidi->lock, flags);
 }
@@ -1975,11 +1973,9 @@ snd_hdspm_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
         spin_lock_irqsave (&hmidi->lock, flags);
         if (up) {
                 if (!hmidi->istimer) {
-                        init_timer(&hmidi->timer);
-                        hmidi->timer.function = snd_hdspm_midi_output_timer;
-                        hmidi->timer.data = (unsigned long) hmidi;
-                        hmidi->timer.expires = 1 + jiffies;
-                        add_timer(&hmidi->timer);
+                        setup_timer(&hmidi->timer, snd_hdspm_midi_output_timer,
+                                    (unsigned long) hmidi);
+                        mod_timer(&hmidi->timer, 1 + jiffies);
                         hmidi->istimer++;
                 }
         } else {
@@ -6086,6 +6082,9 @@ static int snd_hdspm_playback_open(struct snd_pcm_substream *substream)
                 snd_pcm_hw_constraint_minmax(runtime,
                                              SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
                                              64, 8192);
+                snd_pcm_hw_constraint_minmax(runtime,
+                                             SNDRV_PCM_HW_PARAM_PERIODS,
+                                             2, 2);
                 break;
         }
 
@@ -6160,6 +6159,9 @@ static int snd_hdspm_capture_open(struct snd_pcm_substream *substream)
                 snd_pcm_hw_constraint_minmax(runtime,
                                              SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
                                              64, 8192);
+                snd_pcm_hw_constraint_minmax(runtime,
+                                             SNDRV_PCM_HW_PARAM_PERIODS,
+                                             2, 2);
                 break;
         }
 
@@ -6965,9 +6967,7 @@ static int snd_hdspm_free(struct hdspm * hdspm)
                 free_irq(hdspm->irq, (void *) hdspm);
 
         kfree(hdspm->mixer);
-
-        if (hdspm->iobase)
-                iounmap(hdspm->iobase);
+        iounmap(hdspm->iobase);
 
         if (hdspm->port)
                 pci_release_regions(hdspm->pci);
diff --git a/sound/pci/rme9652/rme9652.c b/sound/pci/rme9652/rme9652.c
index 6521521853b8..fdbc0aa2776a 100644
--- a/sound/pci/rme9652/rme9652.c
+++ b/sound/pci/rme9652/rme9652.c
@@ -25,6 +25,7 @@
 #include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/module.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -34,7 +35,6 @@
 #include <sound/initval.h>
 
 #include <asm/current.h>
-#include <asm/io.h>
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
@@ -1756,8 +1756,7 @@ static int snd_rme9652_free(struct snd_rme9652 *rme9652)
 
         if (rme9652->irq >= 0)
                 free_irq(rme9652->irq, (void *)rme9652);
-        if (rme9652->iobase)
-                iounmap(rme9652->iobase);
+        iounmap(rme9652->iobase);
         if (rme9652->port)
                 pci_release_regions(rme9652->pci);
 
diff --git a/sound/pci/sis7019.c b/sound/pci/sis7019.c
index 7f6a0a0d115a..efe669b80256 100644
--- a/sound/pci/sis7019.c
+++ b/sound/pci/sis7019.c
@@ -1064,12 +1064,9 @@ static int sis_chip_free(struct sis7019 *sis)
         if (sis->irq >= 0)
                 free_irq(sis->irq, sis);
 
-        if (sis->ioaddr)
-                iounmap(sis->ioaddr);
-
+        iounmap(sis->ioaddr);
         pci_release_regions(sis->pci);
         pci_disable_device(sis->pci);
-
         sis_free_suspend(sis);
         return 0;
 }
@@ -1211,7 +1208,6 @@ static int sis_chip_init(struct sis7019 *sis)
 #ifdef CONFIG_PM_SLEEP
 static int sis_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct sis7019 *sis = card->private_data;
         void __iomem *ioaddr = sis->ioaddr;
@@ -1240,9 +1236,6 @@ static int sis_suspend(struct device *dev)
                 ioaddr += 4096;
         }
 
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
@@ -1254,14 +1247,6 @@ static int sis_resume(struct device *dev)
         void __iomem *ioaddr = sis->ioaddr;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
-        if (pci_enable_device(pci) < 0) {
-                dev_err(&pci->dev, "unable to re-enable device\n");
-                goto error;
-        }
-
         if (sis_chip_init(sis)) {
                 dev_err(&pci->dev, "unable to re-init controller\n");
                 goto error;
@@ -1284,7 +1269,6 @@ static int sis_resume(struct device *dev)
         memset(sis->suspend_state[0], 0, 4096);
 
         sis->irq = pci->irq;
-        pci_set_master(pci);
 
         if (sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT)
                 snd_ac97_resume(sis->ac97[0]);
diff --git a/sound/pci/sonicvibes.c b/sound/pci/sonicvibes.c
index 313a7328bf9c..0f40624a4275 100644
--- a/sound/pci/sonicvibes.c
+++ b/sound/pci/sonicvibes.c
@@ -30,6 +30,7 @@
 #include <linux/gameport.h>
 #include <linux/module.h>
 #include <linux/dma-mapping.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -39,8 +40,6 @@
 #include <sound/opl3.h>
 #include <sound/initval.h>
 
-#include <asm/io.h>
-
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 MODULE_DESCRIPTION("S3 SonicVibes PCI");
 MODULE_LICENSE("GPL");
@@ -880,8 +879,7 @@ static struct snd_pcm_ops snd_sonicvibes_capture_ops = {
         .pointer =      snd_sonicvibes_capture_pointer,
 };
 
-static int snd_sonicvibes_pcm(struct sonicvibes *sonic, int device,
-                              struct snd_pcm **rpcm)
+static int snd_sonicvibes_pcm(struct sonicvibes *sonic, int device)
 {
         struct snd_pcm *pcm;
         int err;
@@ -902,8 +900,6 @@ static int snd_sonicvibes_pcm(struct sonicvibes *sonic, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(sonic->pci), 64*1024, 128*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -1491,7 +1487,7 @@ static int snd_sonic_probe(struct pci_dev *pci,
                 (unsigned long long)pci_resource_start(pci, 1),
                 sonic->irq);
 
-        if ((err = snd_sonicvibes_pcm(sonic, 0, NULL)) < 0) {
+        if ((err = snd_sonicvibes_pcm(sonic, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
diff --git a/sound/pci/trident/trident.c b/sound/pci/trident/trident.c
index a54cd6879b31..cedf13b64803 100644
--- a/sound/pci/trident/trident.c
+++ b/sound/pci/trident/trident.c
@@ -127,21 +127,21 @@ static int snd_trident_probe(struct pci_dev *pci,
         sprintf(card->longname, "%s PCI Audio at 0x%lx, irq %d",
                 card->shortname, trident->port, trident->irq);
 
-        if ((err = snd_trident_pcm(trident, pcm_dev++, NULL)) < 0) {
+        if ((err = snd_trident_pcm(trident, pcm_dev++)) < 0) {
                 snd_card_free(card);
                 return err;
         }
         switch (trident->device) {
         case TRIDENT_DEVICE_ID_DX:
         case TRIDENT_DEVICE_ID_NX:
-                if ((err = snd_trident_foldback_pcm(trident, pcm_dev++, NULL)) < 0) {
+                if ((err = snd_trident_foldback_pcm(trident, pcm_dev++)) < 0) {
                         snd_card_free(card);
                         return err;
                 }
                 break;
         }
         if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
-                if ((err = snd_trident_spdif_pcm(trident, pcm_dev++, NULL)) < 0) {
+                if ((err = snd_trident_spdif_pcm(trident, pcm_dev++)) < 0) {
                         snd_card_free(card);
                         return err;
                 }
diff --git a/sound/pci/trident/trident.h b/sound/pci/trident/trident.h
index 5f110eb56e47..9624e5937719 100644
--- a/sound/pci/trident/trident.h
+++ b/sound/pci/trident/trident.h
@@ -420,9 +420,9 @@ int snd_trident_create(struct snd_card *card,
                        struct snd_trident ** rtrident);
 int snd_trident_create_gameport(struct snd_trident *trident);
 
-int snd_trident_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm);
-int snd_trident_foldback_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm);
-int snd_trident_spdif_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm);
+int snd_trident_pcm(struct snd_trident *trident, int device);
+int snd_trident_foldback_pcm(struct snd_trident *trident, int device);
+int snd_trident_spdif_pcm(struct snd_trident *trident, int device);
 int snd_trident_attach_synthesizer(struct snd_trident * trident);
 struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type,
                                              int client, int port);
diff --git a/sound/pci/trident/trident_main.c b/sound/pci/trident/trident_main.c
index 57cd757acfe7..b72be035f785 100644
--- a/sound/pci/trident/trident_main.c
+++ b/sound/pci/trident/trident_main.c
@@ -36,6 +36,7 @@
 #include <linux/gameport.h>
 #include <linux/dma-mapping.h>
 #include <linux/export.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/info.h>
@@ -44,8 +45,6 @@
 #include "trident.h"
 #include <sound/asoundef.h>
 
-#include <asm/io.h>
-
 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
                                        struct snd_trident_voice * voice,
                                        struct snd_pcm_substream *substream);
@@ -2172,14 +2171,11 @@ static struct snd_pcm_ops snd_trident_spdif_7018_ops = {
   
   ---------------------------------------------------------------------------*/
 
-int snd_trident_pcm(struct snd_trident *trident,
-                    int device, struct snd_pcm **rpcm)
+int snd_trident_pcm(struct snd_trident *trident, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm)) < 0)
                 return err;
 
@@ -2214,8 +2210,6 @@ int snd_trident_pcm(struct snd_trident *trident,
                                                       snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
         }
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -2230,16 +2224,13 @@ int snd_trident_pcm(struct snd_trident *trident,
   
   ---------------------------------------------------------------------------*/
 
-int snd_trident_foldback_pcm(struct snd_trident *trident,
-                             int device, struct snd_pcm **rpcm)
+int snd_trident_foldback_pcm(struct snd_trident *trident, int device)
 {
         struct snd_pcm *foldback;
         int err;
         int num_chan = 3;
         struct snd_pcm_substream *substream;
 
-        if (rpcm)
-                *rpcm = NULL;
         if (trident->device == TRIDENT_DEVICE_ID_NX)
                 num_chan = 4;
         if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback)) < 0)
@@ -2271,8 +2262,6 @@ int snd_trident_foldback_pcm(struct snd_trident *trident,
                 snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV,
                                                       snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
 
-        if (rpcm)
-                *rpcm = foldback;
         return 0;
 }
 
@@ -2287,14 +2276,11 @@ int snd_trident_foldback_pcm(struct snd_trident *trident,
   
   ---------------------------------------------------------------------------*/
 
-int snd_trident_spdif_pcm(struct snd_trident *trident,
-                          int device, struct snd_pcm **rpcm)
+int snd_trident_spdif_pcm(struct snd_trident *trident, int device)
 {
         struct snd_pcm *spdif;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif)) < 0)
                 return err;
 
@@ -2310,8 +2296,6 @@ int snd_trident_spdif_pcm(struct snd_trident *trident,
 
         snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
 
-        if (rpcm)
-                *rpcm = spdif;
         return 0;
 }
 
@@ -3926,7 +3910,6 @@ static void snd_trident_clear_voices(struct snd_trident * trident, unsigned shor
 #ifdef CONFIG_PM_SLEEP
 static int snd_trident_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_trident *trident = card->private_data;
 
@@ -3938,28 +3921,14 @@ static int snd_trident_suspend(struct device *dev)
 
         snd_ac97_suspend(trident->ac97);
         snd_ac97_suspend(trident->ac97_sec);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_trident_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_trident *trident = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         switch (trident->device) {
         case TRIDENT_DEVICE_ID_DX:
                 snd_trident_4d_dx_init(trident);
diff --git a/sound/pci/trident/trident_memory.c b/sound/pci/trident/trident_memory.c
index 04c474658e3c..b9ebb51893c5 100644
--- a/sound/pci/trident/trident_memory.c
+++ b/sound/pci/trident/trident_memory.c
@@ -23,7 +23,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/pci.h>
 #include <linux/time.h>
 #include <linux/mutex.h>
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index e088467fb736..8622283e89f3 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -46,7 +46,7 @@
  *      - Optimize position calculation for the 823x chips. 
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -2271,7 +2271,6 @@ static int snd_via82xx_chip_init(struct via82xx *chip)
  */
 static int snd_via82xx_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct via82xx *chip = card->private_data;
         int i;
@@ -2291,28 +2290,15 @@ static int snd_via82xx_suspend(struct device *dev)
                 chip->capture_src_saved[1] = inb(chip->port + VIA_REG_CAPTURE_CHANNEL + 0x10);
         }
 
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_via82xx_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct via82xx *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_via82xx_chip_init(chip);
 
         if (chip->chip_type == TYPE_VIA686) {
diff --git a/sound/pci/via82xx_modem.c b/sound/pci/via82xx_modem.c
index fd46ffe12e4f..99b9137bc677 100644
--- a/sound/pci/via82xx_modem.c
+++ b/sound/pci/via82xx_modem.c
@@ -31,7 +31,7 @@
  *      modems.
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1031,7 +1031,6 @@ static int snd_via82xx_chip_init(struct via82xx_modem *chip)
  */
 static int snd_via82xx_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct via82xx_modem *chip = card->private_data;
         int i;
@@ -1043,29 +1042,15 @@ static int snd_via82xx_suspend(struct device *dev)
                 snd_via82xx_channel_reset(chip, &chip->devs[i]);
         synchronize_irq(chip->irq);
         snd_ac97_suspend(chip->ac97);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_via82xx_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct via82xx_modem *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_via82xx_chip_init(chip);
 
         snd_ac97_resume(chip->ac97);
diff --git a/sound/pci/vx222/vx222.c b/sound/pci/vx222/vx222.c
index c5a25e39e3a8..ecbaf473fc1e 100644
--- a/sound/pci/vx222/vx222.c
+++ b/sound/pci/vx222/vx222.c
@@ -259,32 +259,17 @@ static void snd_vx222_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_vx222_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_vx222 *vx = card->private_data;
-        int err;
 
-        err = snd_vx_suspend(&vx->core);
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
-        return err;
+        return snd_vx_suspend(&vx->core);
 }
 
 static int snd_vx222_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_vx222 *vx = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
         return snd_vx_resume(&vx->core);
 }
 
diff --git a/sound/pci/vx222/vx222_ops.c b/sound/pci/vx222/vx222_ops.c
index 52c1a8d5b88a..af83b3b38052 100644
--- a/sound/pci/vx222/vx222_ops.c
+++ b/sound/pci/vx222/vx222_ops.c
@@ -24,11 +24,11 @@
 #include <linux/device.h>
 #include <linux/firmware.h>
 #include <linux/mutex.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/tlv.h>
-#include <asm/io.h>
 #include "vx222.h"
 
 
diff --git a/sound/pci/ymfpci/ymfpci.c b/sound/pci/ymfpci/ymfpci.c
index 47a192369e8f..812e27a1bcbc 100644
--- a/sound/pci/ymfpci/ymfpci.c
+++ b/sound/pci/ymfpci/ymfpci.c
@@ -283,11 +283,11 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci,
                 card->shortname,
                 chip->reg_area_phys,
                 chip->irq);
-        if ((err = snd_ymfpci_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_ymfpci_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_ymfpci_pcm_spdif(chip, 1, NULL)) < 0) {
+        if ((err = snd_ymfpci_pcm_spdif(chip, 1)) < 0) {
                 snd_card_free(card);
                 return err;
         }
@@ -297,12 +297,12 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci,
                 return err;
         }
         if (chip->ac97->ext_id & AC97_EI_SDAC) {
-                err = snd_ymfpci_pcm_4ch(chip, 2, NULL);
+                err = snd_ymfpci_pcm_4ch(chip, 2);
                 if (err < 0) {
                         snd_card_free(card);
                         return err;
                 }
-                err = snd_ymfpci_pcm2(chip, 3, NULL);
+                err = snd_ymfpci_pcm2(chip, 3);
                 if (err < 0) {
                         snd_card_free(card);
                         return err;
diff --git a/sound/pci/ymfpci/ymfpci.h b/sound/pci/ymfpci/ymfpci.h
index 4631a2348915..149d4cb46998 100644
--- a/sound/pci/ymfpci/ymfpci.h
+++ b/sound/pci/ymfpci/ymfpci.h
@@ -379,10 +379,10 @@ void snd_ymfpci_free_gameport(struct snd_ymfpci *chip);
 
 extern const struct dev_pm_ops snd_ymfpci_pm;
 
-int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm);
-int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm);
-int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm);
-int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm);
+int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device);
+int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device);
+int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device);
+int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device);
 int snd_ymfpci_mixer(struct snd_ymfpci *chip, int rear_switch);
 int snd_ymfpci_timer(struct snd_ymfpci *chip, int device);
 
diff --git a/sound/pci/ymfpci/ymfpci_main.c b/sound/pci/ymfpci/ymfpci_main.c
index 81c916a5eb96..4c26076dbf78 100644
--- a/sound/pci/ymfpci/ymfpci_main.c
+++ b/sound/pci/ymfpci/ymfpci_main.c
@@ -27,6 +27,7 @@
 #include <linux/slab.h>
 #include <linux/mutex.h>
 #include <linux/module.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -36,7 +37,6 @@
 #include <sound/asoundef.h>
 #include <sound/mpu401.h>
 
-#include <asm/io.h>
 #include <asm/byteorder.h>
 
 /*
@@ -1145,13 +1145,11 @@ static struct snd_pcm_ops snd_ymfpci_capture_rec_ops = {
         .pointer =              snd_ymfpci_capture_pointer,
 };
 
-int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm)
+int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI", device, 32, 1, &pcm)) < 0)
                 return err;
         pcm->private_data = chip;
@@ -1167,14 +1165,8 @@ int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm)
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                      snd_pcm_std_chmaps, 2, 0, NULL);
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
 }
 
 static struct snd_pcm_ops snd_ymfpci_capture_ac97_ops = {
@@ -1188,13 +1180,11 @@ static struct snd_pcm_ops snd_ymfpci_capture_ac97_ops = {
         .pointer =              snd_ymfpci_capture_pointer,
 };
 
-int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm)
+int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI - PCM2", device, 0, 1, &pcm)) < 0)
                 return err;
         pcm->private_data = chip;
@@ -1210,8 +1200,6 @@ int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm)
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -1226,14 +1214,11 @@ static struct snd_pcm_ops snd_ymfpci_playback_spdif_ops = {
         .pointer =              snd_ymfpci_playback_pointer,
 };
 
-int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device,
-                         struct snd_pcm **rpcm)
+int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI - IEC958", device, 1, 0, &pcm)) < 0)
                 return err;
         pcm->private_data = chip;
@@ -1248,8 +1233,6 @@ int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -1272,14 +1255,11 @@ static const struct snd_pcm_chmap_elem surround_map[] = {
         { }
 };
 
-int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device,
-                       struct snd_pcm **rpcm)
+int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI - Rear", device, 1, 0, &pcm)) < 0)
                 return err;
         pcm->private_data = chip;
@@ -1294,14 +1274,8 @@ int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                      surround_map, 2, 0, NULL);
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
 }
 
 static int snd_ymfpci_spdif_default_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
@@ -2272,8 +2246,7 @@ static int snd_ymfpci_free(struct snd_ymfpci *chip)
         release_and_free_resource(chip->mpu_res);
         release_and_free_resource(chip->fm_res);
         snd_ymfpci_free_gameport(chip);
-        if (chip->reg_area_virt)
-                iounmap(chip->reg_area_virt);
+        iounmap(chip->reg_area_virt);
         if (chip->work_ptr.area)
                 snd_dma_free_pages(&chip->work_ptr);
         
@@ -2326,7 +2299,6 @@ static int saved_regs_index[] = {
 
 static int snd_ymfpci_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ymfpci *chip = card->private_data;
         unsigned int i;
@@ -2347,9 +2319,6 @@ static int snd_ymfpci_suspend(struct device *dev)
         snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0);
         snd_ymfpci_writel(chip, YDSXGR_BUF441OUTVOL, 0);
         snd_ymfpci_disable_dsp(chip);
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
@@ -2360,14 +2329,6 @@ static int snd_ymfpci_resume(struct device *dev)
         struct snd_ymfpci *chip = card->private_data;
         unsigned int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
         snd_ymfpci_aclink_reset(pci);
         snd_ymfpci_codec_ready(chip, 0);
         snd_ymfpci_download_image(chip);
diff --git a/sound/ppc/awacs.c b/sound/ppc/awacs.c
index 5fbf5db2543d..09da7b52bc2e 100644
--- a/sound/ppc/awacs.c
+++ b/sound/ppc/awacs.c
@@ -20,7 +20,7 @@
  */
 
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/nvram.h>
 #include <linux/init.h>
 #include <linux/delay.h>
diff --git a/sound/ppc/beep.c b/sound/ppc/beep.c
index 0040f048221f..d3524f9fa05d 100644
--- a/sound/ppc/beep.c
+++ b/sound/ppc/beep.c
@@ -18,7 +18,7 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/irq.h>
 #include <linux/init.h>
 #include <linux/slab.h>
diff --git a/sound/ppc/burgundy.c b/sound/ppc/burgundy.c
index cb4f0a5e984e..b86159e04493 100644
--- a/sound/ppc/burgundy.c
+++ b/sound/ppc/burgundy.c
@@ -19,7 +19,7 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <sound/core.h>
diff --git a/sound/ppc/pmac.c b/sound/ppc/pmac.c
index 5a13b22748b2..13146d701413 100644
--- a/sound/ppc/pmac.c
+++ b/sound/ppc/pmac.c
@@ -20,7 +20,7 @@
  */
 
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/irq.h>
 #include <linux/init.h>
 #include <linux/delay.h>
@@ -867,16 +867,11 @@ static int snd_pmac_free(struct snd_pmac *chip)
         snd_pmac_dbdma_free(chip, &chip->capture.cmd);
         snd_pmac_dbdma_free(chip, &chip->extra_dma);
         snd_pmac_dbdma_free(chip, &emergency_dbdma);
-        if (chip->macio_base)
-                iounmap(chip->macio_base);
-        if (chip->latch_base)
-                iounmap(chip->latch_base);
-        if (chip->awacs)
-                iounmap(chip->awacs);
-        if (chip->playback.dma)
-                iounmap(chip->playback.dma);
-        if (chip->capture.dma)
-                iounmap(chip->capture.dma);
+        iounmap(chip->macio_base);
+        iounmap(chip->latch_base);
+        iounmap(chip->awacs);
+        iounmap(chip->playback.dma);
+        iounmap(chip->capture.dma);
 
         if (chip->node) {
                 int i;
diff --git a/sound/ppc/snd_ps3.c b/sound/ppc/snd_ps3.c
index 58f292a87f98..368242519279 100644
--- a/sound/ppc/snd_ps3.c
+++ b/sound/ppc/snd_ps3.c
@@ -1044,7 +1044,7 @@ static int snd_ps3_driver_probe(struct ps3_system_bus_device *dev)
         if (!the_card.null_buffer_start_vaddr) {
                 pr_info("%s: nullbuffer alloc failed\n", __func__);
                 ret = -ENOMEM;
-                goto clean_preallocate;
+                goto clean_card;
         }
         pr_debug("%s: null vaddr=%p dma=%#llx\n", __func__,
                  the_card.null_buffer_start_vaddr,
@@ -1066,8 +1066,6 @@ clean_dma_map:
                           PAGE_SIZE,
                           the_card.null_buffer_start_vaddr,
                           the_card.null_buffer_start_dma_addr);
-clean_preallocate:
-        snd_pcm_lib_preallocate_free_for_all(the_card.pcm);
 clean_card:
         snd_card_free(the_card.card);
 clean_irq:
diff --git a/sound/ppc/tumbler.c b/sound/ppc/tumbler.c
index 24c8766a925d..c8fafba218a5 100644
--- a/sound/ppc/tumbler.c
+++ b/sound/ppc/tumbler.c
@@ -32,8 +32,8 @@
 #include <linux/interrupt.h>
 #include <linux/string.h>
 #include <linux/of_irq.h>
+#include <linux/io.h>
 #include <sound/core.h>
-#include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/machdep.h>
 #include <asm/pmac_feature.h>
diff --git a/sound/sh/aica.c b/sound/sh/aica.c
index f44dda610ed2..ad3d9ae38034 100644
--- a/sound/sh/aica.c
+++ b/sound/sh/aica.c
@@ -35,12 +35,12 @@
 #include <linux/timer.h>
 #include <linux/delay.h>
 #include <linux/workqueue.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/pcm.h>
 #include <sound/initval.h>
 #include <sound/info.h>
-#include <asm/io.h>
 #include <asm/dma.h>
 #include <mach/sysasic.h>
 #include "aica.h"
@@ -343,11 +343,9 @@ static void spu_begin_dma(struct snd_pcm_substream *substream)
                 mod_timer(&dreamcastcard->timer, jiffies + 4);
                 return;
         }
-        init_timer(&(dreamcastcard->timer));
-        dreamcastcard->timer.data = (unsigned long) substream;
-        dreamcastcard->timer.function = aica_period_elapsed;
-        dreamcastcard->timer.expires = jiffies + 4;
-        add_timer(&(dreamcastcard->timer));
+        setup_timer(&dreamcastcard->timer, aica_period_elapsed,
+                    (unsigned long) substream);
+        mod_timer(&dreamcastcard->timer, jiffies + 4);
 }
 
 static int snd_aicapcm_pcm_open(struct snd_pcm_substream
diff --git a/sound/soc/Kconfig b/sound/soc/Kconfig
index 7d5d6444a837..dcc79aa0236b 100644
--- a/sound/soc/Kconfig
+++ b/sound/soc/Kconfig
@@ -55,6 +55,7 @@ source "sound/soc/spear/Kconfig"
 source "sound/soc/tegra/Kconfig"
 source "sound/soc/txx9/Kconfig"
 source "sound/soc/ux500/Kconfig"
+source "sound/soc/xtensa/Kconfig"
 
 # Supported codecs
 source "sound/soc/codecs/Kconfig"
diff --git a/sound/soc/Makefile b/sound/soc/Makefile
index 865e090c8061..5b3c8f67c8db 100644
--- a/sound/soc/Makefile
+++ b/sound/soc/Makefile
@@ -36,3 +36,4 @@ obj-$(CONFIG_SND_SOC)	+= spear/
 obj-$(CONFIG_SND_SOC)   += tegra/
 obj-$(CONFIG_SND_SOC)   += txx9/
 obj-$(CONFIG_SND_SOC)   += ux500/
+obj-$(CONFIG_SND_SOC)   += xtensa/
diff --git a/sound/soc/atmel/Kconfig b/sound/soc/atmel/Kconfig
index fb3878312bf8..1579e994acf8 100644
--- a/sound/soc/atmel/Kconfig
+++ b/sound/soc/atmel/Kconfig
@@ -45,7 +45,7 @@ config SND_ATMEL_SOC_WM8904
 
 config SND_AT91_SOC_SAM9X5_WM8731
         tristate "SoC Audio support for WM8731-based at91sam9x5 board"
-        depends on ATMEL_SSC && SND_ATMEL_SOC && SOC_AT91SAM9X5
+        depends on ARCH_AT91 && ATMEL_SSC && SND_ATMEL_SOC
         select SND_ATMEL_SOC_SSC
         select SND_ATMEL_SOC_DMA
         select SND_SOC_WM8731
diff --git a/sound/soc/atmel/atmel-pcm-dma.c b/sound/soc/atmel/atmel-pcm-dma.c
index 33fb3bb133df..b8e7bad05eb1 100644
--- a/sound/soc/atmel/atmel-pcm-dma.c
+++ b/sound/soc/atmel/atmel-pcm-dma.c
@@ -105,13 +105,11 @@ static int atmel_pcm_configure_dma(struct snd_pcm_substream *substream,
                 return ret;
         }
 
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                slave_config->dst_addr = ssc->phybase + SSC_THR;
-                slave_config->dst_maxburst = 1;
-        } else {
-                slave_config->src_addr = ssc->phybase + SSC_RHR;
-                slave_config->src_maxburst = 1;
-        }
+        slave_config->dst_addr = ssc->phybase + SSC_THR;
+        slave_config->dst_maxburst = 1;
+
+        slave_config->src_addr = ssc->phybase + SSC_RHR;
+        slave_config->src_maxburst = 1;
 
         prtd->dma_intr_handler = atmel_pcm_dma_irq;
 
diff --git a/sound/soc/atmel/atmel_ssc_dai.c b/sound/soc/atmel/atmel_ssc_dai.c
index 35e44e463cfe..fb0b7e8b08ff 100644
--- a/sound/soc/atmel/atmel_ssc_dai.c
+++ b/sound/soc/atmel/atmel_ssc_dai.c
@@ -204,6 +204,13 @@ static int atmel_ssc_startup(struct snd_pcm_substream *substream,
         pr_debug("atmel_ssc_startup: SSC_SR=0x%u\n",
                 ssc_readl(ssc_p->ssc->regs, SR));
 
+        /* Enable PMC peripheral clock for this SSC */
+        pr_debug("atmel_ssc_dai: Starting clock\n");
+        clk_enable(ssc_p->ssc->clk);
+
+        /* Reset the SSC to keep it at a clean status */
+        ssc_writel(ssc_p->ssc->regs, CR, SSC_BIT(CR_SWRST));
+
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                 dir = 0;
                 dir_mask = SSC_DIR_MASK_PLAYBACK;
@@ -250,11 +257,6 @@ static void atmel_ssc_shutdown(struct snd_pcm_substream *substream,
         dma_params = ssc_p->dma_params[dir];
 
         if (dma_params != NULL) {
-                ssc_writel(ssc_p->ssc->regs, CR, dma_params->mask->ssc_disable);
-                pr_debug("atmel_ssc_shutdown: %s disabled SSC_SR=0x%08x\n",
-                        (dir ? "receive" : "transmit"),
-                        ssc_readl(ssc_p->ssc->regs, SR));
-
                 dma_params->ssc = NULL;
                 dma_params->substream = NULL;
                 ssc_p->dma_params[dir] = NULL;
@@ -266,10 +268,6 @@ static void atmel_ssc_shutdown(struct snd_pcm_substream *substream,
         ssc_p->dir_mask &= ~dir_mask;
         if (!ssc_p->dir_mask) {
                 if (ssc_p->initialized) {
-                        /* Shutdown the SSC clock. */
-                        pr_debug("atmel_ssc_dai: Stopping clock\n");
-                        clk_disable(ssc_p->ssc->clk);
-
                         free_irq(ssc_p->ssc->irq, ssc_p);
                         ssc_p->initialized = 0;
                 }
@@ -280,6 +278,10 @@ static void atmel_ssc_shutdown(struct snd_pcm_substream *substream,
                 ssc_p->cmr_div = ssc_p->tcmr_period = ssc_p->rcmr_period = 0;
         }
         spin_unlock_irq(&ssc_p->lock);
+
+        /* Shutdown the SSC clock. */
+        pr_debug("atmel_ssc_dai: Stopping clock\n");
+        clk_disable(ssc_p->ssc->clk);
 }
 
 
@@ -450,13 +452,7 @@ static int atmel_ssc_hw_params(struct snd_pcm_substream *substream,
                 break;
 
         case SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBM_CFM:
-                /*
-                 * I2S format, CODEC supplies BCLK and LRC clocks.
-                 *
-                 * The SSC transmit clock is obtained from the BCLK signal on
-                 * on the TK line, and the SSC receive clock is
-                 * generated from the transmit clock.
-                 */
+                /* I2S format, CODEC supplies BCLK and LRC clocks. */
                 rcmr =    SSC_BF(RCMR_PERIOD, 0)
                         | SSC_BF(RCMR_STTDLY, START_DELAY)
                         | SSC_BF(RCMR_START, SSC_START_FALLING_RF)
@@ -491,6 +487,54 @@ static int atmel_ssc_hw_params(struct snd_pcm_substream *substream,
                         | SSC_BF(TFMR_DATLEN, (bits - 1));
                 break;
 
+        case SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBM_CFS:
+                /* I2S format, CODEC supplies BCLK, SSC supplies LRCLK. */
+                if (bits > 16 && !ssc->pdata->has_fslen_ext) {
+                        dev_err(dai->dev,
+                                "sample size %d is too large for SSC device\n",
+                                bits);
+                        return -EINVAL;
+                }
+
+                fslen_ext = (bits - 1) / 16;
+                fslen = (bits - 1) % 16;
+
+                rcmr =    SSC_BF(RCMR_PERIOD, ssc_p->rcmr_period)
+                        | SSC_BF(RCMR_STTDLY, START_DELAY)
+                        | SSC_BF(RCMR_START, SSC_START_FALLING_RF)
+                        | SSC_BF(RCMR_CKI, SSC_CKI_RISING)
+                        | SSC_BF(RCMR_CKO, SSC_CKO_NONE)
+                        | SSC_BF(RCMR_CKS, ssc->clk_from_rk_pin ?
+                                           SSC_CKS_PIN : SSC_CKS_CLOCK);
+
+                rfmr =    SSC_BF(RFMR_FSLEN_EXT, fslen_ext)
+                        | SSC_BF(RFMR_FSEDGE, SSC_FSEDGE_POSITIVE)
+                        | SSC_BF(RFMR_FSOS, SSC_FSOS_NEGATIVE)
+                        | SSC_BF(RFMR_FSLEN, fslen)
+                        | SSC_BF(RFMR_DATNB, (channels - 1))
+                        | SSC_BIT(RFMR_MSBF)
+                        | SSC_BF(RFMR_LOOP, 0)
+                        | SSC_BF(RFMR_DATLEN, (bits - 1));
+
+                tcmr =    SSC_BF(TCMR_PERIOD, ssc_p->tcmr_period)
+                        | SSC_BF(TCMR_STTDLY, START_DELAY)
+                        | SSC_BF(TCMR_START, SSC_START_FALLING_RF)
+                        | SSC_BF(TCMR_CKI, SSC_CKI_FALLING)
+                        | SSC_BF(TCMR_CKO, SSC_CKO_NONE)
+                        | SSC_BF(TCMR_CKS, ssc->clk_from_rk_pin ?
+                                           SSC_CKS_CLOCK : SSC_CKS_PIN);
+
+                tfmr =    SSC_BF(TFMR_FSLEN_EXT, fslen_ext)
+                        | SSC_BF(TFMR_FSEDGE, SSC_FSEDGE_NEGATIVE)
+                        | SSC_BF(TFMR_FSDEN, 0)
+                        | SSC_BF(TFMR_FSOS, SSC_FSOS_NEGATIVE)
+                        | SSC_BF(TFMR_FSLEN, fslen)
+                        | SSC_BF(TFMR_DATNB, (channels - 1))
+                        | SSC_BIT(TFMR_MSBF)
+                        | SSC_BF(TFMR_DATDEF, 0)
+                        | SSC_BF(TFMR_DATLEN, (bits - 1));
+                break;
+
         case SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_CBS_CFS:
                 /*
                  * DSP/PCM Mode A format, SSC provides BCLK and LRC clocks.
@@ -535,10 +579,6 @@ static int atmel_ssc_hw_params(struct snd_pcm_substream *substream,
                 /*
                  * DSP/PCM Mode A format, CODEC supplies BCLK and LRC clocks.
                  *
-                 * The SSC transmit clock is obtained from the BCLK signal on
-                 * on the TK line, and the SSC receive clock is
-                 * generated from the transmit clock.
-                 *
                  * Data is transferred on first BCLK after LRC pulse rising
                  * edge.If stereo, the right channel data is contiguous with
                  * the left channel data.
@@ -587,23 +627,17 @@ static int atmel_ssc_hw_params(struct snd_pcm_substream *substream,
                         rcmr, rfmr, tcmr, tfmr);
 
         if (!ssc_p->initialized) {
-
-                /* Enable PMC peripheral clock for this SSC */
-                pr_debug("atmel_ssc_dai: Starting clock\n");
-                clk_enable(ssc_p->ssc->clk);
-
-                /* Reset the SSC and its PDC registers */
-                ssc_writel(ssc_p->ssc->regs, CR, SSC_BIT(CR_SWRST));
-
-                ssc_writel(ssc_p->ssc->regs, PDC_RPR, 0);
-                ssc_writel(ssc_p->ssc->regs, PDC_RCR, 0);
-                ssc_writel(ssc_p->ssc->regs, PDC_RNPR, 0);
-                ssc_writel(ssc_p->ssc->regs, PDC_RNCR, 0);
-
-                ssc_writel(ssc_p->ssc->regs, PDC_TPR, 0);
-                ssc_writel(ssc_p->ssc->regs, PDC_TCR, 0);
-                ssc_writel(ssc_p->ssc->regs, PDC_TNPR, 0);
-                ssc_writel(ssc_p->ssc->regs, PDC_TNCR, 0);
+                if (!ssc_p->ssc->pdata->use_dma) {
+                        ssc_writel(ssc_p->ssc->regs, PDC_RPR, 0);
+                        ssc_writel(ssc_p->ssc->regs, PDC_RCR, 0);
+                        ssc_writel(ssc_p->ssc->regs, PDC_RNPR, 0);
+                        ssc_writel(ssc_p->ssc->regs, PDC_RNCR, 0);
+
+                        ssc_writel(ssc_p->ssc->regs, PDC_TPR, 0);
+                        ssc_writel(ssc_p->ssc->regs, PDC_TCR, 0);
+                        ssc_writel(ssc_p->ssc->regs, PDC_TNPR, 0);
+                        ssc_writel(ssc_p->ssc->regs, PDC_TNCR, 0);
+                }
 
                 ret = request_irq(ssc_p->ssc->irq, atmel_ssc_interrupt, 0,
                                 ssc_p->name, ssc_p);
diff --git a/sound/soc/atmel/sam9g20_wm8731.c b/sound/soc/atmel/sam9g20_wm8731.c
index 66b66d0e7514..8de836165cf2 100644
--- a/sound/soc/atmel/sam9g20_wm8731.c
+++ b/sound/soc/atmel/sam9g20_wm8731.c
@@ -46,9 +46,6 @@
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
 
-#include <asm/mach-types.h>
-#include <mach/hardware.h>
-
 #include "../codecs/wm8731.h"
 #include "atmel-pcm.h"
 #include "atmel_ssc_dai.h"
@@ -64,33 +61,6 @@
 
 static struct clk *mclk;
 
-static int at91sam9g20ek_hw_params(struct snd_pcm_substream *substream,
-        struct snd_pcm_hw_params *params)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *codec_dai = rtd->codec_dai;
-        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-        int ret;
-
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
-                SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                return ret;
-
-        /* set cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
-                SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-static struct snd_soc_ops at91sam9g20ek_ops = {
-        .hw_params = at91sam9g20ek_hw_params,
-};
-
 static int at91sam9g20ek_set_bias_level(struct snd_soc_card *card,
                                         struct snd_soc_dapm_context *dapm,
                                         enum snd_soc_bias_level level)
@@ -173,7 +143,8 @@ static struct snd_soc_dai_link at91sam9g20ek_dai = {
         .init = at91sam9g20ek_wm8731_init,
         .platform_name = "at91rm9200_ssc.0",
         .codec_name = "wm8731.0-001b",
-        .ops = &at91sam9g20ek_ops,
+        .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                   SND_SOC_DAIFMT_CBM_CFM,
 };
 
 static struct snd_soc_card snd_soc_at91sam9g20ek = {
@@ -198,9 +169,7 @@ static int at91sam9g20ek_audio_probe(struct platform_device *pdev)
         int ret;
 
         if (!np) {
-                if (!(machine_is_at91sam9g20ek() ||
-                        machine_is_at91sam9g20ek_2mmc()))
-                        return -ENODEV;
+                return -ENODEV;
         }
 
         ret = atmel_ssc_set_audio(0);
@@ -237,39 +206,37 @@ static int at91sam9g20ek_audio_probe(struct platform_device *pdev)
         card->dev = &pdev->dev;
 
         /* Parse device node info */
-        if (np) {
-                ret = snd_soc_of_parse_card_name(card, "atmel,model");
-                if (ret)
-                        goto err;
-
-                ret = snd_soc_of_parse_audio_routing(card,
-                        "atmel,audio-routing");
-                if (ret)
-                        goto err;
-
-                /* Parse codec info */
-                at91sam9g20ek_dai.codec_name = NULL;
-                codec_np = of_parse_phandle(np, "atmel,audio-codec", 0);
-                if (!codec_np) {
-                        dev_err(&pdev->dev, "codec info missing\n");
-                        return -EINVAL;
-                }
-                at91sam9g20ek_dai.codec_of_node = codec_np;
-
-                /* Parse dai and platform info */
-                at91sam9g20ek_dai.cpu_dai_name = NULL;
-                at91sam9g20ek_dai.platform_name = NULL;
-                cpu_np = of_parse_phandle(np, "atmel,ssc-controller", 0);
-                if (!cpu_np) {
-                        dev_err(&pdev->dev, "dai and pcm info missing\n");
-                        return -EINVAL;
-                }
-                at91sam9g20ek_dai.cpu_of_node = cpu_np;
-                at91sam9g20ek_dai.platform_of_node = cpu_np;
-
-                of_node_put(codec_np);
-                of_node_put(cpu_np);
+        ret = snd_soc_of_parse_card_name(card, "atmel,model");
+        if (ret)
+                goto err;
+
+        ret = snd_soc_of_parse_audio_routing(card,
+                "atmel,audio-routing");
+        if (ret)
+                goto err;
+
+        /* Parse codec info */
+        at91sam9g20ek_dai.codec_name = NULL;
+        codec_np = of_parse_phandle(np, "atmel,audio-codec", 0);
+        if (!codec_np) {
+                dev_err(&pdev->dev, "codec info missing\n");
+                return -EINVAL;
         }
+        at91sam9g20ek_dai.codec_of_node = codec_np;
+
+        /* Parse dai and platform info */
+        at91sam9g20ek_dai.cpu_dai_name = NULL;
+        at91sam9g20ek_dai.platform_name = NULL;
+        cpu_np = of_parse_phandle(np, "atmel,ssc-controller", 0);
+        if (!cpu_np) {
+                dev_err(&pdev->dev, "dai and pcm info missing\n");
+                return -EINVAL;
+        }
+        at91sam9g20ek_dai.cpu_of_node = cpu_np;
+        at91sam9g20ek_dai.platform_of_node = cpu_np;
+
+        of_node_put(codec_np);
+        of_node_put(cpu_np);
 
         ret = snd_soc_register_card(card);
         if (ret) {
diff --git a/sound/soc/au1x/db1200.c b/sound/soc/au1x/db1200.c
index a747ac0b399f..c75995f2779c 100644
--- a/sound/soc/au1x/db1200.c
+++ b/sound/soc/au1x/db1200.c
@@ -91,27 +91,12 @@ static int db1200_i2s_startup(struct snd_pcm_substream *substream)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *codec_dai = rtd->codec_dai;
-        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-        int ret;
 
         /* WM8731 has its own 12MHz crystal */
         snd_soc_dai_set_sysclk(codec_dai, WM8731_SYSCLK_XTAL,
                                 12000000, SND_SOC_CLOCK_IN);
 
-        /* codec is bitclock and lrclk master */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_LEFT_J |
-                        SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                goto out;
-
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_LEFT_J |
-                        SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                goto out;
-
-        ret = 0;
-out:
-        return ret;
+        return 0;
 }
 
 static struct snd_soc_ops db1200_i2s_wm8731_ops = {
@@ -125,6 +110,8 @@ static struct snd_soc_dai_link db1200_i2s_dai = {
         .cpu_dai_name   = "au1xpsc_i2s.1",
         .platform_name  = "au1xpsc-pcm.1",
         .codec_name     = "wm8731.0-001b",
+        .dai_fmt        = SND_SOC_DAIFMT_LEFT_J | SND_SOC_DAIFMT_NB_NF |
+                          SND_SOC_DAIFMT_CBM_CFM,
         .ops            = &db1200_i2s_wm8731_ops,
 };
 
diff --git a/sound/soc/au1x/dbdma2.c b/sound/soc/au1x/dbdma2.c
index b06b8d8128c6..dd94fea72d5d 100644
--- a/sound/soc/au1x/dbdma2.c
+++ b/sound/soc/au1x/dbdma2.c
@@ -315,11 +315,6 @@ static struct snd_pcm_ops au1xpsc_pcm_ops = {
         .pointer        = au1xpsc_pcm_pointer,
 };
 
-static void au1xpsc_pcm_free_dma_buffers(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 static int au1xpsc_pcm_new(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_card *card = rtd->card->snd_card;
@@ -335,7 +330,6 @@ static int au1xpsc_pcm_new(struct snd_soc_pcm_runtime *rtd)
 static struct snd_soc_platform_driver au1xpsc_soc_platform = {
         .ops            = &au1xpsc_pcm_ops,
         .pcm_new        = au1xpsc_pcm_new,
-        .pcm_free       = au1xpsc_pcm_free_dma_buffers,
 };
 
 static int au1xpsc_pcm_drvprobe(struct platform_device *pdev)
diff --git a/sound/soc/au1x/dma.c b/sound/soc/au1x/dma.c
index 6ffaaff469c7..24cc7f40d87a 100644
--- a/sound/soc/au1x/dma.c
+++ b/sound/soc/au1x/dma.c
@@ -287,11 +287,6 @@ static struct snd_pcm_ops alchemy_pcm_ops = {
         .pointer                = alchemy_pcm_pointer,
 };
 
-static void alchemy_pcm_free_dma_buffers(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 static int alchemy_pcm_new(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_pcm *pcm = rtd->pcm;
@@ -305,7 +300,6 @@ static int alchemy_pcm_new(struct snd_soc_pcm_runtime *rtd)
 static struct snd_soc_platform_driver alchemy_pcm_soc_platform = {
         .ops            = &alchemy_pcm_ops,
         .pcm_new        = alchemy_pcm_new,
-        .pcm_free       = alchemy_pcm_free_dma_buffers,
 };
 
 static int alchemy_pcm_drvprobe(struct platform_device *pdev)
diff --git a/sound/soc/cirrus/Kconfig b/sound/soc/cirrus/Kconfig
index 7b7fbcd49e5e..c7cd60f009e9 100644
--- a/sound/soc/cirrus/Kconfig
+++ b/sound/soc/cirrus/Kconfig
@@ -16,7 +16,7 @@ config SND_EP93XX_SOC_AC97
 
 config SND_EP93XX_SOC_SNAPPERCL15
         tristate "SoC Audio support for Bluewater Systems Snapper CL15 module"
-        depends on SND_EP93XX_SOC && MACH_SNAPPER_CL15
+        depends on SND_EP93XX_SOC && MACH_SNAPPER_CL15 && I2C
         select SND_EP93XX_SOC_I2S
         select SND_SOC_TLV320AIC23_I2C
         help
diff --git a/sound/soc/codecs/88pm860x-codec.c b/sound/soc/codecs/88pm860x-codec.c
index a2bf27f4baab..a0f265327fdf 100644
--- a/sound/soc/codecs/88pm860x-codec.c
+++ b/sound/soc/codecs/88pm860x-codec.c
@@ -386,7 +386,7 @@ static int snd_soc_put_volsw_2r_out(struct snd_kcontrol *kcontrol,
 static int pm860x_rsync_event(struct snd_soc_dapm_widget *w,
                               struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         /*
          * In order to avoid current on the load, mute power-on and power-off
@@ -403,7 +403,7 @@ static int pm860x_rsync_event(struct snd_soc_dapm_widget *w,
 static int pm860x_dac_event(struct snd_soc_dapm_widget *w,
                             struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         unsigned int dac = 0;
         int data;
 
diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
index 8349f982a586..ea9f0e31f9d4 100644
--- a/sound/soc/codecs/Kconfig
+++ b/sound/soc/codecs/Kconfig
@@ -69,6 +69,7 @@ config SND_SOC_ALL_CODECS
         select SND_SOC_MAX98088 if I2C
         select SND_SOC_MAX98090 if I2C
         select SND_SOC_MAX98095 if I2C
+        select SND_SOC_MAX98357A if GPIOLIB
         select SND_SOC_MAX9850 if I2C
         select SND_SOC_MAX9768 if I2C
         select SND_SOC_MAX9877 if I2C
@@ -456,6 +457,9 @@ config SND_SOC_MAX98090
 config SND_SOC_MAX98095
        tristate
 
+config SND_SOC_MAX98357A
+       tristate
+
 config SND_SOC_MAX9850
         tristate
 
@@ -525,7 +529,7 @@ config SND_SOC_RT5677
 
 config SND_SOC_RT5677_SPI
         tristate
-        default SND_SOC_RT5677
+        default SND_SOC_RT5677 && SPI
 
 #Freescale sgtl5000 codec
 config SND_SOC_SGTL5000
@@ -580,7 +584,9 @@ config SND_SOC_SSM4567
         depends on I2C
 
 config SND_SOC_STA32X
-        tristate
+        tristate "STA326, STA328 and STA329 speaker amplifier"
+        depends on I2C
+        select REGMAP_I2C
 
 config SND_SOC_STA350
         tristate "STA350 speaker amplifier"
diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile
index bbdfd1e1c182..69b8666d187a 100644
--- a/sound/soc/codecs/Makefile
+++ b/sound/soc/codecs/Makefile
@@ -64,6 +64,7 @@ snd-soc-max9768-objs := max9768.o
 snd-soc-max98088-objs := max98088.o
 snd-soc-max98090-objs := max98090.o
 snd-soc-max98095-objs := max98095.o
+snd-soc-max98357a-objs := max98357a.o
 snd-soc-max9850-objs := max9850.o
 snd-soc-mc13783-objs := mc13783.o
 snd-soc-ml26124-objs := ml26124.o
@@ -245,6 +246,7 @@ obj-$(CONFIG_SND_SOC_MAX9768)	+= snd-soc-max9768.o
 obj-$(CONFIG_SND_SOC_MAX98088)  += snd-soc-max98088.o
 obj-$(CONFIG_SND_SOC_MAX98090)  += snd-soc-max98090.o
 obj-$(CONFIG_SND_SOC_MAX98095)  += snd-soc-max98095.o
+obj-$(CONFIG_SND_SOC_MAX98357A) += snd-soc-max98357a.o
 obj-$(CONFIG_SND_SOC_MAX9850)   += snd-soc-max9850.o
 obj-$(CONFIG_SND_SOC_MC13783)   += snd-soc-mc13783.o
 obj-$(CONFIG_SND_SOC_ML26124)   += snd-soc-ml26124.o
diff --git a/sound/soc/codecs/ad193x.c b/sound/soc/codecs/ad193x.c
index 387530b0b0fd..17c953595660 100644
--- a/sound/soc/codecs/ad193x.c
+++ b/sound/soc/codecs/ad193x.c
@@ -333,8 +333,8 @@ static int ad193x_codec_probe(struct snd_soc_codec *codec)
         regmap_write(ad193x->regmap, AD193X_DAC_CHNL_MUTE, 0x0);
         /* de-emphasis: 48kHz, powedown dac */
         regmap_write(ad193x->regmap, AD193X_DAC_CTRL2, 0x1A);
-        /* powerdown dac, dac in tdm mode */
-        regmap_write(ad193x->regmap, AD193X_DAC_CTRL0, 0x41);
+        /* dac in tdm mode */
+        regmap_write(ad193x->regmap, AD193X_DAC_CTRL0, 0x40);
         /* high-pass filter enable */
         regmap_write(ad193x->regmap, AD193X_ADC_CTRL0, 0x3);
         /* sata delay=1, adc aux mode */
diff --git a/sound/soc/codecs/ak4671.c b/sound/soc/codecs/ak4671.c
index 686cacb0e835..632e89f793a7 100644
--- a/sound/soc/codecs/ak4671.c
+++ b/sound/soc/codecs/ak4671.c
@@ -163,7 +163,7 @@ static const struct snd_kcontrol_new ak4671_snd_controls[] = {
 static int ak4671_out2_event(struct snd_soc_dapm_widget *w,
                 struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
diff --git a/sound/soc/codecs/alc5623.c b/sound/soc/codecs/alc5623.c
index bdf8c5ac8ca4..0e357996864b 100644
--- a/sound/soc/codecs/alc5623.c
+++ b/sound/soc/codecs/alc5623.c
@@ -55,18 +55,20 @@ static inline int alc5623_reset(struct snd_soc_codec *codec)
 static int amp_mixer_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+
         /* to power-on/off class-d amp generators/speaker */
         /* need to write to 'index-46h' register :        */
         /* so write index num (here 0x46) to reg 0x6a     */
         /* and then 0xffff/0 to reg 0x6c                  */
-        snd_soc_write(w->codec, ALC5623_HID_CTRL_INDEX, 0x46);
+        snd_soc_write(codec, ALC5623_HID_CTRL_INDEX, 0x46);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
-                snd_soc_write(w->codec, ALC5623_HID_CTRL_DATA, 0xFFFF);
+                snd_soc_write(codec, ALC5623_HID_CTRL_DATA, 0xFFFF);
                 break;
         case SND_SOC_DAPM_POST_PMD:
-                snd_soc_write(w->codec, ALC5623_HID_CTRL_DATA, 0);
+                snd_soc_write(codec, ALC5623_HID_CTRL_DATA, 0);
                 break;
         }
 
diff --git a/sound/soc/codecs/alc5632.c b/sound/soc/codecs/alc5632.c
index d1fdbc266631..db3283abbe18 100644
--- a/sound/soc/codecs/alc5632.c
+++ b/sound/soc/codecs/alc5632.c
@@ -116,18 +116,20 @@ static inline int alc5632_reset(struct regmap *map)
 static int amp_mixer_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+
         /* to power-on/off class-d amp generators/speaker */
         /* need to write to 'index-46h' register :        */
         /* so write index num (here 0x46) to reg 0x6a     */
         /* and then 0xffff/0 to reg 0x6c                  */
-        snd_soc_write(w->codec, ALC5632_HID_CTRL_INDEX, 0x46);
+        snd_soc_write(codec, ALC5632_HID_CTRL_INDEX, 0x46);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
-                snd_soc_write(w->codec, ALC5632_HID_CTRL_DATA, 0xFFFF);
+                snd_soc_write(codec, ALC5632_HID_CTRL_DATA, 0xFFFF);
                 break;
         case SND_SOC_DAPM_POST_PMD:
-                snd_soc_write(w->codec, ALC5632_HID_CTRL_DATA, 0);
+                snd_soc_write(codec, ALC5632_HID_CTRL_DATA, 0);
                 break;
         }
 
@@ -1066,7 +1068,7 @@ static int alc5632_probe(struct snd_soc_codec *codec)
         return 0;
 }
 
-static struct snd_soc_codec_driver soc_codec_device_alc5632 = {
+static const struct snd_soc_codec_driver soc_codec_device_alc5632 = {
         .probe = alc5632_probe,
         .resume = alc5632_resume,
         .set_bias_level = alc5632_set_bias_level,
@@ -1080,7 +1082,7 @@ static struct snd_soc_codec_driver soc_codec_device_alc5632 = {
         .num_dapm_routes = ARRAY_SIZE(alc5632_dapm_routes),
 };
 
-static struct regmap_config alc5632_regmap = {
+static const struct regmap_config alc5632_regmap = {
         .reg_bits = 8,
         .val_bits = 16,
 
diff --git a/sound/soc/codecs/arizona.c b/sound/soc/codecs/arizona.c
index 9550d7433ad0..29202610dd0d 100644
--- a/sound/soc/codecs/arizona.c
+++ b/sound/soc/codecs/arizona.c
@@ -84,7 +84,7 @@ static int arizona_spk_ev(struct snd_soc_dapm_widget *w,
                           struct snd_kcontrol *kcontrol,
                           int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct arizona *arizona = dev_get_drvdata(codec->dev->parent);
         struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
         bool manual_ena = false;
@@ -692,7 +692,8 @@ static void arizona_in_set_vu(struct snd_soc_codec *codec, int ena)
 int arizona_in_ev(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol,
                   int event)
 {
-        struct arizona_priv *priv = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
         unsigned int reg;
 
         if (w->shift % 2)
@@ -705,25 +706,25 @@ int arizona_in_ev(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol,
                 priv->in_pending++;
                 break;
         case SND_SOC_DAPM_POST_PMU:
-                snd_soc_update_bits(w->codec, reg, ARIZONA_IN1L_MUTE, 0);
+                snd_soc_update_bits(codec, reg, ARIZONA_IN1L_MUTE, 0);
 
                 /* If this is the last input pending then allow VU */
                 priv->in_pending--;
                 if (priv->in_pending == 0) {
                         msleep(1);
-                        arizona_in_set_vu(w->codec, 1);
+                        arizona_in_set_vu(codec, 1);
                 }
                 break;
         case SND_SOC_DAPM_PRE_PMD:
-                snd_soc_update_bits(w->codec, reg,
+                snd_soc_update_bits(codec, reg,
                                     ARIZONA_IN1L_MUTE | ARIZONA_IN_VU,
                                     ARIZONA_IN1L_MUTE | ARIZONA_IN_VU);
                 break;
         case SND_SOC_DAPM_POST_PMD:
                 /* Disable volume updates if no inputs are enabled */
-                reg = snd_soc_read(w->codec, ARIZONA_INPUT_ENABLES);
+                reg = snd_soc_read(codec, ARIZONA_INPUT_ENABLES);
                 if (reg == 0)
-                        arizona_in_set_vu(w->codec, 0);
+                        arizona_in_set_vu(codec, 0);
         }
 
         return 0;
@@ -734,7 +735,25 @@ int arizona_out_ev(struct snd_soc_dapm_widget *w,
                    struct snd_kcontrol *kcontrol,
                    int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
+
         switch (event) {
+        case SND_SOC_DAPM_PRE_PMU:
+                switch (w->shift) {
+                case ARIZONA_OUT1L_ENA_SHIFT:
+                case ARIZONA_OUT1R_ENA_SHIFT:
+                case ARIZONA_OUT2L_ENA_SHIFT:
+                case ARIZONA_OUT2R_ENA_SHIFT:
+                case ARIZONA_OUT3L_ENA_SHIFT:
+                case ARIZONA_OUT3R_ENA_SHIFT:
+                        priv->out_up_pending++;
+                        priv->out_up_delay += 17;
+                        break;
+                default:
+                        break;
+                }
+                break;
         case SND_SOC_DAPM_POST_PMU:
                 switch (w->shift) {
                 case ARIZONA_OUT1L_ENA_SHIFT:
@@ -743,13 +762,50 @@ int arizona_out_ev(struct snd_soc_dapm_widget *w,
                 case ARIZONA_OUT2R_ENA_SHIFT:
                 case ARIZONA_OUT3L_ENA_SHIFT:
                 case ARIZONA_OUT3R_ENA_SHIFT:
-                        msleep(17);
+                        priv->out_up_pending--;
+                        if (!priv->out_up_pending) {
+                                msleep(priv->out_up_delay);
+                                priv->out_up_delay = 0;
+                        }
                         break;
 
                 default:
                         break;
                 }
                 break;
+        case SND_SOC_DAPM_PRE_PMD:
+                switch (w->shift) {
+                case ARIZONA_OUT1L_ENA_SHIFT:
+                case ARIZONA_OUT1R_ENA_SHIFT:
+                case ARIZONA_OUT2L_ENA_SHIFT:
+                case ARIZONA_OUT2R_ENA_SHIFT:
+                case ARIZONA_OUT3L_ENA_SHIFT:
+                case ARIZONA_OUT3R_ENA_SHIFT:
+                        priv->out_down_pending++;
+                        priv->out_down_delay++;
+                        break;
+                default:
+                        break;
+                }
+                break;
+        case SND_SOC_DAPM_POST_PMD:
+                switch (w->shift) {
+                case ARIZONA_OUT1L_ENA_SHIFT:
+                case ARIZONA_OUT1R_ENA_SHIFT:
+                case ARIZONA_OUT2L_ENA_SHIFT:
+                case ARIZONA_OUT2R_ENA_SHIFT:
+                case ARIZONA_OUT3L_ENA_SHIFT:
+                case ARIZONA_OUT3R_ENA_SHIFT:
+                        priv->out_down_pending--;
+                        if (!priv->out_down_pending) {
+                                msleep(priv->out_down_delay);
+                                priv->out_down_delay = 0;
+                        }
+                        break;
+                default:
+                        break;
+                }
+                break;
         }
 
         return 0;
@@ -760,7 +816,8 @@ int arizona_hp_ev(struct snd_soc_dapm_widget *w,
                    struct snd_kcontrol *kcontrol,
                    int event)
 {
-        struct arizona_priv *priv = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct arizona_priv *priv = snd_soc_codec_get_drvdata(codec);
         struct arizona *arizona = priv->arizona;
         unsigned int mask = 1 << w->shift;
         unsigned int val;
@@ -772,6 +829,9 @@ int arizona_hp_ev(struct snd_soc_dapm_widget *w,
         case SND_SOC_DAPM_PRE_PMD:
                 val = 0;
                 break;
+        case SND_SOC_DAPM_PRE_PMU:
+        case SND_SOC_DAPM_POST_PMD:
+                return arizona_out_ev(w, kcontrol, event);
         default:
                 return -EINVAL;
         }
diff --git a/sound/soc/codecs/arizona.h b/sound/soc/codecs/arizona.h
index 942cfb197b6d..11ff899b0272 100644
--- a/sound/soc/codecs/arizona.h
+++ b/sound/soc/codecs/arizona.h
@@ -77,6 +77,11 @@ struct arizona_priv {
         int num_inputs;
         unsigned int in_pending;
 
+        unsigned int out_up_pending;
+        unsigned int out_up_delay;
+        unsigned int out_down_pending;
+        unsigned int out_down_delay;
+
         unsigned int spk_ena:2;
         unsigned int spk_ena_pending:1;
 };
diff --git a/sound/soc/codecs/bt-sco.c b/sound/soc/codecs/bt-sco.c
index 5075bf0a7276..e7238b8904bc 100644
--- a/sound/soc/codecs/bt-sco.c
+++ b/sound/soc/codecs/bt-sco.c
@@ -86,5 +86,5 @@ static struct platform_driver bt_sco_driver = {
 module_platform_driver(bt_sco_driver);
 
 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
-MODULE_DESCRIPTION("ASoC generic bluethooth sco link driver");
+MODULE_DESCRIPTION("ASoC generic bluetooth sco link driver");
 MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/cs35l32.c b/sound/soc/codecs/cs35l32.c
index ec55c590afd0..f2b8aad21274 100644
--- a/sound/soc/codecs/cs35l32.c
+++ b/sound/soc/codecs/cs35l32.c
@@ -264,7 +264,7 @@ static int cs35l32_codec_set_sysclk(struct snd_soc_codec *codec,
                         CS35L32_MCLK_DIV2_MASK | CS35L32_MCLK_RATIO_MASK, val);
 }
 
-static struct snd_soc_codec_driver soc_codec_dev_cs35l32 = {
+static const struct snd_soc_codec_driver soc_codec_dev_cs35l32 = {
         .set_sysclk = cs35l32_codec_set_sysclk,
 
         .dapm_widgets = cs35l32_dapm_widgets,
@@ -288,7 +288,7 @@ static const struct reg_default cs35l32_monitor_patch[] = {
         { 0x00, 0x00 },
 };
 
-static struct regmap_config cs35l32_regmap = {
+static const struct regmap_config cs35l32_regmap = {
         .reg_bits = 8,
         .val_bits = 8,
 
diff --git a/sound/soc/codecs/cs42l52.c b/sound/soc/codecs/cs42l52.c
index 35fbef743fbe..1589e7a881d8 100644
--- a/sound/soc/codecs/cs42l52.c
+++ b/sound/soc/codecs/cs42l52.c
@@ -1103,7 +1103,7 @@ static int cs42l52_remove(struct snd_soc_codec *codec)
         return 0;
 }
 
-static struct snd_soc_codec_driver soc_codec_dev_cs42l52 = {
+static const struct snd_soc_codec_driver soc_codec_dev_cs42l52 = {
         .probe = cs42l52_probe,
         .remove = cs42l52_remove,
         .set_bias_level = cs42l52_set_bias_level,
@@ -1130,7 +1130,7 @@ static const struct reg_default cs42l52_threshold_patch[] = {
 
 };
 
-static struct regmap_config cs42l52_regmap = {
+static const struct regmap_config cs42l52_regmap = {
         .reg_bits = 8,
         .val_bits = 8,
 
diff --git a/sound/soc/codecs/cs42l56.c b/sound/soc/codecs/cs42l56.c
index 2ddc7ac10ad7..cbc654fe48c7 100644
--- a/sound/soc/codecs/cs42l56.c
+++ b/sound/soc/codecs/cs42l56.c
@@ -1164,7 +1164,7 @@ static int cs42l56_remove(struct snd_soc_codec *codec)
         return 0;
 }
 
-static struct snd_soc_codec_driver soc_codec_dev_cs42l56 = {
+static const struct snd_soc_codec_driver soc_codec_dev_cs42l56 = {
         .probe = cs42l56_probe,
         .remove = cs42l56_remove,
         .set_bias_level = cs42l56_set_bias_level,
@@ -1179,7 +1179,7 @@ static struct snd_soc_codec_driver soc_codec_dev_cs42l56 = {
         .num_controls = ARRAY_SIZE(cs42l56_snd_controls),
 };
 
-static struct regmap_config cs42l56_regmap = {
+static const struct regmap_config cs42l56_regmap = {
         .reg_bits = 8,
         .val_bits = 8,
 
diff --git a/sound/soc/codecs/cs42l73.c b/sound/soc/codecs/cs42l73.c
index 7c55537c69cf..8ecedba79606 100644
--- a/sound/soc/codecs/cs42l73.c
+++ b/sound/soc/codecs/cs42l73.c
@@ -1347,7 +1347,7 @@ static int cs42l73_probe(struct snd_soc_codec *codec)
         return 0;
 }
 
-static struct snd_soc_codec_driver soc_codec_dev_cs42l73 = {
+static const struct snd_soc_codec_driver soc_codec_dev_cs42l73 = {
         .probe = cs42l73_probe,
         .set_bias_level = cs42l73_set_bias_level,
         .suspend_bias_off = true,
@@ -1361,7 +1361,7 @@ static struct snd_soc_codec_driver soc_codec_dev_cs42l73 = {
         .num_controls = ARRAY_SIZE(cs42l73_snd_controls),
 };
 
-static struct regmap_config cs42l73_regmap = {
+static const struct regmap_config cs42l73_regmap = {
         .reg_bits = 8,
         .val_bits = 8,
 
diff --git a/sound/soc/codecs/da732x.c b/sound/soc/codecs/da732x.c
index 61b2f9a2eef1..ffe96175a8a5 100644
--- a/sound/soc/codecs/da732x.c
+++ b/sound/soc/codecs/da732x.c
@@ -609,7 +609,7 @@ static const struct snd_kcontrol_new da732x_snd_controls[] = {
 static int da732x_adc_event(struct snd_soc_dapm_widget *w,
                             struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -663,7 +663,7 @@ static int da732x_adc_event(struct snd_soc_dapm_widget *w,
 static int da732x_out_pga_event(struct snd_soc_dapm_widget *w,
                                 struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
diff --git a/sound/soc/codecs/max98357a.c b/sound/soc/codecs/max98357a.c
new file mode 100644
index 000000000000..e9e6efbc21dd
--- /dev/null
+++ b/sound/soc/codecs/max98357a.c
@@ -0,0 +1,148 @@
+/* Copyright (c) 2010-2011,2013-2015 The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * max98357a.c -- MAX98357A ALSA SoC Codec driver
+ */
+
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/gpio/consumer.h>
+#include <linux/kernel.h>
+#include <linux/mod_devicetable.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dai.h>
+#include <sound/soc-dapm.h>
+
+#define DRV_NAME "max98357a"
+
+static int max98357a_daiops_trigger(struct snd_pcm_substream *substream,
+                int cmd, struct snd_soc_dai *dai)
+{
+        struct gpio_desc *sdmode = snd_soc_dai_get_drvdata(dai);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                gpiod_set_value(sdmode, 1);
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                gpiod_set_value(sdmode, 0);
+                break;
+        }
+
+        return 0;
+}
+
+static const struct snd_soc_dapm_widget max98357a_dapm_widgets[] = {
+        SND_SOC_DAPM_DAC("SDMode", NULL, SND_SOC_NOPM, 0, 0),
+        SND_SOC_DAPM_OUTPUT("Speaker"),
+};
+
+static const struct snd_soc_dapm_route max98357a_dapm_routes[] = {
+        {"Speaker", NULL, "SDMode"},
+};
+
+static int max98357a_codec_probe(struct snd_soc_codec *codec)
+{
+        struct gpio_desc *sdmode;
+
+        sdmode = devm_gpiod_get(codec->dev, "sdmode");
+        if (IS_ERR(sdmode)) {
+                dev_err(codec->dev, "%s() unable to get sdmode GPIO: %ld\n",
+                                __func__, PTR_ERR(sdmode));
+                return PTR_ERR(sdmode);
+        }
+        gpiod_direction_output(sdmode, 0);
+        snd_soc_codec_set_drvdata(codec, sdmode);
+
+        return 0;
+}
+
+static struct snd_soc_codec_driver max98357a_codec_driver = {
+        .probe                  = max98357a_codec_probe,
+        .dapm_widgets           = max98357a_dapm_widgets,
+        .num_dapm_widgets       = ARRAY_SIZE(max98357a_dapm_widgets),
+        .dapm_routes            = max98357a_dapm_routes,
+        .num_dapm_routes        = ARRAY_SIZE(max98357a_dapm_routes),
+};
+
+static struct snd_soc_dai_ops max98357a_dai_ops = {
+        .trigger        = max98357a_daiops_trigger,
+};
+
+static struct snd_soc_dai_driver max98357a_dai_driver = {
+        .name = DRV_NAME,
+        .playback = {
+                .stream_name    = DRV_NAME "-playback",
+                .formats        = SNDRV_PCM_FMTBIT_S16 |
+                                        SNDRV_PCM_FMTBIT_S24 |
+                                        SNDRV_PCM_FMTBIT_S32,
+                .rates          = SNDRV_PCM_RATE_8000 |
+                                        SNDRV_PCM_RATE_16000 |
+                                        SNDRV_PCM_RATE_48000 |
+                                        SNDRV_PCM_RATE_96000,
+                .rate_min       = 8000,
+                .rate_max       = 96000,
+                .channels_min   = 1,
+                .channels_max   = 2,
+        },
+        .ops    = &max98357a_dai_ops,
+};
+
+static int max98357a_platform_probe(struct platform_device *pdev)
+{
+        int ret;
+
+        ret = snd_soc_register_codec(&pdev->dev, &max98357a_codec_driver,
+                        &max98357a_dai_driver, 1);
+        if (ret)
+                dev_err(&pdev->dev, "%s() error registering codec driver: %d\n",
+                                __func__, ret);
+
+        return ret;
+}
+
+static int max98357a_platform_remove(struct platform_device *pdev)
+{
+        snd_soc_unregister_codec(&pdev->dev);
+
+        return 0;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id max98357a_device_id[] = {
+        { .compatible = "maxim," DRV_NAME, },
+        {}
+};
+MODULE_DEVICE_TABLE(of, max98357a_device_id);
+#endif
+
+static struct platform_driver max98357a_platform_driver = {
+        .driver = {
+                .name = DRV_NAME,
+                .of_match_table = of_match_ptr(max98357a_device_id),
+        },
+        .probe  = max98357a_platform_probe,
+        .remove = max98357a_platform_remove,
+};
+module_platform_driver(max98357a_platform_driver);
+
+MODULE_DESCRIPTION("Maxim MAX98357A Codec Driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/sound/soc/codecs/mc13783.c b/sound/soc/codecs/mc13783.c
index c1e441c2c8af..2ffb9a0570dc 100644
--- a/sound/soc/codecs/mc13783.c
+++ b/sound/soc/codecs/mc13783.c
@@ -328,16 +328,16 @@ static int mc13783_set_tdm_slot_dac(struct snd_soc_dai *dai,
         }
 
         switch (rx_mask) {
-        case 0xfffffffc:
+        case 0x03:
                 val |= SSI_NETWORK_DAC_RXSLOT_0_1;
                 break;
-        case 0xfffffff3:
+        case 0x0c:
                 val |= SSI_NETWORK_DAC_RXSLOT_2_3;
                 break;
-        case 0xffffffcf:
+        case 0x30:
                 val |= SSI_NETWORK_DAC_RXSLOT_4_5;
                 break;
-        case 0xffffff3f:
+        case 0xc0:
                 val |= SSI_NETWORK_DAC_RXSLOT_6_7;
                 break;
         default:
@@ -360,7 +360,7 @@ static int mc13783_set_tdm_slot_codec(struct snd_soc_dai *dai,
         if (slots != 4)
                 return -EINVAL;
 
-        if (tx_mask != 0xfffffffc)
+        if (tx_mask != 0x3)
                 return -EINVAL;
 
         val |= (0x00 << 2);     /* primary timeslot RX/TX(?) is 0 */
diff --git a/sound/soc/codecs/pcm3008.c b/sound/soc/codecs/pcm3008.c
index 7e73fa4b3183..8fb445f33f6f 100644
--- a/sound/soc/codecs/pcm3008.c
+++ b/sound/soc/codecs/pcm3008.c
@@ -32,7 +32,7 @@ static int pcm3008_dac_ev(struct snd_soc_dapm_widget *w,
                           struct snd_kcontrol *kcontrol,
                           int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct pcm3008_setup_data *setup = codec->dev->platform_data;
 
         gpio_set_value_cansleep(setup->pdda_pin,
@@ -45,7 +45,7 @@ static int pcm3008_adc_ev(struct snd_soc_dapm_widget *w,
                           struct snd_kcontrol *kcontrol,
                           int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct pcm3008_setup_data *setup = codec->dev->platform_data;
 
         gpio_set_value_cansleep(setup->pdad_pin,
diff --git a/sound/soc/codecs/pcm512x-i2c.c b/sound/soc/codecs/pcm512x-i2c.c
index d0547fa275fc..dcdfac0ffeb1 100644
--- a/sound/soc/codecs/pcm512x-i2c.c
+++ b/sound/soc/codecs/pcm512x-i2c.c
@@ -46,6 +46,8 @@ static int pcm512x_i2c_remove(struct i2c_client *i2c)
 static const struct i2c_device_id pcm512x_i2c_id[] = {
         { "pcm5121", },
         { "pcm5122", },
+        { "pcm5141", },
+        { "pcm5142", },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, pcm512x_i2c_id);
@@ -53,6 +55,8 @@ MODULE_DEVICE_TABLE(i2c, pcm512x_i2c_id);
 static const struct of_device_id pcm512x_of_match[] = {
         { .compatible = "ti,pcm5121", },
         { .compatible = "ti,pcm5122", },
+        { .compatible = "ti,pcm5141", },
+        { .compatible = "ti,pcm5142", },
         { }
 };
 MODULE_DEVICE_TABLE(of, pcm512x_of_match);
diff --git a/sound/soc/codecs/pcm512x-spi.c b/sound/soc/codecs/pcm512x-spi.c
index f297058c0038..7b64a9cef704 100644
--- a/sound/soc/codecs/pcm512x-spi.c
+++ b/sound/soc/codecs/pcm512x-spi.c
@@ -43,6 +43,8 @@ static int pcm512x_spi_remove(struct spi_device *spi)
 static const struct spi_device_id pcm512x_spi_id[] = {
         { "pcm5121", },
         { "pcm5122", },
+        { "pcm5141", },
+        { "pcm5142", },
         { },
 };
 MODULE_DEVICE_TABLE(spi, pcm512x_spi_id);
@@ -50,6 +52,8 @@ MODULE_DEVICE_TABLE(spi, pcm512x_spi_id);
 static const struct of_device_id pcm512x_of_match[] = {
         { .compatible = "ti,pcm5121", },
         { .compatible = "ti,pcm5122", },
+        { .compatible = "ti,pcm5141", },
+        { .compatible = "ti,pcm5142", },
         { }
 };
 MODULE_DEVICE_TABLE(of, pcm512x_of_match);
diff --git a/sound/soc/codecs/pcm512x.c b/sound/soc/codecs/pcm512x.c
index 30c673cdc12e..9974f201a08f 100644
--- a/sound/soc/codecs/pcm512x.c
+++ b/sound/soc/codecs/pcm512x.c
@@ -21,12 +21,19 @@
 #include <linux/pm_runtime.h>
 #include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
+#include <linux/gcd.h>
 #include <sound/soc.h>
 #include <sound/soc-dapm.h>
+#include <sound/pcm_params.h>
 #include <sound/tlv.h>
 
 #include "pcm512x.h"
 
+#define DIV_ROUND_DOWN_ULL(ll, d) \
+        ({ unsigned long long _tmp = (ll); do_div(_tmp, d); _tmp; })
+#define DIV_ROUND_CLOSEST_ULL(ll, d) \
+        ({ unsigned long long _tmp = (ll)+(d)/2; do_div(_tmp, d); _tmp; })
+
 #define PCM512x_NUM_SUPPLIES 3
 static const char * const pcm512x_supply_names[PCM512x_NUM_SUPPLIES] = {
         "AVDD",
@@ -39,6 +46,14 @@ struct pcm512x_priv {
         struct clk *sclk;
         struct regulator_bulk_data supplies[PCM512x_NUM_SUPPLIES];
         struct notifier_block supply_nb[PCM512x_NUM_SUPPLIES];
+        int fmt;
+        int pll_in;
+        int pll_out;
+        int pll_r;
+        int pll_j;
+        int pll_d;
+        int pll_p;
+        unsigned long real_pll;
 };
 
 /*
@@ -69,6 +84,7 @@ static const struct reg_default pcm512x_reg_defaults[] = {
         { PCM512x_MUTE,              0x00 },
         { PCM512x_DSP,               0x00 },
         { PCM512x_PLL_REF,           0x00 },
+        { PCM512x_DAC_REF,           0x00 },
         { PCM512x_DAC_ROUTING,       0x11 },
         { PCM512x_DSP_PROGRAM,       0x01 },
         { PCM512x_CLKDET,            0x00 },
@@ -87,6 +103,25 @@ static const struct reg_default pcm512x_reg_defaults[] = {
         { PCM512x_ANALOG_GAIN_BOOST, 0x00 },
         { PCM512x_VCOM_CTRL_1,       0x00 },
         { PCM512x_VCOM_CTRL_2,       0x01 },
+        { PCM512x_BCLK_LRCLK_CFG,    0x00 },
+        { PCM512x_MASTER_MODE,       0x7c },
+        { PCM512x_GPIO_DACIN,        0x00 },
+        { PCM512x_GPIO_PLLIN,        0x00 },
+        { PCM512x_SYNCHRONIZE,       0x10 },
+        { PCM512x_PLL_COEFF_0,       0x00 },
+        { PCM512x_PLL_COEFF_1,       0x00 },
+        { PCM512x_PLL_COEFF_2,       0x00 },
+        { PCM512x_PLL_COEFF_3,       0x00 },
+        { PCM512x_PLL_COEFF_4,       0x00 },
+        { PCM512x_DSP_CLKDIV,        0x00 },
+        { PCM512x_DAC_CLKDIV,        0x00 },
+        { PCM512x_NCP_CLKDIV,        0x00 },
+        { PCM512x_OSR_CLKDIV,        0x00 },
+        { PCM512x_MASTER_CLKDIV_1,   0x00 },
+        { PCM512x_MASTER_CLKDIV_2,   0x00 },
+        { PCM512x_FS_SPEED_MODE,     0x00 },
+        { PCM512x_IDAC_1,            0x01 },
+        { PCM512x_IDAC_2,            0x00 },
 };
 
 static bool pcm512x_readable(struct device *dev, unsigned int reg)
@@ -103,6 +138,10 @@ static bool pcm512x_readable(struct device *dev, unsigned int reg)
         case PCM512x_DSP_GPIO_INPUT:
         case PCM512x_MASTER_MODE:
         case PCM512x_PLL_REF:
+        case PCM512x_DAC_REF:
+        case PCM512x_GPIO_DACIN:
+        case PCM512x_GPIO_PLLIN:
+        case PCM512x_SYNCHRONIZE:
         case PCM512x_PLL_COEFF_0:
         case PCM512x_PLL_COEFF_1:
         case PCM512x_PLL_COEFF_2:
@@ -143,6 +182,7 @@ static bool pcm512x_readable(struct device *dev, unsigned int reg)
         case PCM512x_RATE_DET_2:
         case PCM512x_RATE_DET_3:
         case PCM512x_RATE_DET_4:
+        case PCM512x_CLOCK_STATUS:
         case PCM512x_ANALOG_MUTE_DET:
         case PCM512x_GPIN:
         case PCM512x_DIGITAL_MUTE_DET:
@@ -154,6 +194,8 @@ static bool pcm512x_readable(struct device *dev, unsigned int reg)
         case PCM512x_VCOM_CTRL_1:
         case PCM512x_VCOM_CTRL_2:
         case PCM512x_CRAM_CTRL:
+        case PCM512x_FLEX_A:
+        case PCM512x_FLEX_B:
                 return true;
         default:
                 /* There are 256 raw register addresses */
@@ -170,6 +212,7 @@ static bool pcm512x_volatile(struct device *dev, unsigned int reg)
         case PCM512x_RATE_DET_2:
         case PCM512x_RATE_DET_3:
         case PCM512x_RATE_DET_4:
+        case PCM512x_CLOCK_STATUS:
         case PCM512x_ANALOG_MUTE_DET:
         case PCM512x_GPIN:
         case PCM512x_DIGITAL_MUTE_DET:
@@ -277,7 +320,7 @@ SOC_ENUM("Auto Mute Time Right", pcm512x_autom_r),
 SOC_SINGLE("Auto Mute Mono Switch", PCM512x_DIGITAL_MUTE_3,
            PCM512x_ACTL_SHIFT, 1, 0),
 SOC_DOUBLE("Auto Mute Switch", PCM512x_DIGITAL_MUTE_3, PCM512x_AMLE_SHIFT,
-           PCM512x_AMLR_SHIFT, 1, 0),
+           PCM512x_AMRE_SHIFT, 1, 0),
 
 SOC_ENUM("Volume Ramp Down Rate", pcm512x_vndf),
 SOC_ENUM("Volume Ramp Down Step", pcm512x_vnds),
@@ -303,6 +346,136 @@ static const struct snd_soc_dapm_route pcm512x_dapm_routes[] = {
         { "OUTR", NULL, "DACR" },
 };
 
+static const u32 pcm512x_dai_rates[] = {
+        8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000,
+        88200, 96000, 176400, 192000, 384000,
+};
+
+static const struct snd_pcm_hw_constraint_list constraints_slave = {
+        .count = ARRAY_SIZE(pcm512x_dai_rates),
+        .list  = pcm512x_dai_rates,
+};
+
+static int pcm512x_hw_rule_rate(struct snd_pcm_hw_params *params,
+                                struct snd_pcm_hw_rule *rule)
+{
+        struct snd_interval ranges[2];
+        int frame_size;
+
+        frame_size = snd_soc_params_to_frame_size(params);
+        if (frame_size < 0)
+                return frame_size;
+
+        switch (frame_size) {
+        case 32:
+                /* No hole when the frame size is 32. */
+                return 0;
+        case 48:
+        case 64:
+                /* There is only one hole in the range of supported
+                 * rates, but it moves with the frame size.
+                 */
+                memset(ranges, 0, sizeof(ranges));
+                ranges[0].min = 8000;
+                ranges[0].max = 25000000 / frame_size / 2;
+                ranges[1].min = DIV_ROUND_UP(16000000, frame_size);
+                ranges[1].max = 384000;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return snd_interval_ranges(hw_param_interval(params, rule->var),
+                                   ARRAY_SIZE(ranges), ranges, 0);
+}
+
+static int pcm512x_dai_startup_master(struct snd_pcm_substream *substream,
+                                      struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct pcm512x_priv *pcm512x = snd_soc_codec_get_drvdata(codec);
+        struct device *dev = dai->dev;
+        struct snd_pcm_hw_constraint_ratnums *constraints_no_pll;
+        struct snd_ratnum *rats_no_pll;
+
+        if (IS_ERR(pcm512x->sclk)) {
+                dev_err(dev, "Need SCLK for master mode: %ld\n",
+                        PTR_ERR(pcm512x->sclk));
+                return PTR_ERR(pcm512x->sclk);
+        }
+
+        if (pcm512x->pll_out)
+                return snd_pcm_hw_rule_add(substream->runtime, 0,
+                                           SNDRV_PCM_HW_PARAM_RATE,
+                                           pcm512x_hw_rule_rate,
+                                           NULL,
+                                           SNDRV_PCM_HW_PARAM_FRAME_BITS,
+                                           SNDRV_PCM_HW_PARAM_CHANNELS, -1);
+
+        constraints_no_pll = devm_kzalloc(dev, sizeof(*constraints_no_pll),
+                                          GFP_KERNEL);
+        if (!constraints_no_pll)
+                return -ENOMEM;
+        constraints_no_pll->nrats = 1;
+        rats_no_pll = devm_kzalloc(dev, sizeof(*rats_no_pll), GFP_KERNEL);
+        if (!rats_no_pll)
+                return -ENOMEM;
+        constraints_no_pll->rats = rats_no_pll;
+        rats_no_pll->num = clk_get_rate(pcm512x->sclk) / 64;
+        rats_no_pll->den_min = 1;
+        rats_no_pll->den_max = 128;
+        rats_no_pll->den_step = 1;
+
+        return snd_pcm_hw_constraint_ratnums(substream->runtime, 0,
+                                             SNDRV_PCM_HW_PARAM_RATE,
+                                             constraints_no_pll);
+}
+
+static int pcm512x_dai_startup_slave(struct snd_pcm_substream *substream,
+                                     struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct pcm512x_priv *pcm512x = snd_soc_codec_get_drvdata(codec);
+        struct device *dev = dai->dev;
+        struct regmap *regmap = pcm512x->regmap;
+
+        if (IS_ERR(pcm512x->sclk)) {
+                dev_info(dev, "No SCLK, using BCLK: %ld\n",
+                         PTR_ERR(pcm512x->sclk));
+
+                /* Disable reporting of missing SCLK as an error */
+                regmap_update_bits(regmap, PCM512x_ERROR_DETECT,
+                                   PCM512x_IDCH, PCM512x_IDCH);
+
+                /* Switch PLL input to BCLK */
+                regmap_update_bits(regmap, PCM512x_PLL_REF,
+                                   PCM512x_SREF, PCM512x_SREF_BCK);
+        }
+
+        return snd_pcm_hw_constraint_list(substream->runtime, 0,
+                                          SNDRV_PCM_HW_PARAM_RATE,
+                                          &constraints_slave);
+}
+
+static int pcm512x_dai_startup(struct snd_pcm_substream *substream,
+                               struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct pcm512x_priv *pcm512x = snd_soc_codec_get_drvdata(codec);
+
+        switch (pcm512x->fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+        case SND_SOC_DAIFMT_CBM_CFS:
+                return pcm512x_dai_startup_master(substream, dai);
+
+        case SND_SOC_DAIFMT_CBS_CFS:
+                return pcm512x_dai_startup_slave(substream, dai);
+
+        default:
+                return -EINVAL;
+        }
+}
+
 static int pcm512x_set_bias_level(struct snd_soc_codec *codec,
                                   enum snd_soc_bias_level level)
 {
@@ -340,17 +513,717 @@ static int pcm512x_set_bias_level(struct snd_soc_codec *codec,
         return 0;
 }
 
+static unsigned long pcm512x_find_sck(struct snd_soc_dai *dai,
+                                      unsigned long bclk_rate)
+{
+        struct device *dev = dai->dev;
+        unsigned long sck_rate;
+        int pow2;
+
+        /* 64 MHz <= pll_rate <= 100 MHz, VREF mode */
+        /* 16 MHz <= sck_rate <=  25 MHz, VREF mode */
+
+        /* select sck_rate as a multiple of bclk_rate but still with
+         * as many factors of 2 as possible, as that makes it easier
+         * to find a fast DAC rate
+         */
+        pow2 = 1 << fls((25000000 - 16000000) / bclk_rate);
+        for (; pow2; pow2 >>= 1) {
+                sck_rate = rounddown(25000000, bclk_rate * pow2);
+                if (sck_rate >= 16000000)
+                        break;
+        }
+        if (!pow2) {
+                dev_err(dev, "Impossible to generate a suitable SCK\n");
+                return 0;
+        }
+
+        dev_dbg(dev, "sck_rate %lu\n", sck_rate);
+        return sck_rate;
+}
+
+/* pll_rate = pllin_rate * R * J.D / P
+ * 1 <= R <= 16
+ * 1 <= J <= 63
+ * 0 <= D <= 9999
+ * 1 <= P <= 15
+ * 64 MHz <= pll_rate <= 100 MHz
+ * if D == 0
+ *     1 MHz <= pllin_rate / P <= 20 MHz
+ * else if D > 0
+ *     6.667 MHz <= pllin_rate / P <= 20 MHz
+ *     4 <= J <= 11
+ *     R = 1
+ */
+static int pcm512x_find_pll_coeff(struct snd_soc_dai *dai,
+                                  unsigned long pllin_rate,
+                                  unsigned long pll_rate)
+{
+        struct device *dev = dai->dev;
+        struct snd_soc_codec *codec = dai->codec;
+        struct pcm512x_priv *pcm512x = snd_soc_codec_get_drvdata(codec);
+        unsigned long common;
+        int R, J, D, P;
+        unsigned long K; /* 10000 * J.D */
+        unsigned long num;
+        unsigned long den;
+
+        common = gcd(pll_rate, pllin_rate);
+        dev_dbg(dev, "pll %lu pllin %lu common %lu\n",
+                pll_rate, pllin_rate, common);
+        num = pll_rate / common;
+        den = pllin_rate / common;
+
+        /* pllin_rate / P (or here, den) cannot be greater than 20 MHz */
+        if (pllin_rate / den > 20000000 && num < 8) {
+                num *= 20000000 / (pllin_rate / den);
+                den *= 20000000 / (pllin_rate / den);
+        }
+        dev_dbg(dev, "num / den = %lu / %lu\n", num, den);
+
+        P = den;
+        if (den <= 15 && num <= 16 * 63
+            && 1000000 <= pllin_rate / P && pllin_rate / P <= 20000000) {
+                /* Try the case with D = 0 */
+                D = 0;
+                /* factor 'num' into J and R, such that R <= 16 and J <= 63 */
+                for (R = 16; R; R--) {
+                        if (num % R)
+                                continue;
+                        J = num / R;
+                        if (J == 0 || J > 63)
+                                continue;
+
+                        dev_dbg(dev, "R * J / P = %d * %d / %d\n", R, J, P);
+                        pcm512x->real_pll = pll_rate;
+                        goto done;
+                }
+                /* no luck */
+        }
+
+        R = 1;
+
+        if (num > 0xffffffffUL / 10000)
+                goto fallback;
+
+        /* Try to find an exact pll_rate using the D > 0 case */
+        common = gcd(10000 * num, den);
+        num = 10000 * num / common;
+        den /= common;
+        dev_dbg(dev, "num %lu den %lu common %lu\n", num, den, common);
+
+        for (P = den; P <= 15; P++) {
+                if (pllin_rate / P < 6667000 || 200000000 < pllin_rate / P)
+                        continue;
+                if (num * P % den)
+                        continue;
+                K = num * P / den;
+                /* J == 12 is ok if D == 0 */
+                if (K < 40000 || K > 120000)
+                        continue;
+
+                J = K / 10000;
+                D = K % 10000;
+                dev_dbg(dev, "J.D / P = %d.%04d / %d\n", J, D, P);
+                pcm512x->real_pll = pll_rate;
+                goto done;
+        }
+
+        /* Fall back to an approximate pll_rate */
+
+fallback:
+        /* find smallest possible P */
+        P = DIV_ROUND_UP(pllin_rate, 20000000);
+        if (!P)
+                P = 1;
+        else if (P > 15) {
+                dev_err(dev, "Need a slower clock as pll-input\n");
+                return -EINVAL;
+        }
+        if (pllin_rate / P < 6667000) {
+                dev_err(dev, "Need a faster clock as pll-input\n");
+                return -EINVAL;
+        }
+        K = DIV_ROUND_CLOSEST_ULL(10000ULL * pll_rate * P, pllin_rate);
+        if (K < 40000)
+                K = 40000;
+        /* J == 12 is ok if D == 0 */
+        if (K > 120000)
+                K = 120000;
+        J = K / 10000;
+        D = K % 10000;
+        dev_dbg(dev, "J.D / P ~ %d.%04d / %d\n", J, D, P);
+        pcm512x->real_pll = DIV_ROUND_DOWN_ULL((u64)K * pllin_rate, 10000 * P);
+
+done:
+        pcm512x->pll_r = R;
+        pcm512x->pll_j = J;
+        pcm512x->pll_d = D;
+        pcm512x->pll_p = P;
+        return 0;
+}
+
+static unsigned long pcm512x_pllin_dac_rate(struct snd_soc_dai *dai,
+                                            unsigned long osr_rate,
+                                            unsigned long pllin_rate)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct pcm512x_priv *pcm512x = snd_soc_codec_get_drvdata(codec);
+        unsigned long dac_rate;
+
+        if (!pcm512x->pll_out)
+                return 0; /* no PLL to bypass, force SCK as DAC input */
+
+        if (pllin_rate % osr_rate)
+                return 0; /* futile, quit early */
+
+        /* run DAC no faster than 6144000 Hz */
+        for (dac_rate = rounddown(6144000, osr_rate);
+             dac_rate;
+             dac_rate -= osr_rate) {
+
+                if (pllin_rate / dac_rate > 128)
+                        return 0; /* DAC divider would be too big */
+
+                if (!(pllin_rate % dac_rate))
+                        return dac_rate;
+
+                dac_rate -= osr_rate;
+        }
+
+        return 0;
+}
+
+static int pcm512x_set_dividers(struct snd_soc_dai *dai,
+                                struct snd_pcm_hw_params *params)
+{
+        struct device *dev = dai->dev;
+        struct snd_soc_codec *codec = dai->codec;
+        struct pcm512x_priv *pcm512x = snd_soc_codec_get_drvdata(codec);
+        unsigned long pllin_rate = 0;
+        unsigned long pll_rate;
+        unsigned long sck_rate;
+        unsigned long mck_rate;
+        unsigned long bclk_rate;
+        unsigned long sample_rate;
+        unsigned long osr_rate;
+        unsigned long dacsrc_rate;
+        int bclk_div;
+        int lrclk_div;
+        int dsp_div;
+        int dac_div;
+        unsigned long dac_rate;
+        int ncp_div;
+        int osr_div;
+        int ret;
+        int idac;
+        int fssp;
+        int gpio;
+
+        lrclk_div = snd_soc_params_to_frame_size(params);
+        if (lrclk_div == 0) {
+                dev_err(dev, "No LRCLK?\n");
+                return -EINVAL;
+        }
+
+        if (!pcm512x->pll_out) {
+                sck_rate = clk_get_rate(pcm512x->sclk);
+                bclk_div = params->rate_den * 64 / lrclk_div;
+                bclk_rate = DIV_ROUND_CLOSEST(sck_rate, bclk_div);
+
+                mck_rate = sck_rate;
+        } else {
+                ret = snd_soc_params_to_bclk(params);
+                if (ret < 0) {
+                        dev_err(dev, "Failed to find suitable BCLK: %d\n", ret);
+                        return ret;
+                }
+                if (ret == 0) {
+                        dev_err(dev, "No BCLK?\n");
+                        return -EINVAL;
+                }
+                bclk_rate = ret;
+
+                pllin_rate = clk_get_rate(pcm512x->sclk);
+
+                sck_rate = pcm512x_find_sck(dai, bclk_rate);
+                if (!sck_rate)
+                        return -EINVAL;
+                pll_rate = 4 * sck_rate;
+
+                ret = pcm512x_find_pll_coeff(dai, pllin_rate, pll_rate);
+                if (ret != 0)
+                        return ret;
+
+                ret = regmap_write(pcm512x->regmap,
+                                   PCM512x_PLL_COEFF_0, pcm512x->pll_p - 1);
+                if (ret != 0) {
+                        dev_err(dev, "Failed to write PLL P: %d\n", ret);
+                        return ret;
+                }
+
+                ret = regmap_write(pcm512x->regmap,
+                                   PCM512x_PLL_COEFF_1, pcm512x->pll_j);
+                if (ret != 0) {
+                        dev_err(dev, "Failed to write PLL J: %d\n", ret);
+                        return ret;
+                }
+
+                ret = regmap_write(pcm512x->regmap,
+                                   PCM512x_PLL_COEFF_2, pcm512x->pll_d >> 8);
+                if (ret != 0) {
+                        dev_err(dev, "Failed to write PLL D msb: %d\n", ret);
+                        return ret;
+                }
+
+                ret = regmap_write(pcm512x->regmap,
+                                   PCM512x_PLL_COEFF_3, pcm512x->pll_d & 0xff);
+                if (ret != 0) {
+                        dev_err(dev, "Failed to write PLL D lsb: %d\n", ret);
+                        return ret;
+                }
+
+                ret = regmap_write(pcm512x->regmap,
+                                   PCM512x_PLL_COEFF_4, pcm512x->pll_r - 1);
+                if (ret != 0) {
+                        dev_err(dev, "Failed to write PLL R: %d\n", ret);
+                        return ret;
+                }
+
+                mck_rate = pcm512x->real_pll;
+
+                bclk_div = DIV_ROUND_CLOSEST(sck_rate, bclk_rate);
+        }
+
+        if (bclk_div > 128) {
+                dev_err(dev, "Failed to find BCLK divider\n");
+                return -EINVAL;
+        }
+
+        /* the actual rate */
+        sample_rate = sck_rate / bclk_div / lrclk_div;
+        osr_rate = 16 * sample_rate;
+
+        /* run DSP no faster than 50 MHz */
+        dsp_div = mck_rate > 50000000 ? 2 : 1;
+
+        dac_rate = pcm512x_pllin_dac_rate(dai, osr_rate, pllin_rate);
+        if (dac_rate) {
+                /* the desired clock rate is "compatible" with the pll input
+                 * clock, so use that clock as dac input instead of the pll
+                 * output clock since the pll will introduce jitter and thus
+                 * noise.
+                 */
+                dev_dbg(dev, "using pll input as dac input\n");
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_DAC_REF,
+                                         PCM512x_SDAC, PCM512x_SDAC_GPIO);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to set gpio as dacref: %d\n", ret);
+                        return ret;
+                }
+
+                gpio = PCM512x_GREF_GPIO1 + pcm512x->pll_in - 1;
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_GPIO_DACIN,
+                                         PCM512x_GREF, gpio);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to set gpio %d as dacin: %d\n",
+                                pcm512x->pll_in, ret);
+                        return ret;
+                }
+
+                dacsrc_rate = pllin_rate;
+        } else {
+                /* run DAC no faster than 6144000 Hz */
+                unsigned long dac_mul = 6144000 / osr_rate;
+                unsigned long sck_mul = sck_rate / osr_rate;
+
+                for (; dac_mul; dac_mul--) {
+                        if (!(sck_mul % dac_mul))
+                                break;
+                }
+                if (!dac_mul) {
+                        dev_err(dev, "Failed to find DAC rate\n");
+                        return -EINVAL;
+                }
+
+                dac_rate = dac_mul * osr_rate;
+                dev_dbg(dev, "dac_rate %lu sample_rate %lu\n",
+                        dac_rate, sample_rate);
+
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_DAC_REF,
+                                         PCM512x_SDAC, PCM512x_SDAC_SCK);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to set sck as dacref: %d\n", ret);
+                        return ret;
+                }
+
+                dacsrc_rate = sck_rate;
+        }
+
+        dac_div = DIV_ROUND_CLOSEST(dacsrc_rate, dac_rate);
+        if (dac_div > 128) {
+                dev_err(dev, "Failed to find DAC divider\n");
+                return -EINVAL;
+        }
+
+        ncp_div = DIV_ROUND_CLOSEST(dacsrc_rate / dac_div, 1536000);
+        if (ncp_div > 128 || dacsrc_rate / dac_div / ncp_div > 2048000) {
+                /* run NCP no faster than 2048000 Hz, but why? */
+                ncp_div = DIV_ROUND_UP(dacsrc_rate / dac_div, 2048000);
+                if (ncp_div > 128) {
+                        dev_err(dev, "Failed to find NCP divider\n");
+                        return -EINVAL;
+                }
+        }
+
+        osr_div = DIV_ROUND_CLOSEST(dac_rate, osr_rate);
+        if (osr_div > 128) {
+                dev_err(dev, "Failed to find OSR divider\n");
+                return -EINVAL;
+        }
+
+        idac = mck_rate / (dsp_div * sample_rate);
+
+        ret = regmap_write(pcm512x->regmap, PCM512x_DSP_CLKDIV, dsp_div - 1);
+        if (ret != 0) {
+                dev_err(dev, "Failed to write DSP divider: %d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_write(pcm512x->regmap, PCM512x_DAC_CLKDIV, dac_div - 1);
+        if (ret != 0) {
+                dev_err(dev, "Failed to write DAC divider: %d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_write(pcm512x->regmap, PCM512x_NCP_CLKDIV, ncp_div - 1);
+        if (ret != 0) {
+                dev_err(dev, "Failed to write NCP divider: %d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_write(pcm512x->regmap, PCM512x_OSR_CLKDIV, osr_div - 1);
+        if (ret != 0) {
+                dev_err(dev, "Failed to write OSR divider: %d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_write(pcm512x->regmap,
+                           PCM512x_MASTER_CLKDIV_1, bclk_div - 1);
+        if (ret != 0) {
+                dev_err(dev, "Failed to write BCLK divider: %d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_write(pcm512x->regmap,
+                           PCM512x_MASTER_CLKDIV_2, lrclk_div - 1);
+        if (ret != 0) {
+                dev_err(dev, "Failed to write LRCLK divider: %d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_write(pcm512x->regmap, PCM512x_IDAC_1, idac >> 8);
+        if (ret != 0) {
+                dev_err(dev, "Failed to write IDAC msb divider: %d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_write(pcm512x->regmap, PCM512x_IDAC_2, idac & 0xff);
+        if (ret != 0) {
+                dev_err(dev, "Failed to write IDAC lsb divider: %d\n", ret);
+                return ret;
+        }
+
+        if (sample_rate <= 48000)
+                fssp = PCM512x_FSSP_48KHZ;
+        else if (sample_rate <= 96000)
+                fssp = PCM512x_FSSP_96KHZ;
+        else if (sample_rate <= 192000)
+                fssp = PCM512x_FSSP_192KHZ;
+        else
+                fssp = PCM512x_FSSP_384KHZ;
+        ret = regmap_update_bits(pcm512x->regmap, PCM512x_FS_SPEED_MODE,
+                                 PCM512x_FSSP, fssp);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to set fs speed: %d\n", ret);
+                return ret;
+        }
+
+        dev_dbg(codec->dev, "DSP divider %d\n", dsp_div);
+        dev_dbg(codec->dev, "DAC divider %d\n", dac_div);
+        dev_dbg(codec->dev, "NCP divider %d\n", ncp_div);
+        dev_dbg(codec->dev, "OSR divider %d\n", osr_div);
+        dev_dbg(codec->dev, "BCK divider %d\n", bclk_div);
+        dev_dbg(codec->dev, "LRCK divider %d\n", lrclk_div);
+        dev_dbg(codec->dev, "IDAC %d\n", idac);
+        dev_dbg(codec->dev, "1<<FSSP %d\n", 1 << fssp);
+
+        return 0;
+}
+
+static int pcm512x_hw_params(struct snd_pcm_substream *substream,
+                             struct snd_pcm_hw_params *params,
+                             struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct pcm512x_priv *pcm512x = snd_soc_codec_get_drvdata(codec);
+        int alen;
+        int gpio;
+        int clock_output;
+        int master_mode;
+        int ret;
+
+        dev_dbg(codec->dev, "hw_params %u Hz, %u channels\n",
+                params_rate(params),
+                params_channels(params));
+
+        switch (snd_pcm_format_width(params_format(params))) {
+        case 16:
+                alen = PCM512x_ALEN_16;
+                break;
+        case 20:
+                alen = PCM512x_ALEN_20;
+                break;
+        case 24:
+                alen = PCM512x_ALEN_24;
+                break;
+        case 32:
+                alen = PCM512x_ALEN_32;
+                break;
+        default:
+                dev_err(codec->dev, "Bad frame size: %d\n",
+                        snd_pcm_format_width(params_format(params)));
+                return -EINVAL;
+        }
+
+        switch (pcm512x->fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                ret = regmap_update_bits(pcm512x->regmap,
+                                         PCM512x_BCLK_LRCLK_CFG,
+                                         PCM512x_BCKP
+                                         | PCM512x_BCKO | PCM512x_LRKO,
+                                         0);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to enable slave mode: %d\n", ret);
+                        return ret;
+                }
+
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_ERROR_DETECT,
+                                         PCM512x_DCAS, 0);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to enable clock divider autoset: %d\n",
+                                ret);
+                        return ret;
+                }
+                return 0;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                clock_output = PCM512x_BCKO | PCM512x_LRKO;
+                master_mode = PCM512x_RLRK | PCM512x_RBCK;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFS:
+                clock_output = PCM512x_BCKO;
+                master_mode = PCM512x_RBCK;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        ret = regmap_update_bits(pcm512x->regmap, PCM512x_I2S_1,
+                                 PCM512x_ALEN, alen);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to set frame size: %d\n", ret);
+                return ret;
+        }
+
+        if (pcm512x->pll_out) {
+                ret = regmap_write(pcm512x->regmap, PCM512x_FLEX_A, 0x11);
+                if (ret != 0) {
+                        dev_err(codec->dev, "Failed to set FLEX_A: %d\n", ret);
+                        return ret;
+                }
+
+                ret = regmap_write(pcm512x->regmap, PCM512x_FLEX_B, 0xff);
+                if (ret != 0) {
+                        dev_err(codec->dev, "Failed to set FLEX_B: %d\n", ret);
+                        return ret;
+                }
+
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_ERROR_DETECT,
+                                         PCM512x_IDFS | PCM512x_IDBK
+                                         | PCM512x_IDSK | PCM512x_IDCH
+                                         | PCM512x_IDCM | PCM512x_DCAS
+                                         | PCM512x_IPLK,
+                                         PCM512x_IDFS | PCM512x_IDBK
+                                         | PCM512x_IDSK | PCM512x_IDCH
+                                         | PCM512x_DCAS);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to ignore auto-clock failures: %d\n",
+                                ret);
+                        return ret;
+                }
+        } else {
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_ERROR_DETECT,
+                                         PCM512x_IDFS | PCM512x_IDBK
+                                         | PCM512x_IDSK | PCM512x_IDCH
+                                         | PCM512x_IDCM | PCM512x_DCAS
+                                         | PCM512x_IPLK,
+                                         PCM512x_IDFS | PCM512x_IDBK
+                                         | PCM512x_IDSK | PCM512x_IDCH
+                                         | PCM512x_DCAS | PCM512x_IPLK);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to ignore auto-clock failures: %d\n",
+                                ret);
+                        return ret;
+                }
+
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_PLL_EN,
+                                         PCM512x_PLLE, 0);
+                if (ret != 0) {
+                        dev_err(codec->dev, "Failed to disable pll: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        ret = pcm512x_set_dividers(dai, params);
+        if (ret != 0)
+                return ret;
+
+        if (pcm512x->pll_out) {
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_PLL_REF,
+                                         PCM512x_SREF, PCM512x_SREF_GPIO);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to set gpio as pllref: %d\n", ret);
+                        return ret;
+                }
+
+                gpio = PCM512x_GREF_GPIO1 + pcm512x->pll_in - 1;
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_GPIO_PLLIN,
+                                         PCM512x_GREF, gpio);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to set gpio %d as pllin: %d\n",
+                                pcm512x->pll_in, ret);
+                        return ret;
+                }
+
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_PLL_EN,
+                                         PCM512x_PLLE, PCM512x_PLLE);
+                if (ret != 0) {
+                        dev_err(codec->dev, "Failed to enable pll: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        ret = regmap_update_bits(pcm512x->regmap, PCM512x_BCLK_LRCLK_CFG,
+                                 PCM512x_BCKP | PCM512x_BCKO | PCM512x_LRKO,
+                                 clock_output);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to enable clock output: %d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_update_bits(pcm512x->regmap, PCM512x_MASTER_MODE,
+                                 PCM512x_RLRK | PCM512x_RBCK,
+                                 master_mode);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to enable master mode: %d\n", ret);
+                return ret;
+        }
+
+        if (pcm512x->pll_out) {
+                gpio = PCM512x_G1OE << (pcm512x->pll_out - 1);
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_GPIO_EN,
+                                         gpio, gpio);
+                if (ret != 0) {
+                        dev_err(codec->dev, "Failed to enable gpio %d: %d\n",
+                                pcm512x->pll_out, ret);
+                        return ret;
+                }
+
+                gpio = PCM512x_GPIO_OUTPUT_1 + pcm512x->pll_out - 1;
+                ret = regmap_update_bits(pcm512x->regmap, gpio,
+                                         PCM512x_GxSL, PCM512x_GxSL_PLLCK);
+                if (ret != 0) {
+                        dev_err(codec->dev, "Failed to output pll on %d: %d\n",
+                                ret, pcm512x->pll_out);
+                        return ret;
+                }
+
+                gpio = PCM512x_G1OE << (4 - 1);
+                ret = regmap_update_bits(pcm512x->regmap, PCM512x_GPIO_EN,
+                                         gpio, gpio);
+                if (ret != 0) {
+                        dev_err(codec->dev, "Failed to enable gpio %d: %d\n",
+                                4, ret);
+                        return ret;
+                }
+
+                gpio = PCM512x_GPIO_OUTPUT_1 + 4 - 1;
+                ret = regmap_update_bits(pcm512x->regmap, gpio,
+                                         PCM512x_GxSL, PCM512x_GxSL_PLLLK);
+                if (ret != 0) {
+                        dev_err(codec->dev,
+                                "Failed to output pll lock on %d: %d\n",
+                                ret, 4);
+                        return ret;
+                }
+        }
+
+        ret = regmap_update_bits(pcm512x->regmap, PCM512x_SYNCHRONIZE,
+                                 PCM512x_RQSY, PCM512x_RQSY_HALT);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to halt clocks: %d\n", ret);
+                return ret;
+        }
+
+        ret = regmap_update_bits(pcm512x->regmap, PCM512x_SYNCHRONIZE,
+                                 PCM512x_RQSY, PCM512x_RQSY_RESUME);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to resume clocks: %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static int pcm512x_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct pcm512x_priv *pcm512x = snd_soc_codec_get_drvdata(codec);
+
+        pcm512x->fmt = fmt;
+
+        return 0;
+}
+
+static const struct snd_soc_dai_ops pcm512x_dai_ops = {
+        .startup = pcm512x_dai_startup,
+        .hw_params = pcm512x_hw_params,
+        .set_fmt = pcm512x_set_fmt,
+};
+
 static struct snd_soc_dai_driver pcm512x_dai = {
         .name = "pcm512x-hifi",
         .playback = {
                 .stream_name = "Playback",
                 .channels_min = 2,
                 .channels_max = 2,
-                .rates = SNDRV_PCM_RATE_8000_192000,
+                .rates = SNDRV_PCM_RATE_CONTINUOUS,
+                .rate_min = 8000,
+                .rate_max = 384000,
                 .formats = SNDRV_PCM_FMTBIT_S16_LE |
                            SNDRV_PCM_FMTBIT_S24_LE |
                            SNDRV_PCM_FMTBIT_S32_LE
         },
+        .ops = &pcm512x_dai_ops,
 };
 
 static struct snd_soc_codec_driver pcm512x_codec_driver = {
@@ -448,21 +1321,9 @@ int pcm512x_probe(struct device *dev, struct regmap *regmap)
         }
 
         pcm512x->sclk = devm_clk_get(dev, NULL);
-        if (IS_ERR(pcm512x->sclk)) {
-                if (PTR_ERR(pcm512x->sclk) == -EPROBE_DEFER)
-                        return -EPROBE_DEFER;
-
-                dev_info(dev, "No SCLK, using BCLK: %ld\n",
-                         PTR_ERR(pcm512x->sclk));
-
-                /* Disable reporting of missing SCLK as an error */
-                regmap_update_bits(regmap, PCM512x_ERROR_DETECT,
-                                   PCM512x_IDCH, PCM512x_IDCH);
-
-                /* Switch PLL input to BCLK */
-                regmap_update_bits(regmap, PCM512x_PLL_REF,
-                                   PCM512x_SREF, PCM512x_SREF);
-        } else {
+        if (PTR_ERR(pcm512x->sclk) == -EPROBE_DEFER)
+                return -EPROBE_DEFER;
+        if (!IS_ERR(pcm512x->sclk)) {
                 ret = clk_prepare_enable(pcm512x->sclk);
                 if (ret != 0) {
                         dev_err(dev, "Failed to enable SCLK: %d\n", ret);
@@ -483,6 +1344,43 @@ int pcm512x_probe(struct device *dev, struct regmap *regmap)
         pm_runtime_enable(dev);
         pm_runtime_idle(dev);
 
+#ifdef CONFIG_OF
+        if (dev->of_node) {
+                const struct device_node *np = dev->of_node;
+                u32 val;
+
+                if (of_property_read_u32(np, "pll-in", &val) >= 0) {
+                        if (val > 6) {
+                                dev_err(dev, "Invalid pll-in\n");
+                                ret = -EINVAL;
+                                goto err_clk;
+                        }
+                        pcm512x->pll_in = val;
+                }
+
+                if (of_property_read_u32(np, "pll-out", &val) >= 0) {
+                        if (val > 6) {
+                                dev_err(dev, "Invalid pll-out\n");
+                                ret = -EINVAL;
+                                goto err_clk;
+                        }
+                        pcm512x->pll_out = val;
+                }
+
+                if (!pcm512x->pll_in != !pcm512x->pll_out) {
+                        dev_err(dev,
+                                "Error: both pll-in and pll-out, or none\n");
+                        ret = -EINVAL;
+                        goto err_clk;
+                }
+                if (pcm512x->pll_in && pcm512x->pll_in == pcm512x->pll_out) {
+                        dev_err(dev, "Error: pll-in == pll-out\n");
+                        ret = -EINVAL;
+                        goto err_clk;
+                }
+        }
+#endif
+
         ret = snd_soc_register_codec(dev, &pcm512x_codec_driver,
                                     &pcm512x_dai, 1);
         if (ret != 0) {
diff --git a/sound/soc/codecs/pcm512x.h b/sound/soc/codecs/pcm512x.h
index 6ee76aaca09a..b7c310207223 100644
--- a/sound/soc/codecs/pcm512x.h
+++ b/sound/soc/codecs/pcm512x.h
@@ -37,6 +37,10 @@
 #define PCM512x_DSP_GPIO_INPUT    (PCM512x_PAGE_BASE(0) +  10)
 #define PCM512x_MASTER_MODE       (PCM512x_PAGE_BASE(0) +  12)
 #define PCM512x_PLL_REF           (PCM512x_PAGE_BASE(0) +  13)
+#define PCM512x_DAC_REF           (PCM512x_PAGE_BASE(0) +  14)
+#define PCM512x_GPIO_DACIN        (PCM512x_PAGE_BASE(0) +  16)
+#define PCM512x_GPIO_PLLIN        (PCM512x_PAGE_BASE(0) +  18)
+#define PCM512x_SYNCHRONIZE       (PCM512x_PAGE_BASE(0) +  19)
 #define PCM512x_PLL_COEFF_0       (PCM512x_PAGE_BASE(0) +  20)
 #define PCM512x_PLL_COEFF_1       (PCM512x_PAGE_BASE(0) +  21)
 #define PCM512x_PLL_COEFF_2       (PCM512x_PAGE_BASE(0) +  22)
@@ -77,6 +81,7 @@
 #define PCM512x_RATE_DET_2        (PCM512x_PAGE_BASE(0) +  92)
 #define PCM512x_RATE_DET_3        (PCM512x_PAGE_BASE(0) +  93)
 #define PCM512x_RATE_DET_4        (PCM512x_PAGE_BASE(0) +  94)
+#define PCM512x_CLOCK_STATUS      (PCM512x_PAGE_BASE(0) +  95)
 #define PCM512x_ANALOG_MUTE_DET   (PCM512x_PAGE_BASE(0) + 108)
 #define PCM512x_GPIN              (PCM512x_PAGE_BASE(0) + 119)
 #define PCM512x_DIGITAL_MUTE_DET  (PCM512x_PAGE_BASE(0) + 120)
@@ -91,7 +96,10 @@
 
 #define PCM512x_CRAM_CTRL         (PCM512x_PAGE_BASE(44) +  1)
 
-#define PCM512x_MAX_REGISTER      (PCM512x_PAGE_BASE(44) +  1)
+#define PCM512x_FLEX_A            (PCM512x_PAGE_BASE(253) + 63)
+#define PCM512x_FLEX_B            (PCM512x_PAGE_BASE(253) + 64)
+
+#define PCM512x_MAX_REGISTER      (PCM512x_PAGE_BASE(253) + 64)
 
 /* Page 0, Register 1 - reset */
 #define PCM512x_RSTR (1 << 0)
@@ -108,8 +116,8 @@
 #define PCM512x_RQML_SHIFT 4
 
 /* Page 0, Register 4 - PLL */
-#define PCM512x_PLCE       (1 << 0)
-#define PCM512x_RLCE_SHIFT 0
+#define PCM512x_PLLE       (1 << 0)
+#define PCM512x_PLLE_SHIFT 0
 #define PCM512x_PLCK       (1 << 4)
 #define PCM512x_PLCK_SHIFT 4
 
@@ -119,8 +127,66 @@
 #define PCM512x_DEMP       (1 << 4)
 #define PCM512x_DEMP_SHIFT 4
 
+/* Page 0, Register 8 - GPIO output enable */
+#define PCM512x_G1OE       (1 << 0)
+#define PCM512x_G2OE       (1 << 1)
+#define PCM512x_G3OE       (1 << 2)
+#define PCM512x_G4OE       (1 << 3)
+#define PCM512x_G5OE       (1 << 4)
+#define PCM512x_G6OE       (1 << 5)
+
+/* Page 0, Register 9 - BCK, LRCLK configuration */
+#define PCM512x_LRKO       (1 << 0)
+#define PCM512x_LRKO_SHIFT 0
+#define PCM512x_BCKO       (1 << 4)
+#define PCM512x_BCKO_SHIFT 4
+#define PCM512x_BCKP       (1 << 5)
+#define PCM512x_BCKP_SHIFT 5
+
+/* Page 0, Register 12 - Master mode BCK, LRCLK reset */
+#define PCM512x_RLRK       (1 << 0)
+#define PCM512x_RLRK_SHIFT 0
+#define PCM512x_RBCK       (1 << 1)
+#define PCM512x_RBCK_SHIFT 1
+
 /* Page 0, Register 13 - PLL reference */
-#define PCM512x_SREF (1 << 4)
+#define PCM512x_SREF        (7 << 4)
+#define PCM512x_SREF_SHIFT  4
+#define PCM512x_SREF_SCK    (0 << 4)
+#define PCM512x_SREF_BCK    (1 << 4)
+#define PCM512x_SREF_GPIO   (3 << 4)
+
+/* Page 0, Register 14 - DAC reference */
+#define PCM512x_SDAC        (7 << 4)
+#define PCM512x_SDAC_SHIFT  4
+#define PCM512x_SDAC_MCK    (0 << 4)
+#define PCM512x_SDAC_PLL    (1 << 4)
+#define PCM512x_SDAC_SCK    (3 << 4)
+#define PCM512x_SDAC_BCK    (4 << 4)
+#define PCM512x_SDAC_GPIO   (5 << 4)
+
+/* Page 0, Register 16, 18 - GPIO source for DAC, PLL */
+#define PCM512x_GREF        (7 << 0)
+#define PCM512x_GREF_SHIFT  0
+#define PCM512x_GREF_GPIO1  (0 << 0)
+#define PCM512x_GREF_GPIO2  (1 << 0)
+#define PCM512x_GREF_GPIO3  (2 << 0)
+#define PCM512x_GREF_GPIO4  (3 << 0)
+#define PCM512x_GREF_GPIO5  (4 << 0)
+#define PCM512x_GREF_GPIO6  (5 << 0)
+
+/* Page 0, Register 19 - synchronize */
+#define PCM512x_RQSY        (1 << 0)
+#define PCM512x_RQSY_RESUME (0 << 0)
+#define PCM512x_RQSY_HALT   (1 << 0)
+
+/* Page 0, Register 34 - fs speed mode */
+#define PCM512x_FSSP        (3 << 0)
+#define PCM512x_FSSP_SHIFT  0
+#define PCM512x_FSSP_48KHZ  (0 << 0)
+#define PCM512x_FSSP_96KHZ  (1 << 0)
+#define PCM512x_FSSP_192KHZ (2 << 0)
+#define PCM512x_FSSP_384KHZ (3 << 0)
 
 /* Page 0, Register 37 - Error detection */
 #define PCM512x_IPLK (1 << 0)
@@ -131,6 +197,20 @@
 #define PCM512x_IDBK (1 << 5)
 #define PCM512x_IDFS (1 << 6)
 
+/* Page 0, Register 40 - I2S configuration */
+#define PCM512x_ALEN       (3 << 0)
+#define PCM512x_ALEN_SHIFT 0
+#define PCM512x_ALEN_16    (0 << 0)
+#define PCM512x_ALEN_20    (1 << 0)
+#define PCM512x_ALEN_24    (2 << 0)
+#define PCM512x_ALEN_32    (3 << 0)
+#define PCM512x_AFMT       (3 << 4)
+#define PCM512x_AFMT_SHIFT 4
+#define PCM512x_AFMT_I2S   (0 << 4)
+#define PCM512x_AFMT_DSP   (1 << 4)
+#define PCM512x_AFMT_RTJ   (2 << 4)
+#define PCM512x_AFMT_LTJ   (3 << 4)
+
 /* Page 0, Register 42 - DAC routing */
 #define PCM512x_AUPR_SHIFT 0
 #define PCM512x_AUPL_SHIFT 4
@@ -152,7 +232,26 @@
 /* Page 0, Register 65 - Digital mute enables */
 #define PCM512x_ACTL_SHIFT 2
 #define PCM512x_AMLE_SHIFT 1
-#define PCM512x_AMLR_SHIFT 0
+#define PCM512x_AMRE_SHIFT 0
+
+/* Page 0, Register 80-85, GPIO output selection */
+#define PCM512x_GxSL       (31 << 0)
+#define PCM512x_GxSL_SHIFT 0
+#define PCM512x_GxSL_OFF   (0 << 0)
+#define PCM512x_GxSL_DSP   (1 << 0)
+#define PCM512x_GxSL_REG   (2 << 0)
+#define PCM512x_GxSL_AMUTB (3 << 0)
+#define PCM512x_GxSL_AMUTL (4 << 0)
+#define PCM512x_GxSL_AMUTR (5 << 0)
+#define PCM512x_GxSL_CLKI  (6 << 0)
+#define PCM512x_GxSL_SDOUT (7 << 0)
+#define PCM512x_GxSL_ANMUL (8 << 0)
+#define PCM512x_GxSL_ANMUR (9 << 0)
+#define PCM512x_GxSL_PLLLK (10 << 0)
+#define PCM512x_GxSL_CPCLK (11 << 0)
+#define PCM512x_GxSL_UV0_7 (14 << 0)
+#define PCM512x_GxSL_UV0_3 (15 << 0)
+#define PCM512x_GxSL_PLLCK (16 << 0)
 
 /* Page 1, Register 2 - analog volume control */
 #define PCM512x_RAGN_SHIFT 0
diff --git a/sound/soc/codecs/rt286.c b/sound/soc/codecs/rt286.c
index 1d1c7f8a9af2..f374840a5a7c 100644
--- a/sound/soc/codecs/rt286.c
+++ b/sound/soc/codecs/rt286.c
@@ -34,6 +34,7 @@
 #include "rt286.h"
 
 #define RT286_VENDOR_ID 0x10ec0286
+#define RT288_VENDOR_ID 0x10ec0288
 
 struct rt286_priv {
         struct regmap *regmap;
@@ -305,6 +306,8 @@ static int rt286_jack_detect(struct rt286_priv *rt286, bool *hp, bool *mic)
         *hp = false;
         *mic = false;
 
+        if (!rt286->codec)
+                return -EINVAL;
         if (rt286->pdata.cbj_en) {
                 regmap_read(rt286->regmap, RT286_GET_HP_SENSE, &buf);
                 *hp = buf & 0x80000000;
@@ -403,7 +406,8 @@ EXPORT_SYMBOL_GPL(rt286_mic_detect);
 static int is_mclk_mode(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
-        struct rt286_priv *rt286 = snd_soc_codec_get_drvdata(source->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
+        struct rt286_priv *rt286 = snd_soc_codec_get_drvdata(codec);
 
         if (rt286->clk_id == RT286_SCLK_S_MCLK)
                 return 1;
@@ -417,6 +421,8 @@ static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0);
 static const struct snd_kcontrol_new rt286_snd_controls[] = {
         SOC_DOUBLE_R_TLV("DAC0 Playback Volume", RT286_DACL_GAIN,
                             RT286_DACR_GAIN, 0, 0x7f, 0, out_vol_tlv),
+        SOC_DOUBLE_R("ADC0 Capture Switch", RT286_ADCL_GAIN,
+                            RT286_ADCR_GAIN, 7, 1, 1),
         SOC_DOUBLE_R_TLV("ADC0 Capture Volume", RT286_ADCL_GAIN,
                             RT286_ADCR_GAIN, 0, 0x7f, 0, out_vol_tlv),
         SOC_SINGLE_TLV("AMIC Volume", RT286_MIC_GAIN,
@@ -500,7 +506,7 @@ SOC_DAPM_ENUM("SPO source", rt286_spo_enum);
 static int rt286_spk_event(struct snd_soc_dapm_widget *w,
                             struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -522,7 +528,7 @@ static int rt286_spk_event(struct snd_soc_dapm_widget *w,
 static int rt286_set_dmic1_event(struct snd_soc_dapm_widget *w,
                                   struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -538,36 +544,10 @@ static int rt286_set_dmic1_event(struct snd_soc_dapm_widget *w,
         return 0;
 }
 
-static int rt286_adc_event(struct snd_soc_dapm_widget *w,
-                             struct snd_kcontrol *kcontrol, int event)
-{
-        struct snd_soc_codec *codec = w->codec;
-        unsigned int nid;
-
-        nid = (w->reg >> 20) & 0xff;
-
-        switch (event) {
-        case SND_SOC_DAPM_POST_PMU:
-                snd_soc_update_bits(codec,
-                        VERB_CMD(AC_VERB_SET_AMP_GAIN_MUTE, nid, 0),
-                        0x7080, 0x7000);
-                break;
-        case SND_SOC_DAPM_PRE_PMD:
-                snd_soc_update_bits(codec,
-                        VERB_CMD(AC_VERB_SET_AMP_GAIN_MUTE, nid, 0),
-                        0x7080, 0x7080);
-                break;
-        default:
-                return 0;
-        }
-
-        return 0;
-}
-
 static int rt286_vref_event(struct snd_soc_dapm_widget *w,
                              struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
@@ -585,7 +565,7 @@ static int rt286_vref_event(struct snd_soc_dapm_widget *w,
 static int rt286_ldo2_event(struct snd_soc_dapm_widget *w,
                              struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -604,7 +584,7 @@ static int rt286_ldo2_event(struct snd_soc_dapm_widget *w,
 static int rt286_mic1_event(struct snd_soc_dapm_widget *w,
                              struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
@@ -667,12 +647,10 @@ static const struct snd_soc_dapm_widget rt286_dapm_widgets[] = {
         SND_SOC_DAPM_ADC("ADC 1", NULL, SND_SOC_NOPM, 0, 0),
 
         /* ADC Mux */
-        SND_SOC_DAPM_MUX_E("ADC 0 Mux", RT286_SET_POWER(RT286_ADC_IN1), 0, 1,
-                &rt286_adc0_mux, rt286_adc_event, SND_SOC_DAPM_PRE_PMD |
-                SND_SOC_DAPM_POST_PMU),
-        SND_SOC_DAPM_MUX_E("ADC 1 Mux", RT286_SET_POWER(RT286_ADC_IN2), 0, 1,
-                &rt286_adc1_mux, rt286_adc_event, SND_SOC_DAPM_PRE_PMD |
-                SND_SOC_DAPM_POST_PMU),
+        SND_SOC_DAPM_MUX("ADC 0 Mux", RT286_SET_POWER(RT286_ADC_IN1), 0, 1,
+                &rt286_adc0_mux),
+        SND_SOC_DAPM_MUX("ADC 1 Mux", RT286_SET_POWER(RT286_ADC_IN2), 0, 1,
+                &rt286_adc1_mux),
 
         /* Audio Interface */
         SND_SOC_DAPM_AIF_IN("AIF1RX", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
@@ -1194,6 +1172,7 @@ static const struct regmap_config rt286_regmap = {
 
 static const struct i2c_device_id rt286_i2c_id[] = {
         {"rt286", 0},
+        {"rt288", 0},
         {}
 };
 MODULE_DEVICE_TABLE(i2c, rt286_i2c_id);
@@ -1214,6 +1193,17 @@ static struct dmi_system_id force_combo_jack_table[] = {
         { }
 };
 
+static struct dmi_system_id dmi_dell_dino[] = {
+        {
+                .ident = "Dell Dino",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_BOARD_NAME, "0144P8")
+                }
+        },
+        { }
+};
+
 static int rt286_i2c_probe(struct i2c_client *i2c,
                            const struct i2c_device_id *id)
 {
@@ -1236,7 +1226,7 @@ static int rt286_i2c_probe(struct i2c_client *i2c,
 
         regmap_read(rt286->regmap,
                 RT286_GET_PARAM(AC_NODE_ROOT, AC_PAR_VENDOR_ID), &ret);
-        if (ret != RT286_VENDOR_ID) {
+        if (ret != RT286_VENDOR_ID && ret != RT288_VENDOR_ID) {
                 dev_err(&i2c->dev,
                         "Device with ID register %x is not rt286\n", ret);
                 return -ENODEV;
@@ -1249,7 +1239,8 @@ static int rt286_i2c_probe(struct i2c_client *i2c,
         if (pdata)
                 rt286->pdata = *pdata;
 
-        if (dmi_check_system(force_combo_jack_table))
+        if (dmi_check_system(force_combo_jack_table) ||
+                dmi_check_system(dmi_dell_dino))
                 rt286->pdata.cbj_en = true;
 
         regmap_write(rt286->regmap, RT286_SET_AUDIO_POWER, AC_PWRST_D3);
@@ -1288,6 +1279,17 @@ static int rt286_i2c_probe(struct i2c_client *i2c,
         regmap_update_bits(rt286->regmap, RT286_DEPOP_CTRL3, 0xf777, 0x4737);
         regmap_update_bits(rt286->regmap, RT286_DEPOP_CTRL4, 0x00ff, 0x003f);
 
+        if (dmi_check_system(dmi_dell_dino)) {
+                regmap_update_bits(rt286->regmap,
+                        RT286_SET_GPIO_MASK, 0x40, 0x40);
+                regmap_update_bits(rt286->regmap,
+                        RT286_SET_GPIO_DIRECTION, 0x40, 0x40);
+                regmap_update_bits(rt286->regmap,
+                        RT286_SET_GPIO_DATA, 0x40, 0x40);
+                regmap_update_bits(rt286->regmap,
+                        RT286_GPIO_CTRL, 0xc, 0x8);
+        }
+
         if (rt286->i2c->irq) {
                 ret = request_threaded_irq(rt286->i2c->irq, NULL, rt286_irq,
                         IRQF_TRIGGER_HIGH | IRQF_ONESHOT, "rt286", rt286);
diff --git a/sound/soc/codecs/rt286.h b/sound/soc/codecs/rt286.h
index b539b7320a79..7130edb152ef 100644
--- a/sound/soc/codecs/rt286.h
+++ b/sound/soc/codecs/rt286.h
@@ -117,6 +117,12 @@
         VERB_CMD(AC_VERB_SET_COEF_INDEX, RT286_VENDOR_REGISTERS, 0)
 #define RT286_PROC_COEF\
         VERB_CMD(AC_VERB_SET_PROC_COEF, RT286_VENDOR_REGISTERS, 0)
+#define RT286_SET_GPIO_MASK\
+        VERB_CMD(AC_VERB_SET_GPIO_MASK, RT286_AUDIO_FUNCTION_GROUP, 0)
+#define RT286_SET_GPIO_DIRECTION\
+        VERB_CMD(AC_VERB_SET_GPIO_DIRECTION, RT286_AUDIO_FUNCTION_GROUP, 0)
+#define RT286_SET_GPIO_DATA\
+        VERB_CMD(AC_VERB_SET_GPIO_DATA, RT286_AUDIO_FUNCTION_GROUP, 0)
 
 /* Index registers */
 #define RT286_A_BIAS_CTRL1      0x01
@@ -131,6 +137,7 @@
 #define RT286_POWER_CTRL3       0x0f
 #define RT286_MIC1_DET_CTRL     0x19
 #define RT286_MISC_CTRL1        0x20
+#define RT286_GPIO_CTRL         0x29
 #define RT286_IRQ_CTRL          0x33
 #define RT286_PLL_CTRL1         0x49
 #define RT286_CBJ_CTRL1         0x4f
diff --git a/sound/soc/codecs/rt5631.c b/sound/soc/codecs/rt5631.c
index 6d7b7ca7d530..c61852742ee3 100644
--- a/sound/soc/codecs/rt5631.c
+++ b/sound/soc/codecs/rt5631.c
@@ -287,70 +287,78 @@ static const struct snd_kcontrol_new rt5631_snd_controls[] = {
 static int check_sysclk1_source(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int reg;
 
-        reg = snd_soc_read(source->codec, RT5631_GLOBAL_CLK_CTRL);
+        reg = snd_soc_read(codec, RT5631_GLOBAL_CLK_CTRL);
         return reg & RT5631_SYSCLK_SOUR_SEL_PLL;
 }
 
 static int check_dmic_used(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
-        struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(source->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
+        struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
         return rt5631->dmic_used_flag;
 }
 
 static int check_dacl_to_outmixl(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int reg;
 
-        reg = snd_soc_read(source->codec, RT5631_OUTMIXER_L_CTRL);
+        reg = snd_soc_read(codec, RT5631_OUTMIXER_L_CTRL);
         return !(reg & RT5631_M_DAC_L_TO_OUTMIXER_L);
 }
 
 static int check_dacr_to_outmixr(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int reg;
 
-        reg = snd_soc_read(source->codec, RT5631_OUTMIXER_R_CTRL);
+        reg = snd_soc_read(codec, RT5631_OUTMIXER_R_CTRL);
         return !(reg & RT5631_M_DAC_R_TO_OUTMIXER_R);
 }
 
 static int check_dacl_to_spkmixl(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int reg;
 
-        reg = snd_soc_read(source->codec, RT5631_SPK_MIXER_CTRL);
+        reg = snd_soc_read(codec, RT5631_SPK_MIXER_CTRL);
         return !(reg & RT5631_M_DAC_L_TO_SPKMIXER_L);
 }
 
 static int check_dacr_to_spkmixr(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int reg;
 
-        reg = snd_soc_read(source->codec, RT5631_SPK_MIXER_CTRL);
+        reg = snd_soc_read(codec, RT5631_SPK_MIXER_CTRL);
         return !(reg & RT5631_M_DAC_R_TO_SPKMIXER_R);
 }
 
 static int check_adcl_select(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int reg;
 
-        reg = snd_soc_read(source->codec, RT5631_ADC_REC_MIXER);
+        reg = snd_soc_read(codec, RT5631_ADC_REC_MIXER);
         return !(reg & RT5631_M_MIC1_TO_RECMIXER_L);
 }
 
 static int check_adcr_select(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int reg;
 
-        reg = snd_soc_read(source->codec, RT5631_ADC_REC_MIXER);
+        reg = snd_soc_read(codec, RT5631_ADC_REC_MIXER);
         return !(reg & RT5631_M_MIC2_TO_RECMIXER_R);
 }
 
@@ -556,7 +564,7 @@ static void depop_seq_mute_stage(struct snd_soc_codec *codec, int enable)
 static int hp_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -590,7 +598,7 @@ static int hp_event(struct snd_soc_dapm_widget *w,
 static int set_dmic_params(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
 
         switch (rt5631->rx_rate) {
diff --git a/sound/soc/codecs/rt5640.c b/sound/soc/codecs/rt5640.c
index 1ff726c29249..178e55d4d481 100644
--- a/sound/soc/codecs/rt5640.c
+++ b/sound/soc/codecs/rt5640.c
@@ -458,7 +458,7 @@ static const struct snd_kcontrol_new rt5640_specific_snd_controls[] = {
 static int set_dmic_clk(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5640_priv *rt5640 = snd_soc_codec_get_drvdata(codec);
         int idx = -EINVAL;
 
@@ -475,9 +475,10 @@ static int set_dmic_clk(struct snd_soc_dapm_widget *w,
 static int is_sys_clk_from_pll(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int val;
 
-        val = snd_soc_read(source->codec, RT5640_GLB_CLK);
+        val = snd_soc_read(codec, RT5640_GLB_CLK);
         val &= RT5640_SCLK_SRC_MASK;
         if (val == RT5640_SCLK_SRC_PLL1)
                 return 1;
@@ -963,7 +964,7 @@ static void rt5640_pmu_depop(struct snd_soc_codec *codec)
 static int rt5640_hp_event(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5640_priv *rt5640 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -987,7 +988,7 @@ static int rt5640_hp_event(struct snd_soc_dapm_widget *w,
 static int rt5640_hp_power_event(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -1003,7 +1004,7 @@ static int rt5640_hp_power_event(struct snd_soc_dapm_widget *w,
 static int rt5640_hp_post_event(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5640_priv *rt5640 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
diff --git a/sound/soc/codecs/rt5645.c b/sound/soc/codecs/rt5645.c
index 27141e2df878..c9a4c5be083b 100644
--- a/sound/soc/codecs/rt5645.c
+++ b/sound/soc/codecs/rt5645.c
@@ -31,6 +31,7 @@
 #include "rt5645.h"
 
 #define RT5645_DEVICE_ID 0x6308
+#define RT5650_DEVICE_ID 0x6419
 
 #define RT5645_PR_RANGE_BASE (0xff + 1)
 #define RT5645_PR_SPACING 0x100
@@ -59,6 +60,10 @@ static const struct reg_default init_list[] = {
 };
 #define RT5645_INIT_REG_LEN ARRAY_SIZE(init_list)
 
+static const struct reg_default rt5650_init_list[] = {
+        {0xf6,  0x0100},
+};
+
 static const struct reg_default rt5645_reg[] = {
         { 0x00, 0x0000 },
         { 0x01, 0xc8c8 },
@@ -86,6 +91,7 @@ static const struct reg_default rt5645_reg[] = {
         { 0x2a, 0x5656 },
         { 0x2b, 0x5454 },
         { 0x2c, 0xaaa0 },
+        { 0x2d, 0x0000 },
         { 0x2f, 0x1002 },
         { 0x31, 0x5000 },
         { 0x32, 0x0000 },
@@ -193,6 +199,8 @@ static const struct reg_default rt5645_reg[] = {
         { 0xdb, 0x0003 },
         { 0xdc, 0x0049 },
         { 0xdd, 0x001b },
+        { 0xdf, 0x0008 },
+        { 0xe0, 0x4000 },
         { 0xe6, 0x8000 },
         { 0xe7, 0x0200 },
         { 0xec, 0xb300 },
@@ -242,6 +250,7 @@ static bool rt5645_volatile_register(struct device *dev, unsigned int reg)
         case RT5645_IRQ_CTRL3:
         case RT5645_INT_IRQ_ST:
         case RT5645_IL_CMD:
+        case RT5650_4BTN_IL_CMD1:
         case RT5645_VENDOR_ID:
         case RT5645_VENDOR_ID1:
         case RT5645_VENDOR_ID2:
@@ -287,6 +296,7 @@ static bool rt5645_readable_register(struct device *dev, unsigned int reg)
         case RT5645_STO_DAC_MIXER:
         case RT5645_MONO_DAC_MIXER:
         case RT5645_DIG_MIXER:
+        case RT5650_A_DAC_SOUR:
         case RT5645_DIG_INF1_DATA:
         case RT5645_PDM_OUT_CTRL:
         case RT5645_REC_L1_MIXER:
@@ -378,6 +388,8 @@ static bool rt5645_readable_register(struct device *dev, unsigned int reg)
         case RT5645_IL_CMD:
         case RT5645_IL_CMD2:
         case RT5645_IL_CMD3:
+        case RT5650_4BTN_IL_CMD1:
+        case RT5650_4BTN_IL_CMD2:
         case RT5645_DRC1_HL_CTRL1:
         case RT5645_DRC2_HL_CTRL1:
         case RT5645_ADC_MONO_HP_CTRL1:
@@ -527,7 +539,7 @@ static const struct snd_kcontrol_new rt5645_snd_controls[] = {
 static int set_dmic_clk(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5645_priv *rt5645 = snd_soc_codec_get_drvdata(codec);
         int idx = -EINVAL;
 
@@ -544,9 +556,10 @@ static int set_dmic_clk(struct snd_soc_dapm_widget *w,
 static int is_sys_clk_from_pll(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int val;
 
-        val = snd_soc_read(source->codec, RT5645_GLB_CLK);
+        val = snd_soc_read(codec, RT5645_GLB_CLK);
         val &= RT5645_SCLK_SRC_MASK;
         if (val == RT5645_SCLK_SRC_PLL1)
                 return 1;
@@ -557,6 +570,7 @@ static int is_sys_clk_from_pll(struct snd_soc_dapm_widget *source,
 static int is_using_asrc(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int reg, shift, val;
 
         switch (source->shift) {
@@ -588,7 +602,7 @@ static int is_using_asrc(struct snd_soc_dapm_widget *source,
                 return 0;
         }
 
-        val = (snd_soc_read(source->codec, reg) >> shift) & 0xf;
+        val = (snd_soc_read(codec, reg) >> shift) & 0xf;
         switch (val) {
         case 1:
         case 2:
@@ -601,6 +615,87 @@ static int is_using_asrc(struct snd_soc_dapm_widget *source,
 
 }
 
+/**
+ * rt5645_sel_asrc_clk_src - select ASRC clock source for a set of filters
+ * @codec: SoC audio codec device.
+ * @filter_mask: mask of filters.
+ * @clk_src: clock source
+ *
+ * The ASRC function is for asynchronous MCLK and LRCK. Also, since RT5645 can
+ * only support standard 32fs or 64fs i2s format, ASRC should be enabled to
+ * support special i2s clock format such as Intel's 100fs(100 * sampling rate).
+ * ASRC function will track i2s clock and generate a corresponding system clock
+ * for codec. This function provides an API to select the clock source for a
+ * set of filters specified by the mask. And the codec driver will turn on ASRC
+ * for these filters if ASRC is selected as their clock source.
+ */
+int rt5645_sel_asrc_clk_src(struct snd_soc_codec *codec,
+                unsigned int filter_mask, unsigned int clk_src)
+{
+        unsigned int asrc2_mask = 0;
+        unsigned int asrc2_value = 0;
+        unsigned int asrc3_mask = 0;
+        unsigned int asrc3_value = 0;
+
+        switch (clk_src) {
+        case RT5645_CLK_SEL_SYS:
+        case RT5645_CLK_SEL_I2S1_ASRC:
+        case RT5645_CLK_SEL_I2S2_ASRC:
+        case RT5645_CLK_SEL_SYS2:
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        if (filter_mask & RT5645_DA_STEREO_FILTER) {
+                asrc2_mask |= RT5645_DA_STO_CLK_SEL_MASK;
+                asrc2_value = (asrc2_value & ~RT5645_DA_STO_CLK_SEL_MASK)
+                        | (clk_src << RT5645_DA_STO_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5645_DA_MONO_L_FILTER) {
+                asrc2_mask |= RT5645_DA_MONOL_CLK_SEL_MASK;
+                asrc2_value = (asrc2_value & ~RT5645_DA_MONOL_CLK_SEL_MASK)
+                        | (clk_src << RT5645_DA_MONOL_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5645_DA_MONO_R_FILTER) {
+                asrc2_mask |= RT5645_DA_MONOR_CLK_SEL_MASK;
+                asrc2_value = (asrc2_value & ~RT5645_DA_MONOR_CLK_SEL_MASK)
+                        | (clk_src << RT5645_DA_MONOR_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5645_AD_STEREO_FILTER) {
+                asrc2_mask |= RT5645_AD_STO1_CLK_SEL_MASK;
+                asrc2_value = (asrc2_value & ~RT5645_AD_STO1_CLK_SEL_MASK)
+                        | (clk_src << RT5645_AD_STO1_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5645_AD_MONO_L_FILTER) {
+                asrc3_mask |= RT5645_AD_MONOL_CLK_SEL_MASK;
+                asrc3_value = (asrc3_value & ~RT5645_AD_MONOL_CLK_SEL_MASK)
+                        | (clk_src << RT5645_AD_MONOL_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5645_AD_MONO_R_FILTER)  {
+                asrc3_mask |= RT5645_AD_MONOR_CLK_SEL_MASK;
+                asrc3_value = (asrc3_value & ~RT5645_AD_MONOR_CLK_SEL_MASK)
+                        | (clk_src << RT5645_AD_MONOR_CLK_SEL_SFT);
+        }
+
+        if (asrc2_mask)
+                snd_soc_update_bits(codec, RT5645_ASRC_2,
+                        asrc2_mask, asrc2_value);
+
+        if (asrc3_mask)
+                snd_soc_update_bits(codec, RT5645_ASRC_3,
+                        asrc3_mask, asrc3_value);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(rt5645_sel_asrc_clk_src);
+
 /* Digital Mixer */
 static const struct snd_kcontrol_new rt5645_sto1_adc_l_mix[] = {
         SOC_DAPM_SINGLE("ADC1 Switch", RT5645_STO1_ADC_MIXER,
@@ -1007,6 +1102,44 @@ static SOC_ENUM_SINGLE_DECL(
 static const struct snd_kcontrol_new rt5645_if1_adc_in_mux =
         SOC_DAPM_ENUM("IF1 ADC IN source", rt5645_if1_adc_in_enum);
 
+/* MX-2d [3] [2] */
+static const char * const rt5650_a_dac1_src[] = {
+        "DAC1", "Stereo DAC Mixer"
+};
+
+static SOC_ENUM_SINGLE_DECL(
+        rt5650_a_dac1_l_enum, RT5650_A_DAC_SOUR,
+        RT5650_A_DAC1_L_IN_SFT, rt5650_a_dac1_src);
+
+static const struct snd_kcontrol_new rt5650_a_dac1_l_mux =
+        SOC_DAPM_ENUM("A DAC1 L source", rt5650_a_dac1_l_enum);
+
+static SOC_ENUM_SINGLE_DECL(
+        rt5650_a_dac1_r_enum, RT5650_A_DAC_SOUR,
+        RT5650_A_DAC1_R_IN_SFT, rt5650_a_dac1_src);
+
+static const struct snd_kcontrol_new rt5650_a_dac1_r_mux =
+        SOC_DAPM_ENUM("A DAC1 R source", rt5650_a_dac1_r_enum);
+
+/* MX-2d [1] [0] */
+static const char * const rt5650_a_dac2_src[] = {
+        "Stereo DAC Mixer", "Mono DAC Mixer"
+};
+
+static SOC_ENUM_SINGLE_DECL(
+        rt5650_a_dac2_l_enum, RT5650_A_DAC_SOUR,
+        RT5650_A_DAC2_L_IN_SFT, rt5650_a_dac2_src);
+
+static const struct snd_kcontrol_new rt5650_a_dac2_l_mux =
+        SOC_DAPM_ENUM("A DAC2 L source", rt5650_a_dac2_l_enum);
+
+static SOC_ENUM_SINGLE_DECL(
+        rt5650_a_dac2_r_enum, RT5650_A_DAC_SOUR,
+        RT5650_A_DAC2_R_IN_SFT, rt5650_a_dac2_src);
+
+static const struct snd_kcontrol_new rt5650_a_dac2_r_mux =
+        SOC_DAPM_ENUM("A DAC2 R source", rt5650_a_dac2_r_enum);
+
 /* MX-2F [13:12] */
 static const char * const rt5645_if2_adc_in_src[] = {
         "IF_ADC1", "IF_ADC2", "VAD_ADC"
@@ -1144,18 +1277,23 @@ static void hp_amp_power(struct snd_soc_codec *codec, int on)
 static int rt5645_hp_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5645_priv *rt5645 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
                 hp_amp_power(codec, 1);
                 /* headphone unmute sequence */
-                snd_soc_update_bits(codec, RT5645_DEPOP_M3, RT5645_CP_FQ1_MASK |
-                        RT5645_CP_FQ2_MASK | RT5645_CP_FQ3_MASK,
-                        (RT5645_CP_FQ_192_KHZ << RT5645_CP_FQ1_SFT) |
-                        (RT5645_CP_FQ_12_KHZ << RT5645_CP_FQ2_SFT) |
-                        (RT5645_CP_FQ_192_KHZ << RT5645_CP_FQ3_SFT));
+                if (rt5645->codec_type == CODEC_TYPE_RT5650) {
+                        snd_soc_write(codec, RT5645_DEPOP_M3, 0x0737);
+                } else {
+                        snd_soc_update_bits(codec, RT5645_DEPOP_M3,
+                                RT5645_CP_FQ1_MASK | RT5645_CP_FQ2_MASK |
+                                RT5645_CP_FQ3_MASK,
+                                (RT5645_CP_FQ_192_KHZ << RT5645_CP_FQ1_SFT) |
+                                (RT5645_CP_FQ_12_KHZ << RT5645_CP_FQ2_SFT) |
+                                (RT5645_CP_FQ_192_KHZ << RT5645_CP_FQ3_SFT));
+                }
                 regmap_write(rt5645->regmap,
                         RT5645_PR_BASE + RT5645_MAMP_INT_REG2, 0xfc00);
                 snd_soc_update_bits(codec, RT5645_DEPOP_M1,
@@ -1175,12 +1313,16 @@ static int rt5645_hp_event(struct snd_soc_dapm_widget *w,
 
         case SND_SOC_DAPM_PRE_PMD:
                 /* headphone mute sequence */
-                snd_soc_update_bits(codec, RT5645_DEPOP_M3,
-                        RT5645_CP_FQ1_MASK | RT5645_CP_FQ2_MASK |
-                        RT5645_CP_FQ3_MASK,
-                        (RT5645_CP_FQ_96_KHZ << RT5645_CP_FQ1_SFT) |
-                        (RT5645_CP_FQ_12_KHZ << RT5645_CP_FQ2_SFT) |
-                        (RT5645_CP_FQ_96_KHZ << RT5645_CP_FQ3_SFT));
+                if (rt5645->codec_type == CODEC_TYPE_RT5650) {
+                        snd_soc_write(codec, RT5645_DEPOP_M3, 0x0737);
+                } else {
+                        snd_soc_update_bits(codec, RT5645_DEPOP_M3,
+                                RT5645_CP_FQ1_MASK | RT5645_CP_FQ2_MASK |
+                                RT5645_CP_FQ3_MASK,
+                                (RT5645_CP_FQ_96_KHZ << RT5645_CP_FQ1_SFT) |
+                                (RT5645_CP_FQ_12_KHZ << RT5645_CP_FQ2_SFT) |
+                                (RT5645_CP_FQ_96_KHZ << RT5645_CP_FQ3_SFT));
+                }
                 regmap_write(rt5645->regmap,
                         RT5645_PR_BASE + RT5645_MAMP_INT_REG2, 0xfc00);
                 snd_soc_update_bits(codec, RT5645_DEPOP_M1,
@@ -1205,7 +1347,7 @@ static int rt5645_hp_event(struct snd_soc_dapm_widget *w,
 static int rt5645_spk_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -1232,7 +1374,7 @@ static int rt5645_spk_event(struct snd_soc_dapm_widget *w,
 static int rt5645_lout_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -1262,7 +1404,7 @@ static int rt5645_lout_event(struct snd_soc_dapm_widget *w,
 static int rt5645_bst2_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -1574,6 +1716,17 @@ static const struct snd_soc_dapm_widget rt5645_dapm_widgets[] = {
         SND_SOC_DAPM_OUTPUT("SPOR"),
 };
 
+static const struct snd_soc_dapm_widget rt5650_specific_dapm_widgets[] = {
+        SND_SOC_DAPM_MUX("A DAC1 L Mux", SND_SOC_NOPM,
+                0, 0, &rt5650_a_dac1_l_mux),
+        SND_SOC_DAPM_MUX("A DAC1 R Mux", SND_SOC_NOPM,
+                0, 0, &rt5650_a_dac1_r_mux),
+        SND_SOC_DAPM_MUX("A DAC2 L Mux", SND_SOC_NOPM,
+                0, 0, &rt5650_a_dac2_l_mux),
+        SND_SOC_DAPM_MUX("A DAC2 R Mux", SND_SOC_NOPM,
+                0, 0, &rt5650_a_dac2_r_mux),
+};
+
 static const struct snd_soc_dapm_route rt5645_dapm_routes[] = {
         { "adc stereo1 filter", NULL, "ADC STO1 ASRC", is_using_asrc },
         { "adc stereo2 filter", NULL, "ADC STO2 ASRC", is_using_asrc },
@@ -1779,13 +1932,9 @@ static const struct snd_soc_dapm_route rt5645_dapm_routes[] = {
         { "DAC MIXR", "DAC R2 Switch", "DAC R2 Volume" },
         { "DAC MIXR", "DAC L2 Switch", "DAC L2 Volume" },
 
-        { "DAC L1", NULL, "Stereo DAC MIXL" },
         { "DAC L1", NULL, "PLL1", is_sys_clk_from_pll },
-        { "DAC R1", NULL, "Stereo DAC MIXR" },
         { "DAC R1", NULL, "PLL1", is_sys_clk_from_pll },
-        { "DAC L2", NULL, "Mono DAC MIXL" },
         { "DAC L2", NULL, "PLL1", is_sys_clk_from_pll },
-        { "DAC R2", NULL, "Mono DAC MIXR" },
         { "DAC R2", NULL, "PLL1", is_sys_clk_from_pll },
 
         { "SPK MIXL", "BST1 Switch", "BST1" },
@@ -1874,6 +2023,30 @@ static const struct snd_soc_dapm_route rt5645_dapm_routes[] = {
         { "SPOR", NULL, "SPK amp" },
 };
 
+static const struct snd_soc_dapm_route rt5650_specific_dapm_routes[] = {
+        { "A DAC1 L Mux", "DAC1",  "DAC1 MIXL"},
+        { "A DAC1 L Mux", "Stereo DAC Mixer", "Stereo DAC MIXL"},
+        { "A DAC1 R Mux", "DAC1",  "DAC1 MIXR"},
+        { "A DAC1 R Mux", "Stereo DAC Mixer", "Stereo DAC MIXR"},
+
+        { "A DAC2 L Mux", "Stereo DAC Mixer", "Stereo DAC MIXL"},
+        { "A DAC2 L Mux", "Mono DAC Mixer", "Mono DAC MIXL"},
+        { "A DAC2 R Mux", "Stereo DAC Mixer", "Stereo DAC MIXR"},
+        { "A DAC2 R Mux", "Mono DAC Mixer", "Mono DAC MIXR"},
+
+        { "DAC L1", NULL, "A DAC1 L Mux" },
+        { "DAC R1", NULL, "A DAC1 R Mux" },
+        { "DAC L2", NULL, "A DAC2 L Mux" },
+        { "DAC R2", NULL, "A DAC2 R Mux" },
+};
+
+static const struct snd_soc_dapm_route rt5645_specific_dapm_routes[] = {
+        { "DAC L1", NULL, "Stereo DAC MIXL" },
+        { "DAC R1", NULL, "Stereo DAC MIXR" },
+        { "DAC L2", NULL, "Mono DAC MIXL" },
+        { "DAC R2", NULL, "Mono DAC MIXR" },
+};
+
 static int rt5645_hw_params(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
 {
@@ -2293,6 +2466,22 @@ static int rt5645_probe(struct snd_soc_codec *codec)
 
         rt5645->codec = codec;
 
+        switch (rt5645->codec_type) {
+        case CODEC_TYPE_RT5645:
+                snd_soc_dapm_add_routes(&codec->dapm,
+                        rt5645_specific_dapm_routes,
+                        ARRAY_SIZE(rt5645_specific_dapm_routes));
+                break;
+        case CODEC_TYPE_RT5650:
+                snd_soc_dapm_new_controls(&codec->dapm,
+                        rt5650_specific_dapm_widgets,
+                        ARRAY_SIZE(rt5650_specific_dapm_widgets));
+                snd_soc_dapm_add_routes(&codec->dapm,
+                        rt5650_specific_dapm_routes,
+                        ARRAY_SIZE(rt5650_specific_dapm_routes));
+                break;
+        }
+
         rt5645_set_bias_level(codec, SND_SOC_BIAS_OFF);
 
         snd_soc_update_bits(codec, RT5645_CHARGE_PUMP, 0x0300, 0x0200);
@@ -2424,6 +2613,7 @@ static const struct regmap_config rt5645_regmap = {
 
 static const struct i2c_device_id rt5645_i2c_id[] = {
         { "rt5645", 0 },
+        { "rt5650", 0 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, rt5645_i2c_id);
@@ -2456,9 +2646,18 @@ static int rt5645_i2c_probe(struct i2c_client *i2c,
         }
 
         regmap_read(rt5645->regmap, RT5645_VENDOR_ID2, &val);
-        if (val != RT5645_DEVICE_ID) {
+
+        switch (val) {
+        case RT5645_DEVICE_ID:
+                rt5645->codec_type = CODEC_TYPE_RT5645;
+                break;
+        case RT5650_DEVICE_ID:
+                rt5645->codec_type = CODEC_TYPE_RT5650;
+                break;
+        default:
                 dev_err(&i2c->dev,
-                        "Device with ID register %x is not rt5645\n", val);
+                        "Device with ID register %x is not rt5645 or rt5650\n",
+                        val);
                 return -ENODEV;
         }
 
@@ -2469,6 +2668,14 @@ static int rt5645_i2c_probe(struct i2c_client *i2c,
         if (ret != 0)
                 dev_warn(&i2c->dev, "Failed to apply regmap patch: %d\n", ret);
 
+        if (rt5645->codec_type == CODEC_TYPE_RT5650) {
+                ret = regmap_register_patch(rt5645->regmap, rt5650_init_list,
+                                    ARRAY_SIZE(rt5650_init_list));
+                if (ret != 0)
+                        dev_warn(&i2c->dev, "Apply rt5650 patch failed: %d\n",
+                                           ret);
+        }
+
         if (rt5645->pdata.in2_diff)
                 regmap_update_bits(rt5645->regmap, RT5645_IN2_CTRL,
                                         RT5645_IN_DF2, RT5645_IN_DF2);
diff --git a/sound/soc/codecs/rt5645.h b/sound/soc/codecs/rt5645.h
index a815e36a2bdb..dbfd98c22f4d 100644
--- a/sound/soc/codecs/rt5645.h
+++ b/sound/soc/codecs/rt5645.h
@@ -47,6 +47,7 @@
 #define RT5645_STO_DAC_MIXER                    0x2a
 #define RT5645_MONO_DAC_MIXER                   0x2b
 #define RT5645_DIG_MIXER                        0x2c
+#define RT5650_A_DAC_SOUR                       0x2d
 #define RT5645_DIG_INF1_DATA                    0x2f
 /* Mixer - PDM */
 #define RT5645_PDM_OUT_CTRL                     0x31
@@ -150,6 +151,8 @@
 #define RT5645_IL_CMD                           0xdb
 #define RT5645_IL_CMD2                          0xdc
 #define RT5645_IL_CMD3                          0xdd
+#define RT5650_4BTN_IL_CMD1                     0xdf
+#define RT5650_4BTN_IL_CMD2                     0xe0
 #define RT5645_DRC1_HL_CTRL1                    0xe7
 #define RT5645_DRC2_HL_CTRL1                    0xe9
 #define RT5645_MUTI_DRC_CTRL1                   0xea
@@ -472,6 +475,12 @@
 #define RT5645_DAC_L2_DAC_R_VOL_MASK            (0x1 << 4)
 #define RT5645_DAC_L2_DAC_R_VOL_SFT             4
 
+/* Analog DAC1/2 Input Source Control (0x2d) */
+#define RT5650_A_DAC1_L_IN_SFT                  3
+#define RT5650_A_DAC1_R_IN_SFT                  2
+#define RT5650_A_DAC2_L_IN_SFT                  1
+#define RT5650_A_DAC2_R_IN_SFT                  0
+
 /* Digital Interface Data Control (0x2f) */
 #define RT5645_IF1_ADC2_IN_SEL                  (0x1 << 15)
 #define RT5645_IF1_ADC2_IN_SFT                  15
@@ -1111,50 +1120,27 @@
 #define RT5645_DMIC_2_M_NOR                     (0x0 << 8)
 #define RT5645_DMIC_2_M_ASYN                    (0x1 << 8)
 
+/* ASRC clock source selection (0x84, 0x85) */
+#define RT5645_CLK_SEL_SYS                      (0x0)
+#define RT5645_CLK_SEL_I2S1_ASRC                (0x1)
+#define RT5645_CLK_SEL_I2S2_ASRC                (0x2)
+#define RT5645_CLK_SEL_SYS2                     (0x5)
+
 /* ASRC Control 2 (0x84) */
-#define RT5645_MDA_L_M_MASK                     (0x1 << 15)
-#define RT5645_MDA_L_M_SFT                      15
-#define RT5645_MDA_L_M_NOR                      (0x0 << 15)
-#define RT5645_MDA_L_M_ASYN                     (0x1 << 15)
-#define RT5645_MDA_R_M_MASK                     (0x1 << 14)
-#define RT5645_MDA_R_M_SFT                      14
-#define RT5645_MDA_R_M_NOR                      (0x0 << 14)
-#define RT5645_MDA_R_M_ASYN                     (0x1 << 14)
-#define RT5645_MAD_L_M_MASK                     (0x1 << 13)
-#define RT5645_MAD_L_M_SFT                      13
-#define RT5645_MAD_L_M_NOR                      (0x0 << 13)
-#define RT5645_MAD_L_M_ASYN                     (0x1 << 13)
-#define RT5645_MAD_R_M_MASK                     (0x1 << 12)
-#define RT5645_MAD_R_M_SFT                      12
-#define RT5645_MAD_R_M_NOR                      (0x0 << 12)
-#define RT5645_MAD_R_M_ASYN                     (0x1 << 12)
-#define RT5645_ADC_M_MASK                       (0x1 << 11)
-#define RT5645_ADC_M_SFT                        11
-#define RT5645_ADC_M_NOR                        (0x0 << 11)
-#define RT5645_ADC_M_ASYN                       (0x1 << 11)
-#define RT5645_STO_DAC_M_MASK                   (0x1 << 5)
-#define RT5645_STO_DAC_M_SFT                    5
-#define RT5645_STO_DAC_M_NOR                    (0x0 << 5)
-#define RT5645_STO_DAC_M_ASYN                   (0x1 << 5)
-#define RT5645_I2S1_R_D_MASK                    (0x1 << 4)
-#define RT5645_I2S1_R_D_SFT                     4
-#define RT5645_I2S1_R_D_DIS                     (0x0 << 4)
-#define RT5645_I2S1_R_D_EN                      (0x1 << 4)
-#define RT5645_I2S2_R_D_MASK                    (0x1 << 3)
-#define RT5645_I2S2_R_D_SFT                     3
-#define RT5645_I2S2_R_D_DIS                     (0x0 << 3)
-#define RT5645_I2S2_R_D_EN                      (0x1 << 3)
-#define RT5645_PRE_SCLK_MASK                    (0x3)
-#define RT5645_PRE_SCLK_SFT                     0
-#define RT5645_PRE_SCLK_512                     (0x0)
-#define RT5645_PRE_SCLK_1024                    (0x1)
-#define RT5645_PRE_SCLK_2048                    (0x2)
+#define RT5645_DA_STO_CLK_SEL_MASK              (0xf << 12)
+#define RT5645_DA_STO_CLK_SEL_SFT               12
+#define RT5645_DA_MONOL_CLK_SEL_MASK            (0xf << 8)
+#define RT5645_DA_MONOL_CLK_SEL_SFT             8
+#define RT5645_DA_MONOR_CLK_SEL_MASK            (0xf << 4)
+#define RT5645_DA_MONOR_CLK_SEL_SFT             4
+#define RT5645_AD_STO1_CLK_SEL_MASK             (0xf << 0)
+#define RT5645_AD_STO1_CLK_SEL_SFT              0
 
 /* ASRC Control 3 (0x85) */
-#define RT5645_I2S1_RATE_MASK                   (0xf << 12)
-#define RT5645_I2S1_RATE_SFT                    12
-#define RT5645_I2S2_RATE_MASK                   (0xf << 8)
-#define RT5645_I2S2_RATE_SFT                    8
+#define RT5645_AD_MONOL_CLK_SEL_MASK            (0xf << 4)
+#define RT5645_AD_MONOL_CLK_SEL_SFT             4
+#define RT5645_AD_MONOR_CLK_SEL_MASK            (0xf << 0)
+#define RT5645_AD_MONOR_CLK_SEL_SFT             0
 
 /* ASRC Control 4 (0x89) */
 #define RT5645_I2S1_PD_MASK                     (0x7 << 12)
@@ -2175,6 +2161,24 @@ enum {
         RT5645_DMIC_DATA_GPIO11,
 };
 
+enum {
+        CODEC_TYPE_RT5645,
+        CODEC_TYPE_RT5650,
+};
+
+/* filter mask */
+enum {
+        RT5645_DA_STEREO_FILTER = 0x1,
+        RT5645_DA_MONO_L_FILTER = (0x1 << 1),
+        RT5645_DA_MONO_R_FILTER = (0x1 << 2),
+        RT5645_AD_STEREO_FILTER = (0x1 << 3),
+        RT5645_AD_MONO_L_FILTER = (0x1 << 4),
+        RT5645_AD_MONO_R_FILTER = (0x1 << 5),
+};
+
+int rt5645_sel_asrc_clk_src(struct snd_soc_codec *codec,
+                unsigned int filter_mask, unsigned int clk_src);
+
 struct rt5645_priv {
         struct snd_soc_codec *codec;
         struct rt5645_platform_data pdata;
@@ -2184,6 +2188,7 @@ struct rt5645_priv {
         struct snd_soc_jack *mic_jack;
         struct delayed_work jack_detect_work;
 
+        int codec_type;
         int sysclk;
         int sysclk_src;
         int lrck[RT5645_AIFS];
diff --git a/sound/soc/codecs/rt5651.c b/sound/soc/codecs/rt5651.c
index bb0a3ab5416c..9f4c7be6d798 100644
--- a/sound/soc/codecs/rt5651.c
+++ b/sound/soc/codecs/rt5651.c
@@ -376,7 +376,7 @@ static const struct snd_kcontrol_new rt5651_snd_controls[] = {
 static int set_dmic_clk(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5651_priv *rt5651 = snd_soc_codec_get_drvdata(codec);
         int idx = -EINVAL;
 
@@ -394,9 +394,10 @@ static int set_dmic_clk(struct snd_soc_dapm_widget *w,
 static int is_sysclk_from_pll(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int val;
 
-        val = snd_soc_read(source->codec, RT5651_GLB_CLK);
+        val = snd_soc_read(codec, RT5651_GLB_CLK);
         val &= RT5651_SCLK_SRC_MASK;
         if (val == RT5651_SCLK_SRC_PLL1)
                 return 1;
@@ -731,7 +732,7 @@ static const struct snd_kcontrol_new rt5651_pdm_r_mux =
 static int rt5651_amp_power_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5651_priv *rt5651 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -769,7 +770,7 @@ static int rt5651_amp_power_event(struct snd_soc_dapm_widget *w,
 static int rt5651_hp_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5651_priv *rt5651 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -813,7 +814,8 @@ static int rt5651_hp_event(struct snd_soc_dapm_widget *w,
 static int rt5651_hp_post_event(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5651_priv *rt5651 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -833,7 +835,7 @@ static int rt5651_hp_post_event(struct snd_soc_dapm_widget *w,
 static int rt5651_bst1_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -856,7 +858,7 @@ static int rt5651_bst1_event(struct snd_soc_dapm_widget *w,
 static int rt5651_bst2_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -879,7 +881,7 @@ static int rt5651_bst2_event(struct snd_soc_dapm_widget *w,
 static int rt5651_bst3_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
diff --git a/sound/soc/codecs/rt5670.c b/sound/soc/codecs/rt5670.c
index 8a0833de1665..fd102613d20d 100644
--- a/sound/soc/codecs/rt5670.c
+++ b/sound/soc/codecs/rt5670.c
@@ -14,10 +14,12 @@
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
+#include <linux/pm_runtime.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/acpi.h>
 #include <linux/spi/spi.h>
+#include <linux/dmi.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -223,7 +225,6 @@ static bool rt5670_volatile_register(struct device *dev, unsigned int reg)
         case RT5670_ADC_EQ_CTRL1:
         case RT5670_EQ_CTRL1:
         case RT5670_ALC_CTRL_1:
-        case RT5670_IRQ_CTRL1:
         case RT5670_IRQ_CTRL2:
         case RT5670_INT_IRQ_ST:
         case RT5670_IL_CMD:
@@ -498,7 +499,7 @@ static const struct snd_kcontrol_new rt5670_snd_controls[] = {
 static int set_dmic_clk(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5670_priv *rt5670 = snd_soc_codec_get_drvdata(codec);
         int idx = -EINVAL;
 
@@ -515,9 +516,10 @@ static int set_dmic_clk(struct snd_soc_dapm_widget *w,
 static int is_sys_clk_from_pll(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int val;
 
-        val = snd_soc_read(source->codec, RT5670_GLB_CLK);
+        val = snd_soc_read(codec, RT5670_GLB_CLK);
         val &= RT5670_SCLK_SRC_MASK;
         if (val == RT5670_SCLK_SRC_PLL1)
                 return 1;
@@ -528,6 +530,7 @@ static int is_sys_clk_from_pll(struct snd_soc_dapm_widget *source,
 static int is_using_asrc(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int reg, shift, val;
 
         switch (source->shift) {
@@ -563,7 +566,7 @@ static int is_using_asrc(struct snd_soc_dapm_widget *source,
                 return 0;
         }
 
-        val = (snd_soc_read(source->codec, reg) >> shift) & 0xf;
+        val = (snd_soc_read(codec, reg) >> shift) & 0xf;
         switch (val) {
         case 1:
         case 2:
@@ -588,6 +591,89 @@ static int can_use_asrc(struct snd_soc_dapm_widget *source,
         return 0;
 }
 
+
+/**
+ * rt5670_sel_asrc_clk_src - select ASRC clock source for a set of filters
+ * @codec: SoC audio codec device.
+ * @filter_mask: mask of filters.
+ * @clk_src: clock source
+ *
+ * The ASRC function is for asynchronous MCLK and LRCK. Also, since RT5670 can
+ * only support standard 32fs or 64fs i2s format, ASRC should be enabled to
+ * support special i2s clock format such as Intel's 100fs(100 * sampling rate).
+ * ASRC function will track i2s clock and generate a corresponding system clock
+ * for codec. This function provides an API to select the clock source for a
+ * set of filters specified by the mask. And the codec driver will turn on ASRC
+ * for these filters if ASRC is selected as their clock source.
+ */
+int rt5670_sel_asrc_clk_src(struct snd_soc_codec *codec,
+                            unsigned int filter_mask, unsigned int clk_src)
+{
+        unsigned int asrc2_mask = 0, asrc2_value = 0;
+        unsigned int asrc3_mask = 0, asrc3_value = 0;
+
+        if (clk_src > RT5670_CLK_SEL_SYS3)
+                return -EINVAL;
+
+        if (filter_mask & RT5670_DA_STEREO_FILTER) {
+                asrc2_mask |= RT5670_DA_STO_CLK_SEL_MASK;
+                asrc2_value = (asrc2_value & ~RT5670_DA_STO_CLK_SEL_MASK)
+                                | (clk_src <<  RT5670_DA_STO_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5670_DA_MONO_L_FILTER) {
+                asrc2_mask |= RT5670_DA_MONOL_CLK_SEL_MASK;
+                asrc2_value = (asrc2_value & ~RT5670_DA_MONOL_CLK_SEL_MASK)
+                                | (clk_src <<  RT5670_DA_MONOL_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5670_DA_MONO_R_FILTER) {
+                asrc2_mask |= RT5670_DA_MONOR_CLK_SEL_MASK;
+                asrc2_value = (asrc2_value & ~RT5670_DA_MONOR_CLK_SEL_MASK)
+                                | (clk_src <<  RT5670_DA_MONOR_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5670_AD_STEREO_FILTER) {
+                asrc2_mask |= RT5670_AD_STO1_CLK_SEL_MASK;
+                asrc2_value = (asrc2_value & ~RT5670_AD_STO1_CLK_SEL_MASK)
+                                | (clk_src <<  RT5670_AD_STO1_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5670_AD_MONO_L_FILTER) {
+                asrc3_mask |= RT5670_AD_MONOL_CLK_SEL_MASK;
+                asrc3_value = (asrc3_value & ~RT5670_AD_MONOL_CLK_SEL_MASK)
+                                | (clk_src <<  RT5670_AD_MONOL_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5670_AD_MONO_R_FILTER)  {
+                asrc3_mask |= RT5670_AD_MONOR_CLK_SEL_MASK;
+                asrc3_value = (asrc3_value & ~RT5670_AD_MONOR_CLK_SEL_MASK)
+                                | (clk_src <<  RT5670_AD_MONOR_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5670_UP_RATE_FILTER) {
+                asrc3_mask |= RT5670_UP_CLK_SEL_MASK;
+                asrc3_value = (asrc3_value & ~RT5670_UP_CLK_SEL_MASK)
+                                | (clk_src <<  RT5670_UP_CLK_SEL_SFT);
+        }
+
+        if (filter_mask & RT5670_DOWN_RATE_FILTER) {
+                asrc3_mask |= RT5670_DOWN_CLK_SEL_MASK;
+                asrc3_value = (asrc3_value & ~RT5670_DOWN_CLK_SEL_MASK)
+                                | (clk_src <<  RT5670_DOWN_CLK_SEL_SFT);
+        }
+
+        if (asrc2_mask)
+                snd_soc_update_bits(codec, RT5670_ASRC_2,
+                                    asrc2_mask, asrc2_value);
+
+        if (asrc3_mask)
+                snd_soc_update_bits(codec, RT5670_ASRC_3,
+                                    asrc3_mask, asrc3_value);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(rt5670_sel_asrc_clk_src);
+
 /* Digital Mixer */
 static const struct snd_kcontrol_new rt5670_sto1_adc_l_mix[] = {
         SOC_DAPM_SINGLE("ADC1 Switch", RT5670_STO1_ADC_MIXER,
@@ -1146,7 +1232,7 @@ static const struct snd_kcontrol_new rt5670_vad_adc_mux =
 static int rt5670_hp_power_event(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5670_priv *rt5670 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -1182,7 +1268,7 @@ static int rt5670_hp_power_event(struct snd_soc_dapm_widget *w,
 static int rt5670_hp_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5670_priv *rt5670 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -1232,7 +1318,7 @@ static int rt5670_hp_event(struct snd_soc_dapm_widget *w,
 static int rt5670_bst1_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -1255,7 +1341,7 @@ static int rt5670_bst1_event(struct snd_soc_dapm_widget *w,
 static int rt5670_bst2_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
@@ -2188,6 +2274,13 @@ static int rt5670_set_dai_sysclk(struct snd_soc_dai *dai,
         if (freq == rt5670->sysclk && clk_id == rt5670->sysclk_src)
                 return 0;
 
+        if (rt5670->pdata.jd_mode) {
+                if (clk_id == RT5670_SCLK_S_PLL1)
+                        snd_soc_dapm_force_enable_pin(&codec->dapm, "PLL1");
+                else
+                        snd_soc_dapm_disable_pin(&codec->dapm, "PLL1");
+                snd_soc_dapm_sync(&codec->dapm);
+        }
         switch (clk_id) {
         case RT5670_SCLK_S_MCLK:
                 reg_val |= RT5670_SCLK_SRC_MCLK;
@@ -2522,6 +2615,7 @@ static struct snd_soc_codec_driver soc_codec_dev_rt5670 = {
 static const struct regmap_config rt5670_regmap = {
         .reg_bits = 8,
         .val_bits = 16,
+        .use_single_rw = true,
         .max_register = RT5670_VENDOR_ID2 + 1 + (ARRAY_SIZE(rt5670_ranges) *
                                                RT5670_PR_SPACING),
         .volatile_reg = rt5670_volatile_register,
@@ -2549,6 +2643,17 @@ static struct acpi_device_id rt5670_acpi_match[] = {
 MODULE_DEVICE_TABLE(acpi, rt5670_acpi_match);
 #endif
 
+static const struct dmi_system_id dmi_platform_intel_braswell[] = {
+        {
+                .ident = "Intel Braswell",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Intel Corporation"),
+                        DMI_MATCH(DMI_BOARD_NAME, "Braswell CRB"),
+                },
+        },
+        {}
+};
+
 static int rt5670_i2c_probe(struct i2c_client *i2c,
                     const struct i2c_device_id *id)
 {
@@ -2568,6 +2673,12 @@ static int rt5670_i2c_probe(struct i2c_client *i2c,
         if (pdata)
                 rt5670->pdata = *pdata;
 
+        if (dmi_check_system(dmi_platform_intel_braswell)) {
+                rt5670->pdata.dmic_en = true;
+                rt5670->pdata.dmic1_data_pin = RT5670_DMIC_DATA_IN2P;
+                rt5670->pdata.jd_mode = 1;
+        }
+
         rt5670->regmap = devm_regmap_init_i2c(i2c, &rt5670_regmap);
         if (IS_ERR(rt5670->regmap)) {
                 ret = PTR_ERR(rt5670->regmap);
@@ -2591,6 +2702,12 @@ static int rt5670_i2c_probe(struct i2c_client *i2c,
 
         regmap_write(rt5670->regmap, RT5670_RESET, 0);
 
+        regmap_read(rt5670->regmap, RT5670_VENDOR_ID, &val);
+        if (val >= 4)
+                regmap_write(rt5670->regmap, RT5670_GPIO_CTRL3, 0x0980);
+        else
+                regmap_write(rt5670->regmap, RT5670_GPIO_CTRL3, 0x0d00);
+
         ret = regmap_register_patch(rt5670->regmap, init_list,
                                     ARRAY_SIZE(init_list));
         if (ret != 0)
@@ -2609,6 +2726,10 @@ static int rt5670_i2c_probe(struct i2c_client *i2c,
         }
 
         if (rt5670->pdata.jd_mode) {
+                regmap_update_bits(rt5670->regmap, RT5670_GLB_CLK,
+                                   RT5670_SCLK_SRC_MASK, RT5670_SCLK_SRC_RCCLK);
+                rt5670->sysclk = 0;
+                rt5670->sysclk_src = RT5670_SCLK_S_RCCLK;
                 regmap_update_bits(rt5670->regmap, RT5670_PWR_ANLG1,
                                    RT5670_PWR_MB, RT5670_PWR_MB);
                 regmap_update_bits(rt5670->regmap, RT5670_PWR_ANLG2,
@@ -2716,18 +2837,26 @@ static int rt5670_i2c_probe(struct i2c_client *i2c,
 
         }
 
+        pm_runtime_enable(&i2c->dev);
+        pm_request_idle(&i2c->dev);
+
         ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_rt5670,
                         rt5670_dai, ARRAY_SIZE(rt5670_dai));
         if (ret < 0)
                 goto err;
 
+        pm_runtime_put(&i2c->dev);
+
         return 0;
 err:
+        pm_runtime_disable(&i2c->dev);
+
         return ret;
 }
 
 static int rt5670_i2c_remove(struct i2c_client *i2c)
 {
+        pm_runtime_disable(&i2c->dev);
         snd_soc_unregister_codec(&i2c->dev);
 
         return 0;
diff --git a/sound/soc/codecs/rt5670.h b/sound/soc/codecs/rt5670.h
index d11b9c207e26..21f8e18c13c4 100644
--- a/sound/soc/codecs/rt5670.h
+++ b/sound/soc/codecs/rt5670.h
@@ -1023,50 +1023,33 @@
 #define RT5670_DMIC_2_M_NOR                     (0x0 << 8)
 #define RT5670_DMIC_2_M_ASYN                    (0x1 << 8)
 
+/* ASRC clock source selection (0x84, 0x85) */
+#define RT5670_CLK_SEL_SYS                      (0x0)
+#define RT5670_CLK_SEL_I2S1_ASRC                (0x1)
+#define RT5670_CLK_SEL_I2S2_ASRC                (0x2)
+#define RT5670_CLK_SEL_I2S3_ASRC                (0x3)
+#define RT5670_CLK_SEL_SYS2                     (0x5)
+#define RT5670_CLK_SEL_SYS3                     (0x6)
+
 /* ASRC Control 2 (0x84) */
-#define RT5670_MDA_L_M_MASK                     (0x1 << 15)
-#define RT5670_MDA_L_M_SFT                      15
-#define RT5670_MDA_L_M_NOR                      (0x0 << 15)
-#define RT5670_MDA_L_M_ASYN                     (0x1 << 15)
-#define RT5670_MDA_R_M_MASK                     (0x1 << 14)
-#define RT5670_MDA_R_M_SFT                      14
-#define RT5670_MDA_R_M_NOR                      (0x0 << 14)
-#define RT5670_MDA_R_M_ASYN                     (0x1 << 14)
-#define RT5670_MAD_L_M_MASK                     (0x1 << 13)
-#define RT5670_MAD_L_M_SFT                      13
-#define RT5670_MAD_L_M_NOR                      (0x0 << 13)
-#define RT5670_MAD_L_M_ASYN                     (0x1 << 13)
-#define RT5670_MAD_R_M_MASK                     (0x1 << 12)
-#define RT5670_MAD_R_M_SFT                      12
-#define RT5670_MAD_R_M_NOR                      (0x0 << 12)
-#define RT5670_MAD_R_M_ASYN                     (0x1 << 12)
-#define RT5670_ADC_M_MASK                       (0x1 << 11)
-#define RT5670_ADC_M_SFT                        11
-#define RT5670_ADC_M_NOR                        (0x0 << 11)
-#define RT5670_ADC_M_ASYN                       (0x1 << 11)
-#define RT5670_STO_DAC_M_MASK                   (0x1 << 5)
-#define RT5670_STO_DAC_M_SFT                    5
-#define RT5670_STO_DAC_M_NOR                    (0x0 << 5)
-#define RT5670_STO_DAC_M_ASYN                   (0x1 << 5)
-#define RT5670_I2S1_R_D_MASK                    (0x1 << 4)
-#define RT5670_I2S1_R_D_SFT                     4
-#define RT5670_I2S1_R_D_DIS                     (0x0 << 4)
-#define RT5670_I2S1_R_D_EN                      (0x1 << 4)
-#define RT5670_I2S2_R_D_MASK                    (0x1 << 3)
-#define RT5670_I2S2_R_D_SFT                     3
-#define RT5670_I2S2_R_D_DIS                     (0x0 << 3)
-#define RT5670_I2S2_R_D_EN                      (0x1 << 3)
-#define RT5670_PRE_SCLK_MASK                    (0x3)
-#define RT5670_PRE_SCLK_SFT                     0
-#define RT5670_PRE_SCLK_512                     (0x0)
-#define RT5670_PRE_SCLK_1024                    (0x1)
-#define RT5670_PRE_SCLK_2048                    (0x2)
+#define RT5670_DA_STO_CLK_SEL_MASK              (0xf << 12)
+#define RT5670_DA_STO_CLK_SEL_SFT               12
+#define RT5670_DA_MONOL_CLK_SEL_MASK            (0xf << 8)
+#define RT5670_DA_MONOL_CLK_SEL_SFT             8
+#define RT5670_DA_MONOR_CLK_SEL_MASK            (0xf << 4)
+#define RT5670_DA_MONOR_CLK_SEL_SFT             4
+#define RT5670_AD_STO1_CLK_SEL_MASK             (0xf << 0)
+#define RT5670_AD_STO1_CLK_SEL_SFT              0
 
 /* ASRC Control 3 (0x85) */
-#define RT5670_I2S1_RATE_MASK                   (0xf << 12)
-#define RT5670_I2S1_RATE_SFT                    12
-#define RT5670_I2S2_RATE_MASK                   (0xf << 8)
-#define RT5670_I2S2_RATE_SFT                    8
+#define RT5670_UP_CLK_SEL_MASK                  (0xf << 12)
+#define RT5670_UP_CLK_SEL_SFT                   12
+#define RT5670_DOWN_CLK_SEL_MASK                (0xf << 8)
+#define RT5670_DOWN_CLK_SEL_SFT                 8
+#define RT5670_AD_MONOL_CLK_SEL_MASK            (0xf << 4)
+#define RT5670_AD_MONOL_CLK_SEL_SFT             4
+#define RT5670_AD_MONOR_CLK_SEL_MASK            (0xf << 0)
+#define RT5670_AD_MONOR_CLK_SEL_SFT             0
 
 /* ASRC Control 4 (0x89) */
 #define RT5670_I2S1_PD_MASK                     (0x7 << 12)
@@ -1983,6 +1966,21 @@ enum {
         RT5670_DMIC_DATA_GPIO5,
 };
 
+/* filter mask */
+enum {
+        RT5670_DA_STEREO_FILTER = 0x1,
+        RT5670_DA_MONO_L_FILTER = (0x1 << 1),
+        RT5670_DA_MONO_R_FILTER = (0x1 << 2),
+        RT5670_AD_STEREO_FILTER = (0x1 << 3),
+        RT5670_AD_MONO_L_FILTER = (0x1 << 4),
+        RT5670_AD_MONO_R_FILTER = (0x1 << 5),
+        RT5670_UP_RATE_FILTER   = (0x1 << 6),
+        RT5670_DOWN_RATE_FILTER = (0x1 << 7),
+};
+
+int rt5670_sel_asrc_clk_src(struct snd_soc_codec *codec,
+                            unsigned int filter_mask, unsigned int clk_src);
+
 struct rt5670_priv {
         struct snd_soc_codec *codec;
         struct rt5670_platform_data pdata;
diff --git a/sound/soc/codecs/rt5677.c b/sound/soc/codecs/rt5677.c
index 918ada9738b0..fb9c20eace3f 100644
--- a/sound/soc/codecs/rt5677.c
+++ b/sound/soc/codecs/rt5677.c
@@ -702,6 +702,9 @@ static int rt5677_set_dsp_vad(struct snd_soc_codec *codec, bool on)
         static bool activity;
         int ret;
 
+        if (!IS_ENABLED(CONFIG_SND_SOC_RT5677_SPI))
+                return -ENXIO;
+
         if (on && !activity) {
                 activity = true;
 
@@ -896,7 +899,7 @@ static const struct snd_kcontrol_new rt5677_snd_controls[] = {
 static int set_dmic_clk(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
         int idx = rl6231_calc_dmic_clk(rt5677->sysclk);
 
@@ -911,7 +914,8 @@ static int set_dmic_clk(struct snd_soc_dapm_widget *w,
 static int is_sys_clk_from_pll(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
-        struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(source->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
+        struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
         unsigned int val;
 
         regmap_read(rt5677->regmap, RT5677_GLB_CLK1, &val);
@@ -922,6 +926,101 @@ static int is_sys_clk_from_pll(struct snd_soc_dapm_widget *source,
                 return 0;
 }
 
+static int is_using_asrc(struct snd_soc_dapm_widget *source,
+                         struct snd_soc_dapm_widget *sink)
+{
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
+        struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
+        unsigned int reg, shift, val;
+
+        if (source->reg == RT5677_ASRC_1) {
+                switch (source->shift) {
+                case 12:
+                        reg = RT5677_ASRC_4;
+                        shift = 0;
+                        break;
+                case 13:
+                        reg = RT5677_ASRC_4;
+                        shift = 4;
+                        break;
+                case 14:
+                        reg = RT5677_ASRC_4;
+                        shift = 8;
+                        break;
+                case 15:
+                        reg = RT5677_ASRC_4;
+                        shift = 12;
+                        break;
+                default:
+                        return 0;
+                }
+        } else {
+                switch (source->shift) {
+                case 0:
+                        reg = RT5677_ASRC_6;
+                        shift = 8;
+                        break;
+                case 1:
+                        reg = RT5677_ASRC_6;
+                        shift = 12;
+                        break;
+                case 2:
+                        reg = RT5677_ASRC_5;
+                        shift = 0;
+                        break;
+                case 3:
+                        reg = RT5677_ASRC_5;
+                        shift = 4;
+                        break;
+                case 4:
+                        reg = RT5677_ASRC_5;
+                        shift = 8;
+                        break;
+                case 5:
+                        reg = RT5677_ASRC_5;
+                        shift = 12;
+                        break;
+                case 12:
+                        reg = RT5677_ASRC_3;
+                        shift = 0;
+                        break;
+                case 13:
+                        reg = RT5677_ASRC_3;
+                        shift = 4;
+                        break;
+                case 14:
+                        reg = RT5677_ASRC_3;
+                        shift = 12;
+                        break;
+                default:
+                        return 0;
+                }
+        }
+
+        regmap_read(rt5677->regmap, reg, &val);
+        val = (val >> shift) & 0xf;
+
+        switch (val) {
+        case 1 ... 6:
+                return 1;
+        default:
+                return 0;
+        }
+
+}
+
+static int can_use_asrc(struct snd_soc_dapm_widget *source,
+                         struct snd_soc_dapm_widget *sink)
+{
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
+        struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
+
+        if (rt5677->sysclk > rt5677->lrck[RT5677_AIF1] * 384)
+                return 1;
+
+        return 0;
+}
+
 /* Digital Mixer */
 static const struct snd_kcontrol_new rt5677_sto1_adc_l_mix[] = {
         SOC_DAPM_SINGLE("ADC1 Switch", RT5677_STO1_ADC_MIXER,
@@ -2031,7 +2130,7 @@ static const struct snd_kcontrol_new rt5677_if2_dac7_tdm_sel_mux =
 static int rt5677_bst1_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -2055,7 +2154,7 @@ static int rt5677_bst1_event(struct snd_soc_dapm_widget *w,
 static int rt5677_bst2_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -2079,7 +2178,7 @@ static int rt5677_bst2_event(struct snd_soc_dapm_widget *w,
 static int rt5677_set_pll1_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -2101,7 +2200,7 @@ static int rt5677_set_pll1_event(struct snd_soc_dapm_widget *w,
 static int rt5677_set_pll2_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -2123,7 +2222,7 @@ static int rt5677_set_pll2_event(struct snd_soc_dapm_widget *w,
 static int rt5677_set_micbias1_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -2150,7 +2249,7 @@ static int rt5677_set_micbias1_event(struct snd_soc_dapm_widget *w,
 static int rt5677_if1_adc_tdm_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
         unsigned int value;
 
@@ -2173,7 +2272,7 @@ static int rt5677_if1_adc_tdm_event(struct snd_soc_dapm_widget *w,
 static int rt5677_if2_adc_tdm_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
         unsigned int value;
 
@@ -2196,7 +2295,7 @@ static int rt5677_if2_adc_tdm_event(struct snd_soc_dapm_widget *w,
 static int rt5677_vref_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -2226,6 +2325,45 @@ static const struct snd_soc_dapm_widget rt5677_dapm_widgets[] = {
                 0, rt5677_set_pll2_event, SND_SOC_DAPM_PRE_PMU |
                 SND_SOC_DAPM_POST_PMU),
 
+        /* ASRC */
+        SND_SOC_DAPM_SUPPLY_S("I2S1 ASRC", 1, RT5677_ASRC_1, 0, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY_S("I2S2 ASRC", 1, RT5677_ASRC_1, 1, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY_S("I2S3 ASRC", 1, RT5677_ASRC_1, 2, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY_S("I2S4 ASRC", 1, RT5677_ASRC_1, 3, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY_S("DAC STO ASRC", 1, RT5677_ASRC_2, 14, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY_S("DAC MONO2 L ASRC", 1, RT5677_ASRC_2, 13, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("DAC MONO2 R ASRC", 1, RT5677_ASRC_2, 12, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("DAC MONO3 L ASRC", 1, RT5677_ASRC_1, 15, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("DAC MONO3 R ASRC", 1, RT5677_ASRC_1, 14, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("DAC MONO4 L ASRC", 1, RT5677_ASRC_1, 13, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("DAC MONO4 R ASRC", 1, RT5677_ASRC_1, 12, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("DMIC STO1 ASRC", 1, RT5677_ASRC_2, 11, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("DMIC STO2 ASRC", 1, RT5677_ASRC_2, 10, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("DMIC STO3 ASRC", 1, RT5677_ASRC_2, 9, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("DMIC STO4 ASRC", 1, RT5677_ASRC_2, 8, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("DMIC MONO L ASRC", 1, RT5677_ASRC_2, 7, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("DMIC MONO R ASRC", 1, RT5677_ASRC_2, 6, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("ADC STO1 ASRC", 1, RT5677_ASRC_2, 5, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY_S("ADC STO2 ASRC", 1, RT5677_ASRC_2, 4, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY_S("ADC STO3 ASRC", 1, RT5677_ASRC_2, 3, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY_S("ADC STO4 ASRC", 1, RT5677_ASRC_2, 2, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY_S("ADC MONO L ASRC", 1, RT5677_ASRC_2, 1, 0, NULL,
+                0),
+        SND_SOC_DAPM_SUPPLY_S("ADC MONO R ASRC", 1, RT5677_ASRC_2, 0, 0, NULL,
+                0),
+
         /* Input Side */
         /* micbias */
         SND_SOC_DAPM_SUPPLY("MICBIAS1", RT5677_PWR_ANLG2, RT5677_PWR_MB1_BIT,
@@ -2656,10 +2794,18 @@ static const struct snd_soc_dapm_widget rt5677_dapm_widgets[] = {
         /* DAC Mixer */
         SND_SOC_DAPM_SUPPLY("dac stereo1 filter", RT5677_PWR_DIG2,
                 RT5677_PWR_DAC_S1F_BIT, 0, NULL, 0),
-        SND_SOC_DAPM_SUPPLY("dac mono left filter", RT5677_PWR_DIG2,
+        SND_SOC_DAPM_SUPPLY("dac mono2 left filter", RT5677_PWR_DIG2,
                 RT5677_PWR_DAC_M2F_L_BIT, 0, NULL, 0),
-        SND_SOC_DAPM_SUPPLY("dac mono right filter", RT5677_PWR_DIG2,
+        SND_SOC_DAPM_SUPPLY("dac mono2 right filter", RT5677_PWR_DIG2,
                 RT5677_PWR_DAC_M2F_R_BIT, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY("dac mono3 left filter", RT5677_PWR_DIG2,
+                RT5677_PWR_DAC_M3F_L_BIT, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY("dac mono3 right filter", RT5677_PWR_DIG2,
+                RT5677_PWR_DAC_M3F_R_BIT, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY("dac mono4 left filter", RT5677_PWR_DIG2,
+                RT5677_PWR_DAC_M4F_L_BIT, 0, NULL, 0),
+        SND_SOC_DAPM_SUPPLY("dac mono4 right filter", RT5677_PWR_DIG2,
+                RT5677_PWR_DAC_M4F_R_BIT, 0, NULL, 0),
 
         SND_SOC_DAPM_MIXER("Stereo DAC MIXL", SND_SOC_NOPM, 0, 0,
                 rt5677_sto1_dac_l_mix, ARRAY_SIZE(rt5677_sto1_dac_l_mix)),
@@ -2732,6 +2878,31 @@ static const struct snd_soc_dapm_widget rt5677_dapm_widgets[] = {
 };
 
 static const struct snd_soc_dapm_route rt5677_dapm_routes[] = {
+        { "Stereo1 DMIC Mux", NULL, "DMIC STO1 ASRC", can_use_asrc },
+        { "Stereo2 DMIC Mux", NULL, "DMIC STO2 ASRC", can_use_asrc },
+        { "Stereo3 DMIC Mux", NULL, "DMIC STO3 ASRC", can_use_asrc },
+        { "Stereo4 DMIC Mux", NULL, "DMIC STO4 ASRC", can_use_asrc },
+        { "Mono DMIC L Mux", NULL, "DMIC MONO L ASRC", can_use_asrc },
+        { "Mono DMIC R Mux", NULL, "DMIC MONO R ASRC", can_use_asrc },
+        { "I2S1", NULL, "I2S1 ASRC", can_use_asrc},
+        { "I2S2", NULL, "I2S2 ASRC", can_use_asrc},
+        { "I2S3", NULL, "I2S3 ASRC", can_use_asrc},
+        { "I2S4", NULL, "I2S4 ASRC", can_use_asrc},
+
+        { "dac stereo1 filter", NULL, "DAC STO ASRC", is_using_asrc },
+        { "dac mono2 left filter", NULL, "DAC MONO2 L ASRC", is_using_asrc },
+        { "dac mono2 right filter", NULL, "DAC MONO2 R ASRC", is_using_asrc },
+        { "dac mono3 left filter", NULL, "DAC MONO3 L ASRC", is_using_asrc },
+        { "dac mono3 right filter", NULL, "DAC MONO3 R ASRC", is_using_asrc },
+        { "dac mono4 left filter", NULL, "DAC MONO4 L ASRC", is_using_asrc },
+        { "dac mono4 right filter", NULL, "DAC MONO4 R ASRC", is_using_asrc },
+        { "adc stereo1 filter", NULL, "ADC STO1 ASRC", is_using_asrc },
+        { "adc stereo2 filter", NULL, "ADC STO2 ASRC", is_using_asrc },
+        { "adc stereo3 filter", NULL, "ADC STO3 ASRC", is_using_asrc },
+        { "adc stereo4 filter", NULL, "ADC STO4 ASRC", is_using_asrc },
+        { "adc mono left filter", NULL, "ADC MONO L ASRC", is_using_asrc },
+        { "adc mono right filter", NULL, "ADC MONO R ASRC", is_using_asrc },
+
         { "DMIC1", NULL, "DMIC L1" },
         { "DMIC1", NULL, "DMIC R1" },
         { "DMIC2", NULL, "DMIC L2" },
@@ -2862,8 +3033,6 @@ static const struct snd_soc_dapm_route rt5677_dapm_routes[] = {
 
         { "Stereo1 ADC MIXL", NULL, "Sto1 ADC MIXL" },
         { "Stereo1 ADC MIXL", NULL, "adc stereo1 filter" },
-        { "adc stereo1 filter", NULL, "PLL1", is_sys_clk_from_pll },
-
         { "Stereo1 ADC MIXR", NULL, "Sto1 ADC MIXR" },
         { "Stereo1 ADC MIXR", NULL, "adc stereo1 filter" },
         { "adc stereo1 filter", NULL, "PLL1", is_sys_clk_from_pll },
@@ -2884,8 +3053,6 @@ static const struct snd_soc_dapm_route rt5677_dapm_routes[] = {
 
         { "Stereo2 ADC MIXL", NULL, "Stereo2 ADC LR Mux" },
         { "Stereo2 ADC MIXL", NULL, "adc stereo2 filter" },
-        { "adc stereo2 filter", NULL, "PLL1", is_sys_clk_from_pll },
-
         { "Stereo2 ADC MIXR", NULL, "Sto2 ADC MIXR" },
         { "Stereo2 ADC MIXR", NULL, "adc stereo2 filter" },
         { "adc stereo2 filter", NULL, "PLL1", is_sys_clk_from_pll },
@@ -2900,8 +3067,6 @@ static const struct snd_soc_dapm_route rt5677_dapm_routes[] = {
 
         { "Stereo3 ADC MIXL", NULL, "Sto3 ADC MIXL" },
         { "Stereo3 ADC MIXL", NULL, "adc stereo3 filter" },
-        { "adc stereo3 filter", NULL, "PLL1", is_sys_clk_from_pll },
-
         { "Stereo3 ADC MIXR", NULL, "Sto3 ADC MIXR" },
         { "Stereo3 ADC MIXR", NULL, "adc stereo3 filter" },
         { "adc stereo3 filter", NULL, "PLL1", is_sys_clk_from_pll },
@@ -2916,8 +3081,6 @@ static const struct snd_soc_dapm_route rt5677_dapm_routes[] = {
 
         { "Stereo4 ADC MIXL", NULL, "Sto4 ADC MIXL" },
         { "Stereo4 ADC MIXL", NULL, "adc stereo4 filter" },
-        { "adc stereo4 filter", NULL, "PLL1", is_sys_clk_from_pll },
-
         { "Stereo4 ADC MIXR", NULL, "Sto4 ADC MIXR" },
         { "Stereo4 ADC MIXR", NULL, "adc stereo4 filter" },
         { "adc stereo4 filter", NULL, "PLL1", is_sys_clk_from_pll },
@@ -3121,8 +3284,8 @@ static const struct snd_soc_dapm_route rt5677_dapm_routes[] = {
         { "IB45 Bypass Mux", "Bypass", "IB45 Mux" },
         { "IB45 Bypass Mux", "Pass SRC", "IB45 Mux" },
 
-        { "IB6 Mux", "IF1 DAC 6", "IF1 DAC6" },
-        { "IB6 Mux", "IF2 DAC 6", "IF2 DAC6" },
+        { "IB6 Mux", "IF1 DAC 6", "IF1 DAC6 Mux" },
+        { "IB6 Mux", "IF2 DAC 6", "IF2 DAC6 Mux" },
         { "IB6 Mux", "SLB DAC 6", "SLB DAC6" },
         { "IB6 Mux", "STO4 ADC MIX L", "Stereo4 ADC MIXL" },
         { "IB6 Mux", "IF4 DAC L", "IF4 DAC L" },
@@ -3130,8 +3293,8 @@ static const struct snd_soc_dapm_route rt5677_dapm_routes[] = {
         { "IB6 Mux", "STO2 ADC MIX L", "Stereo2 ADC MIXL" },
         { "IB6 Mux", "STO3 ADC MIX L", "Stereo3 ADC MIXL" },
 
-        { "IB7 Mux", "IF1 DAC 7", "IF1 DAC7" },
-        { "IB7 Mux", "IF2 DAC 7", "IF2 DAC7" },
+        { "IB7 Mux", "IF1 DAC 7", "IF1 DAC7 Mux" },
+        { "IB7 Mux", "IF2 DAC 7", "IF2 DAC7 Mux" },
         { "IB7 Mux", "SLB DAC 7", "SLB DAC7" },
         { "IB7 Mux", "STO4 ADC MIX R", "Stereo4 ADC MIXR" },
         { "IB7 Mux", "IF4 DAC R", "IF4 DAC R" },
@@ -3466,23 +3629,21 @@ static const struct snd_soc_dapm_route rt5677_dapm_routes[] = {
 
         { "DAC1 MIXL", "Stereo ADC Switch", "ADDA1 Mux" },
         { "DAC1 MIXL", "DAC1 Switch", "DAC1 Mux" },
-        { "DAC1 MIXL", NULL, "dac stereo1 filter" },
         { "DAC1 MIXR", "Stereo ADC Switch", "ADDA1 Mux" },
         { "DAC1 MIXR", "DAC1 Switch", "DAC1 Mux" },
-        { "DAC1 MIXR", NULL, "dac stereo1 filter" },
 
         { "DAC1 FS", NULL, "DAC1 MIXL" },
         { "DAC1 FS", NULL, "DAC1 MIXR" },
 
-        { "DAC2 L Mux", "IF1 DAC 2", "IF1 DAC2" },
-        { "DAC2 L Mux", "IF2 DAC 2", "IF2 DAC2" },
+        { "DAC2 L Mux", "IF1 DAC 2", "IF1 DAC2 Mux" },
+        { "DAC2 L Mux", "IF2 DAC 2", "IF2 DAC2 Mux" },
         { "DAC2 L Mux", "IF3 DAC L", "IF3 DAC L" },
         { "DAC2 L Mux", "IF4 DAC L", "IF4 DAC L" },
         { "DAC2 L Mux", "SLB DAC 2", "SLB DAC2" },
         { "DAC2 L Mux", "OB 2", "OutBound2" },
 
-        { "DAC2 R Mux", "IF1 DAC 3", "IF1 DAC3" },
-        { "DAC2 R Mux", "IF2 DAC 3", "IF2 DAC3" },
+        { "DAC2 R Mux", "IF1 DAC 3", "IF1 DAC3 Mux" },
+        { "DAC2 R Mux", "IF2 DAC 3", "IF2 DAC3 Mux" },
         { "DAC2 R Mux", "IF3 DAC R", "IF3 DAC R" },
         { "DAC2 R Mux", "IF4 DAC R", "IF4 DAC R" },
         { "DAC2 R Mux", "SLB DAC 3", "SLB DAC3" },
@@ -3490,29 +3651,29 @@ static const struct snd_soc_dapm_route rt5677_dapm_routes[] = {
         { "DAC2 R Mux", "Haptic Generator", "Haptic Generator" },
         { "DAC2 R Mux", "VAD ADC", "VAD ADC Mux" },
 
-        { "DAC3 L Mux", "IF1 DAC 4", "IF1 DAC4" },
-        { "DAC3 L Mux", "IF2 DAC 4", "IF2 DAC4" },
+        { "DAC3 L Mux", "IF1 DAC 4", "IF1 DAC4 Mux" },
+        { "DAC3 L Mux", "IF2 DAC 4", "IF2 DAC4 Mux" },
         { "DAC3 L Mux", "IF3 DAC L", "IF3 DAC L" },
         { "DAC3 L Mux", "IF4 DAC L", "IF4 DAC L" },
         { "DAC3 L Mux", "SLB DAC 4", "SLB DAC4" },
         { "DAC3 L Mux", "OB 4", "OutBound4" },
 
-        { "DAC3 R Mux", "IF1 DAC 5", "IF1 DAC4" },
-        { "DAC3 R Mux", "IF2 DAC 5", "IF2 DAC4" },
+        { "DAC3 R Mux", "IF1 DAC 5", "IF1 DAC5 Mux" },
+        { "DAC3 R Mux", "IF2 DAC 5", "IF2 DAC5 Mux" },
         { "DAC3 R Mux", "IF3 DAC R", "IF3 DAC R" },
         { "DAC3 R Mux", "IF4 DAC R", "IF4 DAC R" },
         { "DAC3 R Mux", "SLB DAC 5", "SLB DAC5" },
         { "DAC3 R Mux", "OB 5", "OutBound5" },
 
-        { "DAC4 L Mux", "IF1 DAC 6", "IF1 DAC6" },
-        { "DAC4 L Mux", "IF2 DAC 6", "IF2 DAC6" },
+        { "DAC4 L Mux", "IF1 DAC 6", "IF1 DAC6 Mux" },
+        { "DAC4 L Mux", "IF2 DAC 6", "IF2 DAC6 Mux" },
         { "DAC4 L Mux", "IF3 DAC L", "IF3 DAC L" },
         { "DAC4 L Mux", "IF4 DAC L", "IF4 DAC L" },
         { "DAC4 L Mux", "SLB DAC 6", "SLB DAC6" },
         { "DAC4 L Mux", "OB 6", "OutBound6" },
 
-        { "DAC4 R Mux", "IF1 DAC 7", "IF1 DAC7" },
-        { "DAC4 R Mux", "IF2 DAC 7", "IF2 DAC7" },
+        { "DAC4 R Mux", "IF1 DAC 7", "IF1 DAC7 Mux" },
+        { "DAC4 R Mux", "IF2 DAC 7", "IF2 DAC7 Mux" },
         { "DAC4 R Mux", "IF3 DAC R", "IF3 DAC R" },
         { "DAC4 R Mux", "IF4 DAC R", "IF4 DAC R" },
         { "DAC4 R Mux", "SLB DAC 7", "SLB DAC7" },
@@ -3536,35 +3697,46 @@ static const struct snd_soc_dapm_route rt5677_dapm_routes[] = {
         { "Stereo DAC MIXR", "DAC2 R Switch", "DAC2 R Mux" },
         { "Stereo DAC MIXR", "DAC1 L Switch", "DAC1 MIXL" },
         { "Stereo DAC MIXR", NULL, "dac stereo1 filter" },
+        { "dac stereo1 filter", NULL, "PLL1", is_sys_clk_from_pll },
 
         { "Mono DAC MIXL", "ST L Switch", "Sidetone Mux" },
         { "Mono DAC MIXL", "DAC1 L Switch", "DAC1 MIXL" },
         { "Mono DAC MIXL", "DAC2 L Switch", "DAC2 L Mux" },
         { "Mono DAC MIXL", "DAC2 R Switch", "DAC2 R Mux" },
-        { "Mono DAC MIXL", NULL, "dac mono left filter" },
+        { "Mono DAC MIXL", NULL, "dac mono2 left filter" },
+        { "dac mono2 left filter", NULL, "PLL1", is_sys_clk_from_pll },
         { "Mono DAC MIXR", "ST R Switch", "Sidetone Mux" },
         { "Mono DAC MIXR", "DAC1 R Switch", "DAC1 MIXR" },
         { "Mono DAC MIXR", "DAC2 R Switch", "DAC2 R Mux" },
         { "Mono DAC MIXR", "DAC2 L Switch", "DAC2 L Mux" },
-        { "Mono DAC MIXR", NULL, "dac mono right filter" },
+        { "Mono DAC MIXR", NULL, "dac mono2 right filter" },
+        { "dac mono2 right filter", NULL, "PLL1", is_sys_clk_from_pll },
 
         { "DD1 MIXL", "Sto DAC Mix L Switch", "Stereo DAC MIXL" },
         { "DD1 MIXL", "Mono DAC Mix L Switch", "Mono DAC MIXL" },
         { "DD1 MIXL", "DAC3 L Switch", "DAC3 L Mux" },
         { "DD1 MIXL", "DAC3 R Switch", "DAC3 R Mux" },
+        { "DD1 MIXL", NULL, "dac mono3 left filter" },
+        { "dac mono3 left filter", NULL, "PLL1", is_sys_clk_from_pll },
         { "DD1 MIXR", "Sto DAC Mix R Switch", "Stereo DAC MIXR" },
         { "DD1 MIXR", "Mono DAC Mix R Switch", "Mono DAC MIXR" },
         { "DD1 MIXR", "DAC3 L Switch", "DAC3 L Mux" },
         { "DD1 MIXR", "DAC3 R Switch", "DAC3 R Mux" },
+        { "DD1 MIXR", NULL, "dac mono3 right filter" },
+        { "dac mono3 right filter", NULL, "PLL1", is_sys_clk_from_pll },
 
         { "DD2 MIXL", "Sto DAC Mix L Switch", "Stereo DAC MIXL" },
         { "DD2 MIXL", "Mono DAC Mix L Switch", "Mono DAC MIXL" },
         { "DD2 MIXL", "DAC4 L Switch", "DAC4 L Mux" },
         { "DD2 MIXL", "DAC4 R Switch", "DAC4 R Mux" },
+        { "DD2 MIXL", NULL, "dac mono4 left filter" },
+        { "dac mono4 left filter", NULL, "PLL1", is_sys_clk_from_pll },
         { "DD2 MIXR", "Sto DAC Mix R Switch", "Stereo DAC MIXR" },
         { "DD2 MIXR", "Mono DAC Mix R Switch", "Mono DAC MIXR" },
         { "DD2 MIXR", "DAC4 L Switch", "DAC4 L Mux" },
         { "DD2 MIXR", "DAC4 R Switch", "DAC4 R Mux" },
+        { "DD2 MIXR", NULL, "dac mono4 right filter" },
+        { "dac mono4 right filter", NULL, "PLL1", is_sys_clk_from_pll },
 
         { "Stereo DAC MIX", NULL, "Stereo DAC MIXL" },
         { "Stereo DAC MIX", NULL, "Stereo DAC MIXR" },
@@ -3586,11 +3758,8 @@ static const struct snd_soc_dapm_route rt5677_dapm_routes[] = {
         { "DAC3 SRC Mux", "DD MIX2L", "DD2 MIXL" },
 
         { "DAC 1", NULL, "DAC12 SRC Mux" },
-        { "DAC 1", NULL, "PLL1", is_sys_clk_from_pll },
         { "DAC 2", NULL, "DAC12 SRC Mux" },
-        { "DAC 2", NULL, "PLL1", is_sys_clk_from_pll },
         { "DAC 3", NULL, "DAC3 SRC Mux" },
-        { "DAC 3", NULL, "PLL1", is_sys_clk_from_pll },
 
         { "PDM1 L Mux", "STO1 DAC MIX", "Stereo DAC MIXL" },
         { "PDM1 L Mux", "MONO DAC MIX", "Mono DAC MIXL" },
@@ -3937,7 +4106,8 @@ static int rt5677_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
                         unsigned int rx_mask, int slots, int slot_width)
 {
         struct snd_soc_codec *codec = dai->codec;
-        unsigned int val = 0;
+        struct rt5677_priv *rt5677 = snd_soc_codec_get_drvdata(codec);
+        unsigned int val = 0, slot_width_25 = 0;
 
         if (rx_mask || tx_mask)
                 val |= (1 << 12);
@@ -3961,6 +4131,8 @@ static int rt5677_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
         case 20:
                 val |= (1 << 8);
                 break;
+        case 25:
+                slot_width_25 = 0x8080;
         case 24:
                 val |= (2 << 8);
                 break;
@@ -3974,10 +4146,16 @@ static int rt5677_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
 
         switch (dai->id) {
         case RT5677_AIF1:
-                snd_soc_update_bits(codec, RT5677_TDM1_CTRL1, 0x1f00, val);
+                regmap_update_bits(rt5677->regmap, RT5677_TDM1_CTRL1, 0x1f00,
+                        val);
+                regmap_update_bits(rt5677->regmap, RT5677_DIG_MISC, 0x8000,
+                        slot_width_25);
                 break;
         case RT5677_AIF2:
-                snd_soc_update_bits(codec, RT5677_TDM2_CTRL1, 0x1f00, val);
+                regmap_update_bits(rt5677->regmap, RT5677_TDM2_CTRL1, 0x1f00,
+                        val);
+                regmap_update_bits(rt5677->regmap, RT5677_DIG_MISC, 0x80,
+                        slot_width_25);
                 break;
         default:
                 break;
@@ -4762,6 +4940,11 @@ static int rt5677_i2c_probe(struct i2c_client *i2c,
                                         RT5677_GPIO5_DIR_OUT);
         }
 
+        if (rt5677->pdata.micbias1_vdd_3v3)
+                regmap_update_bits(rt5677->regmap, RT5677_MICBIAS,
+                        RT5677_MICBIAS1_CTRL_VDD_MASK,
+                        RT5677_MICBIAS1_CTRL_VDD_3_3V);
+
         rt5677_init_gpio(i2c);
         rt5677_init_irq(i2c);
 
diff --git a/sound/soc/codecs/sgtl5000.c b/sound/soc/codecs/sgtl5000.c
index aa98be32bb60..e182e6569bbd 100644
--- a/sound/soc/codecs/sgtl5000.c
+++ b/sound/soc/codecs/sgtl5000.c
@@ -155,18 +155,19 @@ struct sgtl5000_priv {
 static int mic_bias_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
                 /* change mic bias resistor */
-                snd_soc_update_bits(w->codec, SGTL5000_CHIP_MIC_CTRL,
+                snd_soc_update_bits(codec, SGTL5000_CHIP_MIC_CTRL,
                         SGTL5000_BIAS_R_MASK,
                         sgtl5000->micbias_resistor << SGTL5000_BIAS_R_SHIFT);
                 break;
 
         case SND_SOC_DAPM_PRE_PMD:
-                snd_soc_update_bits(w->codec, SGTL5000_CHIP_MIC_CTRL,
+                snd_soc_update_bits(codec, SGTL5000_CHIP_MIC_CTRL,
                                 SGTL5000_BIAS_R_MASK, 0);
                 break;
         }
@@ -181,11 +182,12 @@ static int mic_bias_event(struct snd_soc_dapm_widget *w,
 static int power_vag_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         const u32 mask = SGTL5000_DAC_POWERUP | SGTL5000_ADC_POWERUP;
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
-                snd_soc_update_bits(w->codec, SGTL5000_CHIP_ANA_POWER,
+                snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
                         SGTL5000_VAG_POWERUP, SGTL5000_VAG_POWERUP);
                 break;
 
@@ -195,9 +197,9 @@ static int power_vag_event(struct snd_soc_dapm_widget *w,
                  * operational to prevent inadvertently starving the
                  * other one of them.
                  */
-                if ((snd_soc_read(w->codec, SGTL5000_CHIP_ANA_POWER) &
+                if ((snd_soc_read(codec, SGTL5000_CHIP_ANA_POWER) &
                                 mask) != mask) {
-                        snd_soc_update_bits(w->codec, SGTL5000_CHIP_ANA_POWER,
+                        snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
                                 SGTL5000_VAG_POWERUP, 0);
                         msleep(400);
                 }
diff --git a/sound/soc/codecs/sn95031.c b/sound/soc/codecs/sn95031.c
index 1f451a1946eb..47b257e41809 100644
--- a/sound/soc/codecs/sn95031.c
+++ b/sound/soc/codecs/sn95031.c
@@ -233,16 +233,18 @@ static int sn95031_set_vaud_bias(struct snd_soc_codec *codec,
 static int sn95031_vhs_event(struct snd_soc_dapm_widget *w,
                     struct snd_kcontrol *kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+
         if (SND_SOC_DAPM_EVENT_ON(event)) {
                 pr_debug("VHS SND_SOC_DAPM_EVENT_ON doing rail startup now\n");
                 /* power up the rail */
-                snd_soc_write(w->codec, SN95031_VHSP, 0x3D);
-                snd_soc_write(w->codec, SN95031_VHSN, 0x3F);
+                snd_soc_write(codec, SN95031_VHSP, 0x3D);
+                snd_soc_write(codec, SN95031_VHSN, 0x3F);
                 msleep(1);
         } else if (SND_SOC_DAPM_EVENT_OFF(event)) {
                 pr_debug("VHS SND_SOC_DAPM_EVENT_OFF doing rail shutdown\n");
-                snd_soc_write(w->codec, SN95031_VHSP, 0xC4);
-                snd_soc_write(w->codec, SN95031_VHSN, 0x04);
+                snd_soc_write(codec, SN95031_VHSP, 0xC4);
+                snd_soc_write(codec, SN95031_VHSN, 0x04);
         }
         return 0;
 }
@@ -250,14 +252,16 @@ static int sn95031_vhs_event(struct snd_soc_dapm_widget *w,
 static int sn95031_vihf_event(struct snd_soc_dapm_widget *w,
                     struct snd_kcontrol *kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+
         if (SND_SOC_DAPM_EVENT_ON(event)) {
                 pr_debug("VIHF SND_SOC_DAPM_EVENT_ON doing rail startup now\n");
                 /* power up the rail */
-                snd_soc_write(w->codec, SN95031_VIHF, 0x27);
+                snd_soc_write(codec, SN95031_VIHF, 0x27);
                 msleep(1);
         } else if (SND_SOC_DAPM_EVENT_OFF(event)) {
                 pr_debug("VIHF SND_SOC_DAPM_EVENT_OFF doing rail shutdown\n");
-                snd_soc_write(w->codec, SN95031_VIHF, 0x24);
+                snd_soc_write(codec, SN95031_VIHF, 0x24);
         }
         return 0;
 }
@@ -265,6 +269,7 @@ static int sn95031_vihf_event(struct snd_soc_dapm_widget *w,
 static int sn95031_dmic12_event(struct snd_soc_dapm_widget *w,
                         struct snd_kcontrol *k, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         unsigned int ldo = 0, clk_dir = 0, data_dir = 0;
 
         if (SND_SOC_DAPM_EVENT_ON(event)) {
@@ -273,15 +278,16 @@ static int sn95031_dmic12_event(struct snd_soc_dapm_widget *w,
                 data_dir = BIT(7);
         }
         /* program DMIC LDO, clock and set clock */
-        snd_soc_update_bits(w->codec, SN95031_MICBIAS, BIT(5)|BIT(4), ldo);
-        snd_soc_update_bits(w->codec, SN95031_DMICBUF0123, BIT(0), clk_dir);
-        snd_soc_update_bits(w->codec, SN95031_DMICBUF0123, BIT(7), data_dir);
+        snd_soc_update_bits(codec, SN95031_MICBIAS, BIT(5)|BIT(4), ldo);
+        snd_soc_update_bits(codec, SN95031_DMICBUF0123, BIT(0), clk_dir);
+        snd_soc_update_bits(codec, SN95031_DMICBUF0123, BIT(7), data_dir);
         return 0;
 }
 
 static int sn95031_dmic34_event(struct snd_soc_dapm_widget *w,
                         struct snd_kcontrol *k, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         unsigned int ldo = 0, clk_dir = 0, data_dir = 0;
 
         if (SND_SOC_DAPM_EVENT_ON(event)) {
@@ -290,22 +296,23 @@ static int sn95031_dmic34_event(struct snd_soc_dapm_widget *w,
                 data_dir = BIT(1);
         }
         /* program DMIC LDO, clock and set clock */
-        snd_soc_update_bits(w->codec, SN95031_MICBIAS, BIT(5)|BIT(4), ldo);
-        snd_soc_update_bits(w->codec, SN95031_DMICBUF0123, BIT(2), clk_dir);
-        snd_soc_update_bits(w->codec, SN95031_DMICBUF45, BIT(1), data_dir);
+        snd_soc_update_bits(codec, SN95031_MICBIAS, BIT(5)|BIT(4), ldo);
+        snd_soc_update_bits(codec, SN95031_DMICBUF0123, BIT(2), clk_dir);
+        snd_soc_update_bits(codec, SN95031_DMICBUF45, BIT(1), data_dir);
         return 0;
 }
 
 static int sn95031_dmic56_event(struct snd_soc_dapm_widget *w,
                         struct snd_kcontrol *k, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         unsigned int ldo = 0;
 
         if (SND_SOC_DAPM_EVENT_ON(event))
                 ldo = BIT(7)|BIT(6);
 
         /* program DMIC LDO */
-        snd_soc_update_bits(w->codec, SN95031_MICBIAS, BIT(7)|BIT(6), ldo);
+        snd_soc_update_bits(codec, SN95031_MICBIAS, BIT(7)|BIT(6), ldo);
         return 0;
 }
 
diff --git a/sound/soc/codecs/sta32x.c b/sound/soc/codecs/sta32x.c
index 7e18200dd6a9..3a1343fa109b 100644
--- a/sound/soc/codecs/sta32x.c
+++ b/sound/soc/codecs/sta32x.c
@@ -24,8 +24,11 @@
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/i2c.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
 #include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
+#include <linux/gpio/consumer.h>
 #include <linux/slab.h>
 #include <linux/workqueue.h>
 #include <sound/core.h>
@@ -102,6 +105,35 @@ static const struct reg_default sta32x_regs[] = {
         { 0x2c, 0x0c },
 };
 
+static const struct regmap_range sta32x_write_regs_range[] = {
+        regmap_reg_range(STA32X_CONFA,  STA32X_AUTO2),
+        regmap_reg_range(STA32X_C1CFG,  STA32X_FDRC2),
+};
+
+static const struct regmap_range sta32x_read_regs_range[] = {
+        regmap_reg_range(STA32X_CONFA,  STA32X_AUTO2),
+        regmap_reg_range(STA32X_C1CFG,  STA32X_FDRC2),
+};
+
+static const struct regmap_range sta32x_volatile_regs_range[] = {
+        regmap_reg_range(STA32X_CFADDR2, STA32X_CFUD),
+};
+
+static const struct regmap_access_table sta32x_write_regs = {
+        .yes_ranges =   sta32x_write_regs_range,
+        .n_yes_ranges = ARRAY_SIZE(sta32x_write_regs_range),
+};
+
+static const struct regmap_access_table sta32x_read_regs = {
+        .yes_ranges =   sta32x_read_regs_range,
+        .n_yes_ranges = ARRAY_SIZE(sta32x_read_regs_range),
+};
+
+static const struct regmap_access_table sta32x_volatile_regs = {
+        .yes_ranges =   sta32x_volatile_regs_range,
+        .n_yes_ranges = ARRAY_SIZE(sta32x_volatile_regs_range),
+};
+
 /* regulator power supply names */
 static const char *sta32x_supply_names[] = {
         "Vdda", /* analog supply, 3.3VV */
@@ -122,6 +154,8 @@ struct sta32x_priv {
         u32 coef_shadow[STA32X_COEF_COUNT];
         struct delayed_work watchdog_work;
         int shutdown;
+        struct gpio_desc *gpiod_nreset;
+        struct mutex coeff_lock;
 };
 
 static const DECLARE_TLV_DB_SCALE(mvol_tlv, -12700, 50, 1);
@@ -155,37 +189,32 @@ static const char *sta32x_limiter_release_rate[] = {
         "0.5116", "0.1370", "0.0744", "0.0499", "0.0360", "0.0299",
         "0.0264", "0.0208", "0.0198", "0.0172", "0.0147", "0.0137",
         "0.0134", "0.0117", "0.0110", "0.0104" };
-
-static const unsigned int sta32x_limiter_ac_attack_tlv[] = {
-        TLV_DB_RANGE_HEAD(2),
+static DECLARE_TLV_DB_RANGE(sta32x_limiter_ac_attack_tlv,
         0, 7, TLV_DB_SCALE_ITEM(-1200, 200, 0),
         8, 16, TLV_DB_SCALE_ITEM(300, 100, 0),
-};
+);
 
-static const unsigned int sta32x_limiter_ac_release_tlv[] = {
-        TLV_DB_RANGE_HEAD(5),
+static DECLARE_TLV_DB_RANGE(sta32x_limiter_ac_release_tlv,
         0, 0, TLV_DB_SCALE_ITEM(TLV_DB_GAIN_MUTE, 0, 0),
         1, 1, TLV_DB_SCALE_ITEM(-2900, 0, 0),
         2, 2, TLV_DB_SCALE_ITEM(-2000, 0, 0),
         3, 8, TLV_DB_SCALE_ITEM(-1400, 200, 0),
         8, 16, TLV_DB_SCALE_ITEM(-700, 100, 0),
-};
+);
 
-static const unsigned int sta32x_limiter_drc_attack_tlv[] = {
-        TLV_DB_RANGE_HEAD(3),
+static DECLARE_TLV_DB_RANGE(sta32x_limiter_drc_attack_tlv,
         0, 7, TLV_DB_SCALE_ITEM(-3100, 200, 0),
         8, 13, TLV_DB_SCALE_ITEM(-1600, 100, 0),
         14, 16, TLV_DB_SCALE_ITEM(-1000, 300, 0),
-};
+);
 
-static const unsigned int sta32x_limiter_drc_release_tlv[] = {
-        TLV_DB_RANGE_HEAD(5),
+static DECLARE_TLV_DB_RANGE(sta32x_limiter_drc_release_tlv,
         0, 0, TLV_DB_SCALE_ITEM(TLV_DB_GAIN_MUTE, 0, 0),
         1, 2, TLV_DB_SCALE_ITEM(-3800, 200, 0),
         3, 4, TLV_DB_SCALE_ITEM(-3300, 200, 0),
         5, 12, TLV_DB_SCALE_ITEM(-3000, 200, 0),
         13, 16, TLV_DB_SCALE_ITEM(-1500, 300, 0),
-};
+);
 
 static SOC_ENUM_SINGLE_DECL(sta32x_drc_ac_enum,
                             STA32X_CONFD, STA32X_CONFD_DRC_SHIFT,
@@ -244,29 +273,42 @@ static int sta32x_coefficient_get(struct snd_kcontrol *kcontrol,
                                   struct snd_ctl_elem_value *ucontrol)
 {
         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+        struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
         int numcoef = kcontrol->private_value >> 16;
         int index = kcontrol->private_value & 0xffff;
-        unsigned int cfud;
-        int i;
+        unsigned int cfud, val;
+        int i, ret = 0;
+
+        mutex_lock(&sta32x->coeff_lock);
 
         /* preserve reserved bits in STA32X_CFUD */
-        cfud = snd_soc_read(codec, STA32X_CFUD) & 0xf0;
-        /* chip documentation does not say if the bits are self clearing,
-         * so do it explicitly */
-        snd_soc_write(codec, STA32X_CFUD, cfud);
+        regmap_read(sta32x->regmap, STA32X_CFUD, &cfud);
+        cfud &= 0xf0;
+        /*
+         * chip documentation does not say if the bits are self clearing,
+         * so do it explicitly
+         */
+        regmap_write(sta32x->regmap, STA32X_CFUD, cfud);
 
-        snd_soc_write(codec, STA32X_CFADDR2, index);
-        if (numcoef == 1)
-                snd_soc_write(codec, STA32X_CFUD, cfud | 0x04);
-        else if (numcoef == 5)
-                snd_soc_write(codec, STA32X_CFUD, cfud | 0x08);
-        else
-                return -EINVAL;
-        for (i = 0; i < 3 * numcoef; i++)
-                ucontrol->value.bytes.data[i] =
-                        snd_soc_read(codec, STA32X_B1CF1 + i);
+        regmap_write(sta32x->regmap, STA32X_CFADDR2, index);
+        if (numcoef == 1) {
+                regmap_write(sta32x->regmap, STA32X_CFUD, cfud | 0x04);
+        } else if (numcoef == 5) {
+                regmap_write(sta32x->regmap, STA32X_CFUD, cfud | 0x08);
+        } else {
+                ret = -EINVAL;
+                goto exit_unlock;
+        }
 
-        return 0;
+        for (i = 0; i < 3 * numcoef; i++) {
+                regmap_read(sta32x->regmap, STA32X_B1CF1 + i, &val);
+                ucontrol->value.bytes.data[i] = val;
+        }
+
+exit_unlock:
+        mutex_unlock(&sta32x->coeff_lock);
+
+        return ret;
 }
 
 static int sta32x_coefficient_put(struct snd_kcontrol *kcontrol,
@@ -280,24 +322,27 @@ static int sta32x_coefficient_put(struct snd_kcontrol *kcontrol,
         int i;
 
         /* preserve reserved bits in STA32X_CFUD */
-        cfud = snd_soc_read(codec, STA32X_CFUD) & 0xf0;
-        /* chip documentation does not say if the bits are self clearing,
-         * so do it explicitly */
-        snd_soc_write(codec, STA32X_CFUD, cfud);
+        regmap_read(sta32x->regmap, STA32X_CFUD, &cfud);
+        cfud &= 0xf0;
+        /*
+         * chip documentation does not say if the bits are self clearing,
+         * so do it explicitly
+         */
+        regmap_write(sta32x->regmap, STA32X_CFUD, cfud);
 
-        snd_soc_write(codec, STA32X_CFADDR2, index);
+        regmap_write(sta32x->regmap, STA32X_CFADDR2, index);
         for (i = 0; i < numcoef && (index + i < STA32X_COEF_COUNT); i++)
                 sta32x->coef_shadow[index + i] =
                           (ucontrol->value.bytes.data[3 * i] << 16)
                         | (ucontrol->value.bytes.data[3 * i + 1] << 8)
                         | (ucontrol->value.bytes.data[3 * i + 2]);
         for (i = 0; i < 3 * numcoef; i++)
-                snd_soc_write(codec, STA32X_B1CF1 + i,
-                              ucontrol->value.bytes.data[i]);
+                regmap_write(sta32x->regmap, STA32X_B1CF1 + i,
+                             ucontrol->value.bytes.data[i]);
         if (numcoef == 1)
-                snd_soc_write(codec, STA32X_CFUD, cfud | 0x01);
+                regmap_write(sta32x->regmap, STA32X_CFUD, cfud | 0x01);
         else if (numcoef == 5)
-                snd_soc_write(codec, STA32X_CFUD, cfud | 0x02);
+                regmap_write(sta32x->regmap, STA32X_CFUD, cfud | 0x02);
         else
                 return -EINVAL;
 
@@ -311,20 +356,23 @@ static int sta32x_sync_coef_shadow(struct snd_soc_codec *codec)
         int i;
 
         /* preserve reserved bits in STA32X_CFUD */
-        cfud = snd_soc_read(codec, STA32X_CFUD) & 0xf0;
+        regmap_read(sta32x->regmap, STA32X_CFUD, &cfud);
+        cfud &= 0xf0;
 
         for (i = 0; i < STA32X_COEF_COUNT; i++) {
-                snd_soc_write(codec, STA32X_CFADDR2, i);
-                snd_soc_write(codec, STA32X_B1CF1,
-                              (sta32x->coef_shadow[i] >> 16) & 0xff);
-                snd_soc_write(codec, STA32X_B1CF2,
-                              (sta32x->coef_shadow[i] >> 8) & 0xff);
-                snd_soc_write(codec, STA32X_B1CF3,
-                              (sta32x->coef_shadow[i]) & 0xff);
-                /* chip documentation does not say if the bits are
-                 * self-clearing, so do it explicitly */
-                snd_soc_write(codec, STA32X_CFUD, cfud);
-                snd_soc_write(codec, STA32X_CFUD, cfud | 0x01);
+                regmap_write(sta32x->regmap, STA32X_CFADDR2, i);
+                regmap_write(sta32x->regmap, STA32X_B1CF1,
+                             (sta32x->coef_shadow[i] >> 16) & 0xff);
+                regmap_write(sta32x->regmap, STA32X_B1CF2,
+                             (sta32x->coef_shadow[i] >> 8) & 0xff);
+                regmap_write(sta32x->regmap, STA32X_B1CF3,
+                             (sta32x->coef_shadow[i]) & 0xff);
+                /*
+                 * chip documentation does not say if the bits are
+                 * self-clearing, so do it explicitly
+                 */
+                regmap_write(sta32x->regmap, STA32X_CFUD, cfud);
+                regmap_write(sta32x->regmap, STA32X_CFUD, cfud | 0x01);
         }
         return 0;
 }
@@ -336,11 +384,11 @@ static int sta32x_cache_sync(struct snd_soc_codec *codec)
         int rc;
 
         /* mute during register sync */
-        mute = snd_soc_read(codec, STA32X_MMUTE);
-        snd_soc_write(codec, STA32X_MMUTE, mute | STA32X_MMUTE_MMUTE);
+        regmap_read(sta32x->regmap, STA32X_MMUTE, &mute);
+        regmap_write(sta32x->regmap, STA32X_MMUTE, mute | STA32X_MMUTE_MMUTE);
         sta32x_sync_coef_shadow(codec);
         rc = regcache_sync(sta32x->regmap);
-        snd_soc_write(codec, STA32X_MMUTE, mute);
+        regmap_write(sta32x->regmap, STA32X_MMUTE, mute);
         return rc;
 }
 
@@ -508,17 +556,12 @@ static struct {
 };
 
 /* MCLK to fs clock ratios */
-static struct {
-        int ratio;
-        int mcs;
-} mclk_ratios[3][7] = {
-        { { 768, 0 }, { 512, 1 }, { 384, 2 }, { 256, 3 },
-          { 128, 4 }, { 576, 5 }, { 0, 0 } },
-        { { 384, 2 }, { 256, 3 }, { 192, 4 }, { 128, 5 }, {64, 0 }, { 0, 0 } },
-        { { 384, 2 }, { 256, 3 }, { 192, 4 }, { 128, 5 }, {64, 0 }, { 0, 0 } },
+static int mcs_ratio_table[3][7] = {
+        { 768, 512, 384, 256, 128, 576, 0 },
+        { 384, 256, 192, 128,  64,   0 },
+        { 384, 256, 192, 128,  64,   0 },
 };
 
-
 /**
  * sta32x_set_dai_sysclk - configure MCLK
  * @codec_dai: the codec DAI
@@ -543,46 +586,10 @@ static int sta32x_set_dai_sysclk(struct snd_soc_dai *codec_dai,
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
-        int i, j, ir, fs;
-        unsigned int rates = 0;
-        unsigned int rate_min = -1;
-        unsigned int rate_max = 0;
 
-        pr_debug("mclk=%u\n", freq);
+        dev_dbg(codec->dev, "mclk=%u\n", freq);
         sta32x->mclk = freq;
 
-        if (sta32x->mclk) {
-                for (i = 0; i < ARRAY_SIZE(interpolation_ratios); i++) {
-                        ir = interpolation_ratios[i].ir;
-                        fs = interpolation_ratios[i].fs;
-                        for (j = 0; mclk_ratios[ir][j].ratio; j++) {
-                                if (mclk_ratios[ir][j].ratio * fs == freq) {
-                                        rates |= snd_pcm_rate_to_rate_bit(fs);
-                                        if (fs < rate_min)
-                                                rate_min = fs;
-                                        if (fs > rate_max)
-                                                rate_max = fs;
-                                        break;
-                                }
-                        }
-                }
-                /* FIXME: soc should support a rate list */
-                rates &= ~SNDRV_PCM_RATE_KNOT;
-
-                if (!rates) {
-                        dev_err(codec->dev, "could not find a valid sample rate\n");
-                        return -EINVAL;
-                }
-        } else {
-                /* enable all possible rates */
-                rates = STA32X_RATES;
-                rate_min = 32000;
-                rate_max = 192000;
-        }
-
-        codec_dai->driver->playback.rates = rates;
-        codec_dai->driver->playback.rate_min = rate_min;
-        codec_dai->driver->playback.rate_max = rate_max;
         return 0;
 }
 
@@ -599,10 +606,7 @@ static int sta32x_set_dai_fmt(struct snd_soc_dai *codec_dai,
 {
         struct snd_soc_codec *codec = codec_dai->codec;
         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
-        u8 confb = snd_soc_read(codec, STA32X_CONFB);
-
-        pr_debug("\n");
-        confb &= ~(STA32X_CONFB_C1IM | STA32X_CONFB_C2IM);
+        u8 confb = 0;
 
         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
         case SND_SOC_DAIFMT_CBS_CFS:
@@ -632,8 +636,8 @@ static int sta32x_set_dai_fmt(struct snd_soc_dai *codec_dai,
                 return -EINVAL;
         }
 
-        snd_soc_write(codec, STA32X_CONFB, confb);
-        return 0;
+        return regmap_update_bits(sta32x->regmap, STA32X_CONFB,
+                                  STA32X_CONFB_C1IM | STA32X_CONFB_C2IM, confb);
 }
 
 /**
@@ -651,39 +655,55 @@ static int sta32x_hw_params(struct snd_pcm_substream *substream,
 {
         struct snd_soc_codec *codec = dai->codec;
         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
-        unsigned int rate;
-        int i, mcs = -1, ir = -1;
-        u8 confa, confb;
+        int i, mcs = -EINVAL, ir = -EINVAL;
+        unsigned int confa, confb;
+        unsigned int rate, ratio;
+        int ret;
+
+        if (!sta32x->mclk) {
+                dev_err(codec->dev,
+                        "sta32x->mclk is unset. Unable to determine ratio\n");
+                return -EIO;
+        }
 
         rate = params_rate(params);
-        pr_debug("rate: %u\n", rate);
-        for (i = 0; i < ARRAY_SIZE(interpolation_ratios); i++)
+        ratio = sta32x->mclk / rate;
+        dev_dbg(codec->dev, "rate: %u, ratio: %u\n", rate, ratio);
+
+        for (i = 0; i < ARRAY_SIZE(interpolation_ratios); i++) {
                 if (interpolation_ratios[i].fs == rate) {
                         ir = interpolation_ratios[i].ir;
                         break;
                 }
-        if (ir < 0)
+        }
+
+        if (ir < 0) {
+                dev_err(codec->dev, "Unsupported samplerate: %u\n", rate);
                 return -EINVAL;
-        for (i = 0; mclk_ratios[ir][i].ratio; i++)
-                if (mclk_ratios[ir][i].ratio * rate == sta32x->mclk) {
-                        mcs = mclk_ratios[ir][i].mcs;
+        }
+
+        for (i = 0; i < 6; i++) {
+                if (mcs_ratio_table[ir][i] == ratio) {
+                        mcs = i;
                         break;
                 }
-        if (mcs < 0)
+        }
+
+        if (mcs < 0) {
+                dev_err(codec->dev, "Unresolvable ratio: %u\n", ratio);
                 return -EINVAL;
+        }
 
-        confa = snd_soc_read(codec, STA32X_CONFA);
-        confa &= ~(STA32X_CONFA_MCS_MASK | STA32X_CONFA_IR_MASK);
-        confa |= (ir << STA32X_CONFA_IR_SHIFT) | (mcs << STA32X_CONFA_MCS_SHIFT);
+        confa = (ir << STA32X_CONFA_IR_SHIFT) |
+                (mcs << STA32X_CONFA_MCS_SHIFT);
+        confb = 0;
 
-        confb = snd_soc_read(codec, STA32X_CONFB);
-        confb &= ~(STA32X_CONFB_SAI_MASK | STA32X_CONFB_SAIFB);
         switch (params_width(params)) {
         case 24:
-                pr_debug("24bit\n");
+                dev_dbg(codec->dev, "24bit\n");
                 /* fall through */
         case 32:
-                pr_debug("24bit or 32bit\n");
+                dev_dbg(codec->dev, "24bit or 32bit\n");
                 switch (sta32x->format) {
                 case SND_SOC_DAIFMT_I2S:
                         confb |= 0x0;
@@ -698,7 +718,7 @@ static int sta32x_hw_params(struct snd_pcm_substream *substream,
 
                 break;
         case 20:
-                pr_debug("20bit\n");
+                dev_dbg(codec->dev, "20bit\n");
                 switch (sta32x->format) {
                 case SND_SOC_DAIFMT_I2S:
                         confb |= 0x4;
@@ -713,7 +733,7 @@ static int sta32x_hw_params(struct snd_pcm_substream *substream,
 
                 break;
         case 18:
-                pr_debug("18bit\n");
+                dev_dbg(codec->dev, "18bit\n");
                 switch (sta32x->format) {
                 case SND_SOC_DAIFMT_I2S:
                         confb |= 0x8;
@@ -728,7 +748,7 @@ static int sta32x_hw_params(struct snd_pcm_substream *substream,
 
                 break;
         case 16:
-                pr_debug("16bit\n");
+                dev_dbg(codec->dev, "16bit\n");
                 switch (sta32x->format) {
                 case SND_SOC_DAIFMT_I2S:
                         confb |= 0x0;
@@ -746,8 +766,30 @@ static int sta32x_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        snd_soc_write(codec, STA32X_CONFA, confa);
-        snd_soc_write(codec, STA32X_CONFB, confb);
+        ret = regmap_update_bits(sta32x->regmap, STA32X_CONFA,
+                                 STA32X_CONFA_MCS_MASK | STA32X_CONFA_IR_MASK,
+                                 confa);
+        if (ret < 0)
+                return ret;
+
+        ret = regmap_update_bits(sta32x->regmap, STA32X_CONFB,
+                                 STA32X_CONFB_SAI_MASK | STA32X_CONFB_SAIFB,
+                                 confb);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int sta32x_startup_sequence(struct sta32x_priv *sta32x)
+{
+        if (sta32x->gpiod_nreset) {
+                gpiod_set_value(sta32x->gpiod_nreset, 0);
+                mdelay(1);
+                gpiod_set_value(sta32x->gpiod_nreset, 1);
+                mdelay(1);
+        }
+
         return 0;
 }
 
@@ -766,14 +808,14 @@ static int sta32x_set_bias_level(struct snd_soc_codec *codec,
         int ret;
         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
 
-        pr_debug("level = %d\n", level);
+        dev_dbg(codec->dev, "level = %d\n", level);
         switch (level) {
         case SND_SOC_BIAS_ON:
                 break;
 
         case SND_SOC_BIAS_PREPARE:
                 /* Full power on */
-                snd_soc_update_bits(codec, STA32X_CONFF,
+                regmap_update_bits(sta32x->regmap, STA32X_CONFF,
                                     STA32X_CONFF_PWDN | STA32X_CONFF_EAPD,
                                     STA32X_CONFF_PWDN | STA32X_CONFF_EAPD);
                 break;
@@ -788,25 +830,28 @@ static int sta32x_set_bias_level(struct snd_soc_codec *codec,
                                 return ret;
                         }
 
+                        sta32x_startup_sequence(sta32x);
                         sta32x_cache_sync(codec);
                         sta32x_watchdog_start(sta32x);
                 }
 
-                /* Power up to mute */
-                /* FIXME */
-                snd_soc_update_bits(codec, STA32X_CONFF,
-                                    STA32X_CONFF_PWDN | STA32X_CONFF_EAPD,
-                                    STA32X_CONFF_PWDN | STA32X_CONFF_EAPD);
+                /* Power down */
+                regmap_update_bits(sta32x->regmap, STA32X_CONFF,
+                                   STA32X_CONFF_PWDN | STA32X_CONFF_EAPD,
+                                   0);
 
                 break;
 
         case SND_SOC_BIAS_OFF:
                 /* The chip runs through the power down sequence for us. */
-                snd_soc_update_bits(codec, STA32X_CONFF,
-                                    STA32X_CONFF_PWDN | STA32X_CONFF_EAPD,
-                                    STA32X_CONFF_PWDN);
+                regmap_update_bits(sta32x->regmap, STA32X_CONFF,
+                                   STA32X_CONFF_PWDN | STA32X_CONFF_EAPD, 0);
                 msleep(300);
                 sta32x_watchdog_stop(sta32x);
+
+                if (sta32x->gpiod_nreset)
+                        gpiod_set_value(sta32x->gpiod_nreset, 0);
+
                 regulator_bulk_disable(ARRAY_SIZE(sta32x->supplies),
                                        sta32x->supplies);
                 break;
@@ -822,7 +867,7 @@ static const struct snd_soc_dai_ops sta32x_dai_ops = {
 };
 
 static struct snd_soc_dai_driver sta32x_dai = {
-        .name = "STA32X",
+        .name = "sta32x-hifi",
         .playback = {
                 .stream_name = "Playback",
                 .channels_min = 2,
@@ -836,11 +881,8 @@ static struct snd_soc_dai_driver sta32x_dai = {
 static int sta32x_probe(struct snd_soc_codec *codec)
 {
         struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec);
+        struct sta32x_platform_data *pdata = sta32x->pdata;
         int i, ret = 0, thermal = 0;
-
-        sta32x->codec = codec;
-        sta32x->pdata = dev_get_platdata(codec->dev);
-
         ret = regulator_bulk_enable(ARRAY_SIZE(sta32x->supplies),
                                     sta32x->supplies);
         if (ret != 0) {
@@ -848,50 +890,73 @@ static int sta32x_probe(struct snd_soc_codec *codec)
                 return ret;
         }
 
-        /* Chip documentation explicitly requires that the reset values
-         * of reserved register bits are left untouched.
-         * Write the register default value to cache for reserved registers,
-         * so the write to the these registers are suppressed by the cache
-         * restore code when it skips writes of default registers.
-         */
-        regcache_cache_only(sta32x->regmap, true);
-        snd_soc_write(codec, STA32X_CONFC, 0xc2);
-        snd_soc_write(codec, STA32X_CONFE, 0xc2);
-        snd_soc_write(codec, STA32X_CONFF, 0x5c);
-        snd_soc_write(codec, STA32X_MMUTE, 0x10);
-        snd_soc_write(codec, STA32X_AUTO1, 0x60);
-        snd_soc_write(codec, STA32X_AUTO3, 0x00);
-        snd_soc_write(codec, STA32X_C3CFG, 0x40);
-        regcache_cache_only(sta32x->regmap, false);
-
-        /* set thermal warning adjustment and recovery */
-        if (!(sta32x->pdata->thermal_conf & STA32X_THERMAL_ADJUSTMENT_ENABLE))
+        ret = sta32x_startup_sequence(sta32x);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to startup device\n");
+                return ret;
+        }
+
+        /* CONFA */
+        if (!pdata->thermal_warning_recovery)
                 thermal |= STA32X_CONFA_TWAB;
-        if (!(sta32x->pdata->thermal_conf & STA32X_THERMAL_RECOVERY_ENABLE))
+        if (!pdata->thermal_warning_adjustment)
                 thermal |= STA32X_CONFA_TWRB;
-        snd_soc_update_bits(codec, STA32X_CONFA,
-                            STA32X_CONFA_TWAB | STA32X_CONFA_TWRB,
-                            thermal);
+        if (!pdata->fault_detect_recovery)
+                thermal |= STA32X_CONFA_FDRB;
+        regmap_update_bits(sta32x->regmap, STA32X_CONFA,
+                           STA32X_CONFA_TWAB | STA32X_CONFA_TWRB |
+                           STA32X_CONFA_FDRB,
+                           thermal);
+
+        /* CONFC */
+        regmap_update_bits(sta32x->regmap, STA32X_CONFC,
+                           STA32X_CONFC_CSZ_MASK,
+                           pdata->drop_compensation_ns
+                                << STA32X_CONFC_CSZ_SHIFT);
+
+        /* CONFE */
+        regmap_update_bits(sta32x->regmap, STA32X_CONFE,
+                           STA32X_CONFE_MPCV,
+                           pdata->max_power_use_mpcc ?
+                                STA32X_CONFE_MPCV : 0);
+        regmap_update_bits(sta32x->regmap, STA32X_CONFE,
+                           STA32X_CONFE_MPC,
+                           pdata->max_power_correction ?
+                                STA32X_CONFE_MPC : 0);
+        regmap_update_bits(sta32x->regmap, STA32X_CONFE,
+                           STA32X_CONFE_AME,
+                           pdata->am_reduction_mode ?
+                                STA32X_CONFE_AME : 0);
+        regmap_update_bits(sta32x->regmap, STA32X_CONFE,
+                           STA32X_CONFE_PWMS,
+                           pdata->odd_pwm_speed_mode ?
+                                STA32X_CONFE_PWMS : 0);
+
+        /*  CONFF */
+        regmap_update_bits(sta32x->regmap, STA32X_CONFF,
+                           STA32X_CONFF_IDE,
+                           pdata->invalid_input_detect_mute ?
+                                STA32X_CONFF_IDE : 0);
 
         /* select output configuration  */
-        snd_soc_update_bits(codec, STA32X_CONFF,
-                            STA32X_CONFF_OCFG_MASK,
-                            sta32x->pdata->output_conf
-                            << STA32X_CONFF_OCFG_SHIFT);
+        regmap_update_bits(sta32x->regmap, STA32X_CONFF,
+                           STA32X_CONFF_OCFG_MASK,
+                           pdata->output_conf
+                                << STA32X_CONFF_OCFG_SHIFT);
 
         /* channel to output mapping */
-        snd_soc_update_bits(codec, STA32X_C1CFG,
-                            STA32X_CxCFG_OM_MASK,
-                            sta32x->pdata->ch1_output_mapping
-                            << STA32X_CxCFG_OM_SHIFT);
-        snd_soc_update_bits(codec, STA32X_C2CFG,
-                            STA32X_CxCFG_OM_MASK,
-                            sta32x->pdata->ch2_output_mapping
-                            << STA32X_CxCFG_OM_SHIFT);
-        snd_soc_update_bits(codec, STA32X_C3CFG,
-                            STA32X_CxCFG_OM_MASK,
-                            sta32x->pdata->ch3_output_mapping
-                            << STA32X_CxCFG_OM_SHIFT);
+        regmap_update_bits(sta32x->regmap, STA32X_C1CFG,
+                           STA32X_CxCFG_OM_MASK,
+                           pdata->ch1_output_mapping
+                                << STA32X_CxCFG_OM_SHIFT);
+        regmap_update_bits(sta32x->regmap, STA32X_C2CFG,
+                           STA32X_CxCFG_OM_MASK,
+                           pdata->ch2_output_mapping
+                                << STA32X_CxCFG_OM_SHIFT);
+        regmap_update_bits(sta32x->regmap, STA32X_C3CFG,
+                           STA32X_CxCFG_OM_MASK,
+                           pdata->ch3_output_mapping
+                                << STA32X_CxCFG_OM_SHIFT);
 
         /* initialize coefficient shadow RAM with reset values */
         for (i = 4; i <= 49; i += 5)
@@ -924,16 +989,6 @@ static int sta32x_remove(struct snd_soc_codec *codec)
         return 0;
 }
 
-static bool sta32x_reg_is_volatile(struct device *dev, unsigned int reg)
-{
-        switch (reg) {
-        case STA32X_CONFA ... STA32X_L2ATRT:
-        case STA32X_MPCC1 ... STA32X_FDRC2:
-                return 0;
-        }
-        return 1;
-}
-
 static const struct snd_soc_codec_driver sta32x_codec = {
         .probe =                sta32x_probe,
         .remove =               sta32x_remove,
@@ -954,12 +1009,75 @@ static const struct regmap_config sta32x_regmap = {
         .reg_defaults =         sta32x_regs,
         .num_reg_defaults =     ARRAY_SIZE(sta32x_regs),
         .cache_type =           REGCACHE_RBTREE,
-        .volatile_reg =         sta32x_reg_is_volatile,
+        .wr_table =             &sta32x_write_regs,
+        .rd_table =             &sta32x_read_regs,
+        .volatile_table =       &sta32x_volatile_regs,
 };
 
+#ifdef CONFIG_OF
+static const struct of_device_id st32x_dt_ids[] = {
+        { .compatible = "st,sta32x", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, st32x_dt_ids);
+
+static int sta32x_probe_dt(struct device *dev, struct sta32x_priv *sta32x)
+{
+        struct device_node *np = dev->of_node;
+        struct sta32x_platform_data *pdata;
+        u16 tmp;
+
+        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+
+        of_property_read_u8(np, "st,output-conf",
+                            &pdata->output_conf);
+        of_property_read_u8(np, "st,ch1-output-mapping",
+                            &pdata->ch1_output_mapping);
+        of_property_read_u8(np, "st,ch2-output-mapping",
+                            &pdata->ch2_output_mapping);
+        of_property_read_u8(np, "st,ch3-output-mapping",
+                            &pdata->ch3_output_mapping);
+
+        if (of_get_property(np, "st,thermal-warning-recovery", NULL))
+                pdata->thermal_warning_recovery = 1;
+        if (of_get_property(np, "st,thermal-warning-adjustment", NULL))
+                pdata->thermal_warning_adjustment = 1;
+        if (of_get_property(np, "st,needs_esd_watchdog", NULL))
+                pdata->needs_esd_watchdog = 1;
+
+        tmp = 140;
+        of_property_read_u16(np, "st,drop-compensation-ns", &tmp);
+        pdata->drop_compensation_ns = clamp_t(u16, tmp, 0, 300) / 20;
+
+        /* CONFE */
+        if (of_get_property(np, "st,max-power-use-mpcc", NULL))
+                pdata->max_power_use_mpcc = 1;
+
+        if (of_get_property(np, "st,max-power-correction", NULL))
+                pdata->max_power_correction = 1;
+
+        if (of_get_property(np, "st,am-reduction-mode", NULL))
+                pdata->am_reduction_mode = 1;
+
+        if (of_get_property(np, "st,odd-pwm-speed-mode", NULL))
+                pdata->odd_pwm_speed_mode = 1;
+
+        /* CONFF */
+        if (of_get_property(np, "st,invalid-input-detect-mute", NULL))
+                pdata->invalid_input_detect_mute = 1;
+
+        sta32x->pdata = pdata;
+
+        return 0;
+}
+#endif
+
 static int sta32x_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
+        struct device *dev = &i2c->dev;
         struct sta32x_priv *sta32x;
         int ret, i;
 
@@ -968,6 +1086,29 @@ static int sta32x_i2c_probe(struct i2c_client *i2c,
         if (!sta32x)
                 return -ENOMEM;
 
+        mutex_init(&sta32x->coeff_lock);
+        sta32x->pdata = dev_get_platdata(dev);
+
+#ifdef CONFIG_OF
+        if (dev->of_node) {
+                ret = sta32x_probe_dt(dev, sta32x);
+                if (ret < 0)
+                        return ret;
+        }
+#endif
+
+        /* GPIOs */
+        sta32x->gpiod_nreset = devm_gpiod_get(dev, "reset");
+        if (IS_ERR(sta32x->gpiod_nreset)) {
+                ret = PTR_ERR(sta32x->gpiod_nreset);
+                if (ret != -ENOENT && ret != -ENOSYS)
+                        return ret;
+
+                sta32x->gpiod_nreset = NULL;
+        } else {
+                gpiod_direction_output(sta32x->gpiod_nreset, 0);
+        }
+
         /* regulators */
         for (i = 0; i < ARRAY_SIZE(sta32x->supplies); i++)
                 sta32x->supplies[i].supply = sta32x_supply_names[i];
@@ -982,15 +1123,15 @@ static int sta32x_i2c_probe(struct i2c_client *i2c,
         sta32x->regmap = devm_regmap_init_i2c(i2c, &sta32x_regmap);
         if (IS_ERR(sta32x->regmap)) {
                 ret = PTR_ERR(sta32x->regmap);
-                dev_err(&i2c->dev, "Failed to init regmap: %d\n", ret);
+                dev_err(dev, "Failed to init regmap: %d\n", ret);
                 return ret;
         }
 
         i2c_set_clientdata(i2c, sta32x);
 
-        ret = snd_soc_register_codec(&i2c->dev, &sta32x_codec, &sta32x_dai, 1);
-        if (ret != 0)
-                dev_err(&i2c->dev, "Failed to register codec (%d)\n", ret);
+        ret = snd_soc_register_codec(dev, &sta32x_codec, &sta32x_dai, 1);
+        if (ret < 0)
+                dev_err(dev, "Failed to register codec (%d)\n", ret);
 
         return ret;
 }
@@ -1013,6 +1154,7 @@ static struct i2c_driver sta32x_i2c_driver = {
         .driver = {
                 .name = "sta32x",
                 .owner = THIS_MODULE,
+                .of_match_table = of_match_ptr(st32x_dt_ids),
         },
         .probe =    sta32x_i2c_probe,
         .remove =   sta32x_i2c_remove,
diff --git a/sound/soc/codecs/sta32x.h b/sound/soc/codecs/sta32x.h
index d8e32a6262ee..d3191c983d71 100644
--- a/sound/soc/codecs/sta32x.h
+++ b/sound/soc/codecs/sta32x.h
@@ -131,7 +131,7 @@
 #define STA32X_CONFF_OCFG_MASK  0x03
 #define STA32X_CONFF_OCFG_SHIFT 0
 #define STA32X_CONFF_IDE        0x04
-#define STA32X_CONFF_IDE_SHIFT  3
+#define STA32X_CONFF_IDE_SHIFT  2
 #define STA32X_CONFF_BCLE       0x08
 #define STA32X_CONFF_ECLE       0x20
 #define STA32X_CONFF_PWDN       0x40
diff --git a/sound/soc/codecs/tlv320aic31xx.c b/sound/soc/codecs/tlv320aic31xx.c
index dc3223d6eca1..c86dd9aae157 100644
--- a/sound/soc/codecs/tlv320aic31xx.c
+++ b/sound/soc/codecs/tlv320aic31xx.c
@@ -349,7 +349,8 @@ static int aic31xx_wait_bits(struct aic31xx_priv *aic31xx, unsigned int reg,
 static int aic31xx_dapm_power_event(struct snd_soc_dapm_widget *w,
                                     struct snd_kcontrol *kcontrol, int event)
 {
-        struct aic31xx_priv *aic31xx = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct aic31xx_priv *aic31xx = snd_soc_codec_get_drvdata(codec);
         unsigned int reg = AIC31XX_DACFLAG1;
         unsigned int mask;
 
@@ -377,7 +378,7 @@ static int aic31xx_dapm_power_event(struct snd_soc_dapm_widget *w,
                 reg = AIC31XX_ADCFLAG;
                 break;
         default:
-                dev_err(w->codec->dev, "Unknown widget '%s' calling %s\n",
+                dev_err(codec->dev, "Unknown widget '%s' calling %s\n",
                         w->name, __func__);
                 return -EINVAL;
         }
@@ -388,7 +389,7 @@ static int aic31xx_dapm_power_event(struct snd_soc_dapm_widget *w,
         case SND_SOC_DAPM_POST_PMD:
                 return aic31xx_wait_bits(aic31xx, reg, mask, 0, 5000, 100);
         default:
-                dev_dbg(w->codec->dev,
+                dev_dbg(codec->dev,
                         "Unhandled dapm widget event %d from %s\n",
                         event, w->name);
         }
@@ -433,7 +434,7 @@ static const struct snd_kcontrol_new aic31xx_dapm_spr_switch =
 static int mic_bias_event(struct snd_soc_dapm_widget *w,
                           struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct aic31xx_priv *aic31xx = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
diff --git a/sound/soc/codecs/tlv320aic3x.c b/sound/soc/codecs/tlv320aic3x.c
index dd222b10ce13..51c4713ac6e3 100644
--- a/sound/soc/codecs/tlv320aic3x.c
+++ b/sound/soc/codecs/tlv320aic3x.c
@@ -87,6 +87,7 @@ struct aic3x_priv {
 #define AIC3X_MODEL_3X 0
 #define AIC3X_MODEL_33 1
 #define AIC3X_MODEL_3007 2
+#define AIC3X_MODEL_3104 3
         u16 model;
 
         /* Selects the micbias voltage */
@@ -197,7 +198,7 @@ static int snd_soc_dapm_put_volsw_aic3x(struct snd_kcontrol *kcontrol,
 static int mic_bias_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct aic3x_priv *aic3x = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -316,52 +317,37 @@ static const struct snd_kcontrol_new aic3x_snd_controls[] = {
          * only for swapped L-to-R and R-to-L routes. See below stereo controls
          * for direct L-to-L and R-to-R routes.
          */
-        SOC_SINGLE_TLV("Left Line Mixer Line2R Bypass Volume",
-                       LINE2R_2_LLOPM_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Left Line Mixer PGAR Bypass Volume",
                        PGAR_2_LLOPM_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Left Line Mixer DACR1 Playback Volume",
                        DACR1_2_LLOPM_VOL, 0, 118, 1, output_stage_tlv),
 
-        SOC_SINGLE_TLV("Right Line Mixer Line2L Bypass Volume",
-                       LINE2L_2_RLOPM_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Right Line Mixer PGAL Bypass Volume",
                        PGAL_2_RLOPM_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Right Line Mixer DACL1 Playback Volume",
                        DACL1_2_RLOPM_VOL, 0, 118, 1, output_stage_tlv),
 
-        SOC_SINGLE_TLV("Left HP Mixer Line2R Bypass Volume",
-                       LINE2R_2_HPLOUT_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Left HP Mixer PGAR Bypass Volume",
                        PGAR_2_HPLOUT_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Left HP Mixer DACR1 Playback Volume",
                        DACR1_2_HPLOUT_VOL, 0, 118, 1, output_stage_tlv),
 
-        SOC_SINGLE_TLV("Right HP Mixer Line2L Bypass Volume",
-                       LINE2L_2_HPROUT_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Right HP Mixer PGAL Bypass Volume",
                        PGAL_2_HPROUT_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Right HP Mixer DACL1 Playback Volume",
                        DACL1_2_HPROUT_VOL, 0, 118, 1, output_stage_tlv),
 
-        SOC_SINGLE_TLV("Left HPCOM Mixer Line2R Bypass Volume",
-                       LINE2R_2_HPLCOM_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Left HPCOM Mixer PGAR Bypass Volume",
                        PGAR_2_HPLCOM_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Left HPCOM Mixer DACR1 Playback Volume",
                        DACR1_2_HPLCOM_VOL, 0, 118, 1, output_stage_tlv),
 
-        SOC_SINGLE_TLV("Right HPCOM Mixer Line2L Bypass Volume",
-                       LINE2L_2_HPRCOM_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Right HPCOM Mixer PGAL Bypass Volume",
                        PGAL_2_HPRCOM_VOL, 0, 118, 1, output_stage_tlv),
         SOC_SINGLE_TLV("Right HPCOM Mixer DACL1 Playback Volume",
                        DACL1_2_HPRCOM_VOL, 0, 118, 1, output_stage_tlv),
 
         /* Stereo output controls for direct L-to-L and R-to-R routes */
-        SOC_DOUBLE_R_TLV("Line Line2 Bypass Volume",
-                         LINE2L_2_LLOPM_VOL, LINE2R_2_RLOPM_VOL,
-                         0, 118, 1, output_stage_tlv),
         SOC_DOUBLE_R_TLV("Line PGA Bypass Volume",
                          PGAL_2_LLOPM_VOL, PGAR_2_RLOPM_VOL,
                          0, 118, 1, output_stage_tlv),
@@ -369,9 +355,6 @@ static const struct snd_kcontrol_new aic3x_snd_controls[] = {
                          DACL1_2_LLOPM_VOL, DACR1_2_RLOPM_VOL,
                          0, 118, 1, output_stage_tlv),
 
-        SOC_DOUBLE_R_TLV("HP Line2 Bypass Volume",
-                         LINE2L_2_HPLOUT_VOL, LINE2R_2_HPROUT_VOL,
-                         0, 118, 1, output_stage_tlv),
         SOC_DOUBLE_R_TLV("HP PGA Bypass Volume",
                          PGAL_2_HPLOUT_VOL, PGAR_2_HPROUT_VOL,
                          0, 118, 1, output_stage_tlv),
@@ -379,9 +362,6 @@ static const struct snd_kcontrol_new aic3x_snd_controls[] = {
                          DACL1_2_HPLOUT_VOL, DACR1_2_HPROUT_VOL,
                          0, 118, 1, output_stage_tlv),
 
-        SOC_DOUBLE_R_TLV("HPCOM Line2 Bypass Volume",
-                         LINE2L_2_HPLCOM_VOL, LINE2R_2_HPRCOM_VOL,
-                         0, 118, 1, output_stage_tlv),
         SOC_DOUBLE_R_TLV("HPCOM PGA Bypass Volume",
                          PGAL_2_HPLCOM_VOL, PGAR_2_HPRCOM_VOL,
                          0, 118, 1, output_stage_tlv),
@@ -424,6 +404,45 @@ static const struct snd_kcontrol_new aic3x_snd_controls[] = {
         SOC_ENUM("Output Driver Ramp-up step", aic3x_rampup_step_enum),
 };
 
+/* For other than tlv320aic3104 */
+static const struct snd_kcontrol_new aic3x_extra_snd_controls[] = {
+        /*
+         * Output controls that map to output mixer switches. Note these are
+         * only for swapped L-to-R and R-to-L routes. See below stereo controls
+         * for direct L-to-L and R-to-R routes.
+         */
+        SOC_SINGLE_TLV("Left Line Mixer Line2R Bypass Volume",
+                       LINE2R_2_LLOPM_VOL, 0, 118, 1, output_stage_tlv),
+
+        SOC_SINGLE_TLV("Right Line Mixer Line2L Bypass Volume",
+                       LINE2L_2_RLOPM_VOL, 0, 118, 1, output_stage_tlv),
+
+        SOC_SINGLE_TLV("Left HP Mixer Line2R Bypass Volume",
+                       LINE2R_2_HPLOUT_VOL, 0, 118, 1, output_stage_tlv),
+
+        SOC_SINGLE_TLV("Right HP Mixer Line2L Bypass Volume",
+                       LINE2L_2_HPROUT_VOL, 0, 118, 1, output_stage_tlv),
+
+        SOC_SINGLE_TLV("Left HPCOM Mixer Line2R Bypass Volume",
+                       LINE2R_2_HPLCOM_VOL, 0, 118, 1, output_stage_tlv),
+
+        SOC_SINGLE_TLV("Right HPCOM Mixer Line2L Bypass Volume",
+                       LINE2L_2_HPRCOM_VOL, 0, 118, 1, output_stage_tlv),
+
+        /* Stereo output controls for direct L-to-L and R-to-R routes */
+        SOC_DOUBLE_R_TLV("Line Line2 Bypass Volume",
+                         LINE2L_2_LLOPM_VOL, LINE2R_2_RLOPM_VOL,
+                         0, 118, 1, output_stage_tlv),
+
+        SOC_DOUBLE_R_TLV("HP Line2 Bypass Volume",
+                         LINE2L_2_HPLOUT_VOL, LINE2R_2_HPROUT_VOL,
+                         0, 118, 1, output_stage_tlv),
+
+        SOC_DOUBLE_R_TLV("HPCOM Line2 Bypass Volume",
+                         LINE2L_2_HPLCOM_VOL, LINE2R_2_HPRCOM_VOL,
+                         0, 118, 1, output_stage_tlv),
+};
+
 static const struct snd_kcontrol_new aic3x_mono_controls[] = {
         SOC_DOUBLE_R_TLV("Mono Line2 Bypass Volume",
                          LINE2L_2_MONOLOPM_VOL, LINE2R_2_MONOLOPM_VOL,
@@ -464,22 +483,24 @@ SOC_DAPM_ENUM("Route", aic3x_right_hpcom_enum);
 
 /* Left Line Mixer */
 static const struct snd_kcontrol_new aic3x_left_line_mixer_controls[] = {
-        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_LLOPM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAL Bypass Switch", PGAL_2_LLOPM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACL1 Switch", DACL1_2_LLOPM_VOL, 7, 1, 0),
-        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_LLOPM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAR Bypass Switch", PGAR_2_LLOPM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACR1 Switch", DACR1_2_LLOPM_VOL, 7, 1, 0),
+        /* Not on tlv320aic3104 */
+        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_LLOPM_VOL, 7, 1, 0),
+        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_LLOPM_VOL, 7, 1, 0),
 };
 
 /* Right Line Mixer */
 static const struct snd_kcontrol_new aic3x_right_line_mixer_controls[] = {
-        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_RLOPM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAL Bypass Switch", PGAL_2_RLOPM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACL1 Switch", DACL1_2_RLOPM_VOL, 7, 1, 0),
-        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_RLOPM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAR Bypass Switch", PGAR_2_RLOPM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACR1 Switch", DACR1_2_RLOPM_VOL, 7, 1, 0),
+        /* Not on tlv320aic3104 */
+        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_RLOPM_VOL, 7, 1, 0),
+        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_RLOPM_VOL, 7, 1, 0),
 };
 
 /* Mono Mixer */
@@ -494,42 +515,46 @@ static const struct snd_kcontrol_new aic3x_mono_mixer_controls[] = {
 
 /* Left HP Mixer */
 static const struct snd_kcontrol_new aic3x_left_hp_mixer_controls[] = {
-        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_HPLOUT_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAL Bypass Switch", PGAL_2_HPLOUT_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACL1 Switch", DACL1_2_HPLOUT_VOL, 7, 1, 0),
-        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_HPLOUT_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAR Bypass Switch", PGAR_2_HPLOUT_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACR1 Switch", DACR1_2_HPLOUT_VOL, 7, 1, 0),
+        /* Not on tlv320aic3104 */
+        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_HPLOUT_VOL, 7, 1, 0),
+        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_HPLOUT_VOL, 7, 1, 0),
 };
 
 /* Right HP Mixer */
 static const struct snd_kcontrol_new aic3x_right_hp_mixer_controls[] = {
-        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_HPROUT_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAL Bypass Switch", PGAL_2_HPROUT_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACL1 Switch", DACL1_2_HPROUT_VOL, 7, 1, 0),
-        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_HPROUT_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAR Bypass Switch", PGAR_2_HPROUT_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACR1 Switch", DACR1_2_HPROUT_VOL, 7, 1, 0),
+        /* Not on tlv320aic3104 */
+        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_HPROUT_VOL, 7, 1, 0),
+        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_HPROUT_VOL, 7, 1, 0),
 };
 
 /* Left HPCOM Mixer */
 static const struct snd_kcontrol_new aic3x_left_hpcom_mixer_controls[] = {
-        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_HPLCOM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAL Bypass Switch", PGAL_2_HPLCOM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACL1 Switch", DACL1_2_HPLCOM_VOL, 7, 1, 0),
-        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_HPLCOM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAR Bypass Switch", PGAR_2_HPLCOM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACR1 Switch", DACR1_2_HPLCOM_VOL, 7, 1, 0),
+        /* Not on tlv320aic3104 */
+        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_HPLCOM_VOL, 7, 1, 0),
+        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_HPLCOM_VOL, 7, 1, 0),
 };
 
 /* Right HPCOM Mixer */
 static const struct snd_kcontrol_new aic3x_right_hpcom_mixer_controls[] = {
-        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_HPRCOM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAL Bypass Switch", PGAL_2_HPRCOM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACL1 Switch", DACL1_2_HPRCOM_VOL, 7, 1, 0),
-        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_HPRCOM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("PGAR Bypass Switch", PGAR_2_HPRCOM_VOL, 7, 1, 0),
         SOC_DAPM_SINGLE("DACR1 Switch", DACR1_2_HPRCOM_VOL, 7, 1, 0),
+        /* Not on tlv320aic3104 */
+        SOC_DAPM_SINGLE("Line2L Bypass Switch", LINE2L_2_HPRCOM_VOL, 7, 1, 0),
+        SOC_DAPM_SINGLE("Line2R Bypass Switch", LINE2R_2_HPRCOM_VOL, 7, 1, 0),
 };
 
 /* Left PGA Mixer */
@@ -550,6 +575,22 @@ static const struct snd_kcontrol_new aic3x_right_pga_mixer_controls[] = {
         SOC_DAPM_SINGLE_AIC3X("Mic3R Switch", MIC3LR_2_RADC_CTRL, 0, 1, 1),
 };
 
+/* Left PGA Mixer for tlv320aic3104 */
+static const struct snd_kcontrol_new aic3104_left_pga_mixer_controls[] = {
+        SOC_DAPM_SINGLE_AIC3X("Line1L Switch", LINE1L_2_LADC_CTRL, 3, 1, 1),
+        SOC_DAPM_SINGLE_AIC3X("Line1R Switch", LINE1R_2_LADC_CTRL, 3, 1, 1),
+        SOC_DAPM_SINGLE_AIC3X("Mic2L Switch", MIC3LR_2_LADC_CTRL, 4, 1, 1),
+        SOC_DAPM_SINGLE_AIC3X("Mic2R Switch", MIC3LR_2_LADC_CTRL, 0, 1, 1),
+};
+
+/* Right PGA Mixer for tlv320aic3104 */
+static const struct snd_kcontrol_new aic3104_right_pga_mixer_controls[] = {
+        SOC_DAPM_SINGLE_AIC3X("Line1R Switch", LINE1R_2_RADC_CTRL, 3, 1, 1),
+        SOC_DAPM_SINGLE_AIC3X("Line1L Switch", LINE1L_2_RADC_CTRL, 3, 1, 1),
+        SOC_DAPM_SINGLE_AIC3X("Mic2L Switch", MIC3LR_2_RADC_CTRL, 4, 1, 1),
+        SOC_DAPM_SINGLE_AIC3X("Mic2R Switch", MIC3LR_2_RADC_CTRL, 0, 1, 1),
+};
+
 /* Left Line1 Mux */
 static const struct snd_kcontrol_new aic3x_left_line1l_mux_controls =
 SOC_DAPM_ENUM("Route", aic3x_line1l_2_l_enum);
@@ -593,26 +634,56 @@ static const struct snd_soc_dapm_widget aic3x_dapm_widgets[] = {
 
         /* Inputs to Left ADC */
         SND_SOC_DAPM_ADC("Left ADC", "Left Capture", LINE1L_2_LADC_CTRL, 2, 0),
-        SND_SOC_DAPM_MIXER("Left PGA Mixer", SND_SOC_NOPM, 0, 0,
-                           &aic3x_left_pga_mixer_controls[0],
-                           ARRAY_SIZE(aic3x_left_pga_mixer_controls)),
         SND_SOC_DAPM_MUX("Left Line1L Mux", SND_SOC_NOPM, 0, 0,
                          &aic3x_left_line1l_mux_controls),
         SND_SOC_DAPM_MUX("Left Line1R Mux", SND_SOC_NOPM, 0, 0,
                          &aic3x_left_line1r_mux_controls),
-        SND_SOC_DAPM_MUX("Left Line2L Mux", SND_SOC_NOPM, 0, 0,
-                         &aic3x_left_line2_mux_controls),
 
         /* Inputs to Right ADC */
         SND_SOC_DAPM_ADC("Right ADC", "Right Capture",
                          LINE1R_2_RADC_CTRL, 2, 0),
-        SND_SOC_DAPM_MIXER("Right PGA Mixer", SND_SOC_NOPM, 0, 0,
-                           &aic3x_right_pga_mixer_controls[0],
-                           ARRAY_SIZE(aic3x_right_pga_mixer_controls)),
         SND_SOC_DAPM_MUX("Right Line1L Mux", SND_SOC_NOPM, 0, 0,
                          &aic3x_right_line1l_mux_controls),
         SND_SOC_DAPM_MUX("Right Line1R Mux", SND_SOC_NOPM, 0, 0,
                          &aic3x_right_line1r_mux_controls),
+
+        /* Mic Bias */
+        SND_SOC_DAPM_SUPPLY("Mic Bias", MICBIAS_CTRL, 6, 0,
+                         mic_bias_event,
+                         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+
+        SND_SOC_DAPM_OUTPUT("LLOUT"),
+        SND_SOC_DAPM_OUTPUT("RLOUT"),
+        SND_SOC_DAPM_OUTPUT("HPLOUT"),
+        SND_SOC_DAPM_OUTPUT("HPROUT"),
+        SND_SOC_DAPM_OUTPUT("HPLCOM"),
+        SND_SOC_DAPM_OUTPUT("HPRCOM"),
+
+        SND_SOC_DAPM_INPUT("LINE1L"),
+        SND_SOC_DAPM_INPUT("LINE1R"),
+
+        /*
+         * Virtual output pin to detection block inside codec. This can be
+         * used to keep codec bias on if gpio or detection features are needed.
+         * Force pin on or construct a path with an input jack and mic bias
+         * widgets.
+         */
+        SND_SOC_DAPM_OUTPUT("Detection"),
+};
+
+/* For other than tlv320aic3104 */
+static const struct snd_soc_dapm_widget aic3x_extra_dapm_widgets[] = {
+        /* Inputs to Left ADC */
+        SND_SOC_DAPM_MIXER("Left PGA Mixer", SND_SOC_NOPM, 0, 0,
+                           &aic3x_left_pga_mixer_controls[0],
+                           ARRAY_SIZE(aic3x_left_pga_mixer_controls)),
+        SND_SOC_DAPM_MUX("Left Line2L Mux", SND_SOC_NOPM, 0, 0,
+                         &aic3x_left_line2_mux_controls),
+
+        /* Inputs to Right ADC */
+        SND_SOC_DAPM_MIXER("Right PGA Mixer", SND_SOC_NOPM, 0, 0,
+                           &aic3x_right_pga_mixer_controls[0],
+                           ARRAY_SIZE(aic3x_right_pga_mixer_controls)),
         SND_SOC_DAPM_MUX("Right Line2R Mux", SND_SOC_NOPM, 0, 0,
                          &aic3x_right_line2_mux_controls),
 
@@ -637,11 +708,6 @@ static const struct snd_soc_dapm_widget aic3x_dapm_widgets[] = {
         SND_SOC_DAPM_REG(snd_soc_dapm_micbias, "DMic Rate 32",
                          AIC3X_ASD_INTF_CTRLA, 0, 3, 3, 0),
 
-        /* Mic Bias */
-        SND_SOC_DAPM_SUPPLY("Mic Bias", MICBIAS_CTRL, 6, 0,
-                         mic_bias_event,
-                         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
-
         /* Output mixers */
         SND_SOC_DAPM_MIXER("Left Line Mixer", SND_SOC_NOPM, 0, 0,
                            &aic3x_left_line_mixer_controls[0],
@@ -662,27 +728,46 @@ static const struct snd_soc_dapm_widget aic3x_dapm_widgets[] = {
                            &aic3x_right_hpcom_mixer_controls[0],
                            ARRAY_SIZE(aic3x_right_hpcom_mixer_controls)),
 
-        SND_SOC_DAPM_OUTPUT("LLOUT"),
-        SND_SOC_DAPM_OUTPUT("RLOUT"),
-        SND_SOC_DAPM_OUTPUT("HPLOUT"),
-        SND_SOC_DAPM_OUTPUT("HPROUT"),
-        SND_SOC_DAPM_OUTPUT("HPLCOM"),
-        SND_SOC_DAPM_OUTPUT("HPRCOM"),
-
         SND_SOC_DAPM_INPUT("MIC3L"),
         SND_SOC_DAPM_INPUT("MIC3R"),
-        SND_SOC_DAPM_INPUT("LINE1L"),
-        SND_SOC_DAPM_INPUT("LINE1R"),
         SND_SOC_DAPM_INPUT("LINE2L"),
         SND_SOC_DAPM_INPUT("LINE2R"),
+};
 
-        /*
-         * Virtual output pin to detection block inside codec. This can be
-         * used to keep codec bias on if gpio or detection features are needed.
-         * Force pin on or construct a path with an input jack and mic bias
-         * widgets.
-         */
-        SND_SOC_DAPM_OUTPUT("Detection"),
+/* For tlv320aic3104 */
+static const struct snd_soc_dapm_widget aic3104_extra_dapm_widgets[] = {
+        /* Inputs to Left ADC */
+        SND_SOC_DAPM_MIXER("Left PGA Mixer", SND_SOC_NOPM, 0, 0,
+                           &aic3104_left_pga_mixer_controls[0],
+                           ARRAY_SIZE(aic3104_left_pga_mixer_controls)),
+
+        /* Inputs to Right ADC */
+        SND_SOC_DAPM_MIXER("Right PGA Mixer", SND_SOC_NOPM, 0, 0,
+                           &aic3104_right_pga_mixer_controls[0],
+                           ARRAY_SIZE(aic3104_right_pga_mixer_controls)),
+
+        /* Output mixers */
+        SND_SOC_DAPM_MIXER("Left Line Mixer", SND_SOC_NOPM, 0, 0,
+                           &aic3x_left_line_mixer_controls[0],
+                           ARRAY_SIZE(aic3x_left_line_mixer_controls) - 2),
+        SND_SOC_DAPM_MIXER("Right Line Mixer", SND_SOC_NOPM, 0, 0,
+                           &aic3x_right_line_mixer_controls[0],
+                           ARRAY_SIZE(aic3x_right_line_mixer_controls) - 2),
+        SND_SOC_DAPM_MIXER("Left HP Mixer", SND_SOC_NOPM, 0, 0,
+                           &aic3x_left_hp_mixer_controls[0],
+                           ARRAY_SIZE(aic3x_left_hp_mixer_controls) - 2),
+        SND_SOC_DAPM_MIXER("Right HP Mixer", SND_SOC_NOPM, 0, 0,
+                           &aic3x_right_hp_mixer_controls[0],
+                           ARRAY_SIZE(aic3x_right_hp_mixer_controls) - 2),
+        SND_SOC_DAPM_MIXER("Left HPCOM Mixer", SND_SOC_NOPM, 0, 0,
+                           &aic3x_left_hpcom_mixer_controls[0],
+                           ARRAY_SIZE(aic3x_left_hpcom_mixer_controls) - 2),
+        SND_SOC_DAPM_MIXER("Right HPCOM Mixer", SND_SOC_NOPM, 0, 0,
+                           &aic3x_right_hpcom_mixer_controls[0],
+                           ARRAY_SIZE(aic3x_right_hpcom_mixer_controls) - 2),
+
+        SND_SOC_DAPM_INPUT("MIC2L"),
+        SND_SOC_DAPM_INPUT("MIC2R"),
 };
 
 static const struct snd_soc_dapm_widget aic3x_dapm_mono_widgets[] = {
@@ -712,17 +797,10 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"Left Line1R Mux", "single-ended", "LINE1R"},
         {"Left Line1R Mux", "differential", "LINE1R"},
 
-        {"Left Line2L Mux", "single-ended", "LINE2L"},
-        {"Left Line2L Mux", "differential", "LINE2L"},
-
         {"Left PGA Mixer", "Line1L Switch", "Left Line1L Mux"},
         {"Left PGA Mixer", "Line1R Switch", "Left Line1R Mux"},
-        {"Left PGA Mixer", "Line2L Switch", "Left Line2L Mux"},
-        {"Left PGA Mixer", "Mic3L Switch", "MIC3L"},
-        {"Left PGA Mixer", "Mic3R Switch", "MIC3R"},
 
         {"Left ADC", NULL, "Left PGA Mixer"},
-        {"Left ADC", NULL, "GPIO1 dmic modclk"},
 
         /* Right Input */
         {"Right Line1R Mux", "single-ended", "LINE1R"},
@@ -730,25 +808,10 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"Right Line1L Mux", "single-ended", "LINE1L"},
         {"Right Line1L Mux", "differential", "LINE1L"},
 
-        {"Right Line2R Mux", "single-ended", "LINE2R"},
-        {"Right Line2R Mux", "differential", "LINE2R"},
-
         {"Right PGA Mixer", "Line1L Switch", "Right Line1L Mux"},
         {"Right PGA Mixer", "Line1R Switch", "Right Line1R Mux"},
-        {"Right PGA Mixer", "Line2R Switch", "Right Line2R Mux"},
-        {"Right PGA Mixer", "Mic3L Switch", "MIC3L"},
-        {"Right PGA Mixer", "Mic3R Switch", "MIC3R"},
 
         {"Right ADC", NULL, "Right PGA Mixer"},
-        {"Right ADC", NULL, "GPIO1 dmic modclk"},
-
-        /*
-         * Logical path between digital mic enable and GPIO1 modulator clock
-         * output function
-         */
-        {"GPIO1 dmic modclk", NULL, "DMic Rate 128"},
-        {"GPIO1 dmic modclk", NULL, "DMic Rate 64"},
-        {"GPIO1 dmic modclk", NULL, "DMic Rate 32"},
 
         /* Left DAC Output */
         {"Left DAC Mux", "DAC_L1", "Left DAC"},
@@ -761,10 +824,8 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"Right DAC Mux", "DAC_R3", "Right DAC"},
 
         /* Left Line Output */
-        {"Left Line Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
         {"Left Line Mixer", "PGAL Bypass Switch", "Left PGA Mixer"},
         {"Left Line Mixer", "DACL1 Switch", "Left DAC Mux"},
-        {"Left Line Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
         {"Left Line Mixer", "PGAR Bypass Switch", "Right PGA Mixer"},
         {"Left Line Mixer", "DACR1 Switch", "Right DAC Mux"},
 
@@ -773,10 +834,8 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"LLOUT", NULL, "Left Line Out"},
 
         /* Right Line Output */
-        {"Right Line Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
         {"Right Line Mixer", "PGAL Bypass Switch", "Left PGA Mixer"},
         {"Right Line Mixer", "DACL1 Switch", "Left DAC Mux"},
-        {"Right Line Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
         {"Right Line Mixer", "PGAR Bypass Switch", "Right PGA Mixer"},
         {"Right Line Mixer", "DACR1 Switch", "Right DAC Mux"},
 
@@ -785,10 +844,8 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"RLOUT", NULL, "Right Line Out"},
 
         /* Left HP Output */
-        {"Left HP Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
         {"Left HP Mixer", "PGAL Bypass Switch", "Left PGA Mixer"},
         {"Left HP Mixer", "DACL1 Switch", "Left DAC Mux"},
-        {"Left HP Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
         {"Left HP Mixer", "PGAR Bypass Switch", "Right PGA Mixer"},
         {"Left HP Mixer", "DACR1 Switch", "Right DAC Mux"},
 
@@ -797,10 +854,8 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"HPLOUT", NULL, "Left HP Out"},
 
         /* Right HP Output */
-        {"Right HP Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
         {"Right HP Mixer", "PGAL Bypass Switch", "Left PGA Mixer"},
         {"Right HP Mixer", "DACL1 Switch", "Left DAC Mux"},
-        {"Right HP Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
         {"Right HP Mixer", "PGAR Bypass Switch", "Right PGA Mixer"},
         {"Right HP Mixer", "DACR1 Switch", "Right DAC Mux"},
 
@@ -809,10 +864,8 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"HPROUT", NULL, "Right HP Out"},
 
         /* Left HPCOM Output */
-        {"Left HPCOM Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
         {"Left HPCOM Mixer", "PGAL Bypass Switch", "Left PGA Mixer"},
         {"Left HPCOM Mixer", "DACL1 Switch", "Left DAC Mux"},
-        {"Left HPCOM Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
         {"Left HPCOM Mixer", "PGAR Bypass Switch", "Right PGA Mixer"},
         {"Left HPCOM Mixer", "DACR1 Switch", "Right DAC Mux"},
 
@@ -823,10 +876,8 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"HPLCOM", NULL, "Left HP Com"},
 
         /* Right HPCOM Output */
-        {"Right HPCOM Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
         {"Right HPCOM Mixer", "PGAL Bypass Switch", "Left PGA Mixer"},
         {"Right HPCOM Mixer", "DACL1 Switch", "Left DAC Mux"},
-        {"Right HPCOM Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
         {"Right HPCOM Mixer", "PGAR Bypass Switch", "Right PGA Mixer"},
         {"Right HPCOM Mixer", "DACR1 Switch", "Right DAC Mux"},
 
@@ -839,6 +890,72 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"HPRCOM", NULL, "Right HP Com"},
 };
 
+/* For other than tlv320aic3104 */
+static const struct snd_soc_dapm_route intercon_extra[] = {
+        /* Left Input */
+        {"Left Line2L Mux", "single-ended", "LINE2L"},
+        {"Left Line2L Mux", "differential", "LINE2L"},
+
+        {"Left PGA Mixer", "Line2L Switch", "Left Line2L Mux"},
+        {"Left PGA Mixer", "Mic3L Switch", "MIC3L"},
+        {"Left PGA Mixer", "Mic3R Switch", "MIC3R"},
+
+        {"Left ADC", NULL, "GPIO1 dmic modclk"},
+
+        /* Right Input */
+        {"Right Line2R Mux", "single-ended", "LINE2R"},
+        {"Right Line2R Mux", "differential", "LINE2R"},
+
+        {"Right PGA Mixer", "Line2R Switch", "Right Line2R Mux"},
+        {"Right PGA Mixer", "Mic3L Switch", "MIC3L"},
+        {"Right PGA Mixer", "Mic3R Switch", "MIC3R"},
+
+        {"Right ADC", NULL, "GPIO1 dmic modclk"},
+
+        /*
+         * Logical path between digital mic enable and GPIO1 modulator clock
+         * output function
+         */
+        {"GPIO1 dmic modclk", NULL, "DMic Rate 128"},
+        {"GPIO1 dmic modclk", NULL, "DMic Rate 64"},
+        {"GPIO1 dmic modclk", NULL, "DMic Rate 32"},
+
+        /* Left Line Output */
+        {"Left Line Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
+        {"Left Line Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
+
+        /* Right Line Output */
+        {"Right Line Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
+        {"Right Line Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
+
+        /* Left HP Output */
+        {"Left HP Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
+        {"Left HP Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
+
+        /* Right HP Output */
+        {"Right HP Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
+        {"Right HP Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
+
+        /* Left HPCOM Output */
+        {"Left HPCOM Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
+        {"Left HPCOM Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
+
+        /* Right HPCOM Output */
+        {"Right HPCOM Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
+        {"Right HPCOM Mixer", "Line2R Bypass Switch", "Right Line2R Mux"},
+};
+
+/* For tlv320aic3104 */
+static const struct snd_soc_dapm_route intercon_extra_3104[] = {
+        /* Left Input */
+        {"Left PGA Mixer", "Mic2L Switch", "MIC2L"},
+        {"Left PGA Mixer", "Mic2R Switch", "MIC2R"},
+
+        /* Right Input */
+        {"Right PGA Mixer", "Mic2L Switch", "MIC2L"},
+        {"Right PGA Mixer", "Mic2R Switch", "MIC2R"},
+};
+
 static const struct snd_soc_dapm_route intercon_mono[] = {
         /* Mono Output */
         {"Mono Mixer", "Line2L Bypass Switch", "Left Line2L Mux"},
@@ -867,17 +984,31 @@ static int aic3x_add_widgets(struct snd_soc_codec *codec)
         switch (aic3x->model) {
         case AIC3X_MODEL_3X:
         case AIC3X_MODEL_33:
+                snd_soc_dapm_new_controls(dapm, aic3x_extra_dapm_widgets,
+                                          ARRAY_SIZE(aic3x_extra_dapm_widgets));
+                snd_soc_dapm_add_routes(dapm, intercon_extra,
+                                        ARRAY_SIZE(intercon_extra));
                 snd_soc_dapm_new_controls(dapm, aic3x_dapm_mono_widgets,
                         ARRAY_SIZE(aic3x_dapm_mono_widgets));
                 snd_soc_dapm_add_routes(dapm, intercon_mono,
                                         ARRAY_SIZE(intercon_mono));
                 break;
         case AIC3X_MODEL_3007:
+                snd_soc_dapm_new_controls(dapm, aic3x_extra_dapm_widgets,
+                                          ARRAY_SIZE(aic3x_extra_dapm_widgets));
+                snd_soc_dapm_add_routes(dapm, intercon_extra,
+                                        ARRAY_SIZE(intercon_extra));
                 snd_soc_dapm_new_controls(dapm, aic3007_dapm_widgets,
                         ARRAY_SIZE(aic3007_dapm_widgets));
                 snd_soc_dapm_add_routes(dapm, intercon_3007,
                                         ARRAY_SIZE(intercon_3007));
                 break;
+        case AIC3X_MODEL_3104:
+                snd_soc_dapm_new_controls(dapm, aic3104_extra_dapm_widgets,
+                                ARRAY_SIZE(aic3104_extra_dapm_widgets));
+                snd_soc_dapm_add_routes(dapm, intercon_extra_3104,
+                                ARRAY_SIZE(intercon_extra_3104));
+                break;
         }
 
         return 0;
@@ -1438,23 +1569,33 @@ static int aic3x_probe(struct snd_soc_codec *codec)
         aic3x_init(codec);
 
         if (aic3x->setup) {
-                /* setup GPIO functions */
-                snd_soc_write(codec, AIC3X_GPIO1_REG,
-                              (aic3x->setup->gpio_func[0] & 0xf) << 4);
-                snd_soc_write(codec, AIC3X_GPIO2_REG,
-                              (aic3x->setup->gpio_func[1] & 0xf) << 4);
+                if (aic3x->model != AIC3X_MODEL_3104) {
+                        /* setup GPIO functions */
+                        snd_soc_write(codec, AIC3X_GPIO1_REG,
+                                      (aic3x->setup->gpio_func[0] & 0xf) << 4);
+                        snd_soc_write(codec, AIC3X_GPIO2_REG,
+                                      (aic3x->setup->gpio_func[1] & 0xf) << 4);
+                } else {
+                        dev_warn(codec->dev, "GPIO functionality is not supported on tlv320aic3104\n");
+                }
         }
 
         switch (aic3x->model) {
         case AIC3X_MODEL_3X:
         case AIC3X_MODEL_33:
+                snd_soc_add_codec_controls(codec, aic3x_extra_snd_controls,
+                                ARRAY_SIZE(aic3x_extra_snd_controls));
                 snd_soc_add_codec_controls(codec, aic3x_mono_controls,
                                 ARRAY_SIZE(aic3x_mono_controls));
                 break;
         case AIC3X_MODEL_3007:
+                snd_soc_add_codec_controls(codec, aic3x_extra_snd_controls,
+                                ARRAY_SIZE(aic3x_extra_snd_controls));
                 snd_soc_add_codec_controls(codec,
                                 &aic3x_classd_amp_gain_ctrl, 1);
                 break;
+        case AIC3X_MODEL_3104:
+                break;
         }
 
         /* set mic bias voltage */
@@ -1522,6 +1663,7 @@ static const struct i2c_device_id aic3x_i2c_id[] = {
         { "tlv320aic33", AIC3X_MODEL_33 },
         { "tlv320aic3007", AIC3X_MODEL_3007 },
         { "tlv320aic3106", AIC3X_MODEL_3X },
+        { "tlv320aic3104", AIC3X_MODEL_3104 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, aic3x_i2c_id);
@@ -1673,6 +1815,7 @@ static const struct of_device_id tlv320aic3x_of_match[] = {
         { .compatible = "ti,tlv320aic33" },
         { .compatible = "ti,tlv320aic3007" },
         { .compatible = "ti,tlv320aic3106" },
+        { .compatible = "ti,tlv320aic3104" },
         {},
 };
 MODULE_DEVICE_TABLE(of, tlv320aic3x_of_match);
diff --git a/sound/soc/codecs/tlv320dac33.c b/sound/soc/codecs/tlv320dac33.c
index 0fe2ced5b09f..4e3e607dec13 100644
--- a/sound/soc/codecs/tlv320dac33.c
+++ b/sound/soc/codecs/tlv320dac33.c
@@ -423,17 +423,18 @@ exit:
 static int dac33_playback_event(struct snd_soc_dapm_widget *w,
                 struct snd_kcontrol *kcontrol, int event)
 {
-        struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
                 if (likely(dac33->substream)) {
-                        dac33_calculate_times(dac33->substream, w->codec);
-                        dac33_prepare_chip(dac33->substream, w->codec);
+                        dac33_calculate_times(dac33->substream, codec);
+                        dac33_prepare_chip(dac33->substream, codec);
                 }
                 break;
         case SND_SOC_DAPM_POST_PMD:
-                dac33_disable_digital(w->codec);
+                dac33_disable_digital(codec);
                 break;
         }
         return 0;
diff --git a/sound/soc/codecs/ts3a227e.c b/sound/soc/codecs/ts3a227e.c
index 9f2dced046de..9fd80ac1897f 100644
--- a/sound/soc/codecs/ts3a227e.c
+++ b/sound/soc/codecs/ts3a227e.c
@@ -20,6 +20,8 @@
 #include <sound/jack.h>
 #include <sound/soc.h>
 
+#include "ts3a227e.h"
+
 struct ts3a227e {
         struct regmap *regmap;
         struct snd_soc_jack *jack;
@@ -79,6 +81,10 @@ static const int ts3a227e_buttons[] = {
 /* TS3A227E_REG_SETTING_2 0x05 */
 #define KP_ENABLE 0x04
 
+/* TS3A227E_REG_SETTING_3 0x06 */
+#define MICBIAS_SETTING_SFT (3)
+#define MICBIAS_SETTING_MASK (0x7 << MICBIAS_SETTING_SFT)
+
 /* TS3A227E_REG_ACCESSORY_STATUS  0x0b */
 #define TYPE_3_POLE 0x01
 #define TYPE_4_POLE_OMTP 0x02
@@ -221,9 +227,9 @@ int ts3a227e_enable_jack_detect(struct snd_soc_component *component,
         struct ts3a227e *ts3a227e = snd_soc_component_get_drvdata(component);
 
         snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_MEDIA);
-        snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOLUMEUP);
-        snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEDOWN);
-        snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOICECOMMAND);
+        snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
+        snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
+        snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
 
         ts3a227e->jack = jack;
         ts3a227e_jack_report(ts3a227e);
@@ -248,6 +254,21 @@ static const struct regmap_config ts3a227e_regmap_config = {
         .num_reg_defaults = ARRAY_SIZE(ts3a227e_reg_defaults),
 };
 
+static int ts3a227e_parse_dt(struct ts3a227e *ts3a227e, struct device_node *np)
+{
+        u32 micbias;
+        int err;
+
+        err = of_property_read_u32(np, "ti,micbias", &micbias);
+        if (!err) {
+                regmap_update_bits(ts3a227e->regmap, TS3A227E_REG_SETTING_3,
+                        MICBIAS_SETTING_MASK,
+                        (micbias & 0x07) << MICBIAS_SETTING_SFT);
+        }
+
+        return 0;
+}
+
 static int ts3a227e_i2c_probe(struct i2c_client *i2c,
                               const struct i2c_device_id *id)
 {
@@ -266,6 +287,14 @@ static int ts3a227e_i2c_probe(struct i2c_client *i2c,
         if (IS_ERR(ts3a227e->regmap))
                 return PTR_ERR(ts3a227e->regmap);
 
+        if (dev->of_node) {
+                ret = ts3a227e_parse_dt(ts3a227e, dev->of_node);
+                if (ret) {
+                        dev_err(dev, "Failed to parse device tree: %d\n", ret);
+                        return ret;
+                }
+        }
+
         ret = devm_request_threaded_irq(dev, i2c->irq, NULL, ts3a227e_interrupt,
                                         IRQF_TRIGGER_LOW | IRQF_ONESHOT,
                                         "TS3A227E", ts3a227e);
diff --git a/sound/soc/codecs/twl4030.c b/sound/soc/codecs/twl4030.c
index 44af3188afb9..d04693e9cf9f 100644
--- a/sound/soc/codecs/twl4030.c
+++ b/sound/soc/codecs/twl4030.c
@@ -567,12 +567,13 @@ static const struct snd_kcontrol_new twl4030_dapm_dbypassv_control =
 static int pin_name##pga_event(struct snd_soc_dapm_widget *w,           \
                                struct snd_kcontrol *kcontrol, int event) \
 {                                                                       \
-        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(w->codec); \
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);   \
+        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec); \
                                                                         \
         switch (event) {                                                \
         case SND_SOC_DAPM_POST_PMU:                                     \
                 twl4030->pin_name##_enabled = 1;                        \
-                twl4030_write(w->codec, reg, twl4030_read(w->codec, reg)); \
+                twl4030_write(codec, reg, twl4030_read(codec, reg));    \
                 break;                                                  \
         case SND_SOC_DAPM_POST_PMD:                                     \
                 twl4030->pin_name##_enabled = 0;                        \
@@ -621,12 +622,14 @@ static void handsfree_ramp(struct snd_soc_codec *codec, int reg, int ramp)
 static int handsfreelpga_event(struct snd_soc_dapm_widget *w,
                                struct snd_kcontrol *kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
-                handsfree_ramp(w->codec, TWL4030_REG_HFL_CTL, 1);
+                handsfree_ramp(codec, TWL4030_REG_HFL_CTL, 1);
                 break;
         case SND_SOC_DAPM_POST_PMD:
-                handsfree_ramp(w->codec, TWL4030_REG_HFL_CTL, 0);
+                handsfree_ramp(codec, TWL4030_REG_HFL_CTL, 0);
                 break;
         }
         return 0;
@@ -635,12 +638,14 @@ static int handsfreelpga_event(struct snd_soc_dapm_widget *w,
 static int handsfreerpga_event(struct snd_soc_dapm_widget *w,
                                struct snd_kcontrol *kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
-                handsfree_ramp(w->codec, TWL4030_REG_HFR_CTL, 1);
+                handsfree_ramp(codec, TWL4030_REG_HFR_CTL, 1);
                 break;
         case SND_SOC_DAPM_POST_PMD:
-                handsfree_ramp(w->codec, TWL4030_REG_HFR_CTL, 0);
+                handsfree_ramp(codec, TWL4030_REG_HFR_CTL, 0);
                 break;
         }
         return 0;
@@ -649,19 +654,23 @@ static int handsfreerpga_event(struct snd_soc_dapm_widget *w,
 static int vibramux_event(struct snd_soc_dapm_widget *w,
                           struct snd_kcontrol *kcontrol, int event)
 {
-        twl4030_write(w->codec, TWL4030_REG_VIBRA_SET, 0xff);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+
+        twl4030_write(codec, TWL4030_REG_VIBRA_SET, 0xff);
         return 0;
 }
 
 static int apll_event(struct snd_soc_dapm_widget *w,
                       struct snd_kcontrol *kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
-                twl4030_apll_enable(w->codec, 1);
+                twl4030_apll_enable(codec, 1);
                 break;
         case SND_SOC_DAPM_POST_PMD:
-                twl4030_apll_enable(w->codec, 0);
+                twl4030_apll_enable(codec, 0);
                 break;
         }
         return 0;
@@ -670,23 +679,24 @@ static int apll_event(struct snd_soc_dapm_widget *w,
 static int aif_event(struct snd_soc_dapm_widget *w,
                      struct snd_kcontrol *kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         u8 audio_if;
 
-        audio_if = twl4030_read(w->codec, TWL4030_REG_AUDIO_IF);
+        audio_if = twl4030_read(codec, TWL4030_REG_AUDIO_IF);
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
                 /* Enable AIF */
                 /* enable the PLL before we use it to clock the DAI */
-                twl4030_apll_enable(w->codec, 1);
+                twl4030_apll_enable(codec, 1);
 
-                twl4030_write(w->codec, TWL4030_REG_AUDIO_IF,
+                twl4030_write(codec, TWL4030_REG_AUDIO_IF,
                               audio_if | TWL4030_AIF_EN);
                 break;
         case SND_SOC_DAPM_POST_PMD:
                 /* disable the DAI before we stop it's source PLL */
-                twl4030_write(w->codec, TWL4030_REG_AUDIO_IF,
+                twl4030_write(codec, TWL4030_REG_AUDIO_IF,
                               audio_if &  ~TWL4030_AIF_EN);
-                twl4030_apll_enable(w->codec, 0);
+                twl4030_apll_enable(codec, 0);
                 break;
         }
         return 0;
@@ -758,20 +768,21 @@ static void headset_ramp(struct snd_soc_codec *codec, int ramp)
 static int headsetlpga_event(struct snd_soc_dapm_widget *w,
                              struct snd_kcontrol *kcontrol, int event)
 {
-        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
                 /* Do the ramp-up only once */
                 if (!twl4030->hsr_enabled)
-                        headset_ramp(w->codec, 1);
+                        headset_ramp(codec, 1);
 
                 twl4030->hsl_enabled = 1;
                 break;
         case SND_SOC_DAPM_POST_PMD:
                 /* Do the ramp-down only if both headsetL/R is disabled */
                 if (!twl4030->hsr_enabled)
-                        headset_ramp(w->codec, 0);
+                        headset_ramp(codec, 0);
 
                 twl4030->hsl_enabled = 0;
                 break;
@@ -782,20 +793,21 @@ static int headsetlpga_event(struct snd_soc_dapm_widget *w,
 static int headsetrpga_event(struct snd_soc_dapm_widget *w,
                              struct snd_kcontrol *kcontrol, int event)
 {
-        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
                 /* Do the ramp-up only once */
                 if (!twl4030->hsl_enabled)
-                        headset_ramp(w->codec, 1);
+                        headset_ramp(codec, 1);
 
                 twl4030->hsr_enabled = 1;
                 break;
         case SND_SOC_DAPM_POST_PMD:
                 /* Do the ramp-down only if both headsetL/R is disabled */
                 if (!twl4030->hsl_enabled)
-                        headset_ramp(w->codec, 0);
+                        headset_ramp(codec, 0);
 
                 twl4030->hsr_enabled = 0;
                 break;
@@ -806,7 +818,8 @@ static int headsetrpga_event(struct snd_soc_dapm_widget *w,
 static int digimic_event(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol, int event)
 {
-        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
         struct twl4030_codec_data *pdata = twl4030->pdata;
 
         if (pdata && pdata->digimic_delay)
diff --git a/sound/soc/codecs/twl6040.c b/sound/soc/codecs/twl6040.c
index 90f47f988b3f..aeec27b6f1af 100644
--- a/sound/soc/codecs/twl6040.c
+++ b/sound/soc/codecs/twl6040.c
@@ -234,7 +234,7 @@ static int headset_power_mode(struct snd_soc_codec *codec, int high_perf)
 static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w,
                         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         u8 hslctl, hsrctl;
 
         /*
@@ -261,7 +261,7 @@ static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w,
 static int twl6040_ep_drv_event(struct snd_soc_dapm_widget *w,
                         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec);
         int ret = 0;
 
diff --git a/sound/soc/codecs/wm2000.c b/sound/soc/codecs/wm2000.c
index 34ef65c52a7d..8d9de49a5052 100644
--- a/sound/soc/codecs/wm2000.c
+++ b/sound/soc/codecs/wm2000.c
@@ -683,7 +683,7 @@ static const struct snd_kcontrol_new wm2000_controls[] = {
 static int wm2000_anc_power_event(struct snd_soc_dapm_widget *w,
                                   struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm2000_priv *wm2000 = dev_get_drvdata(codec->dev);
         int ret;
 
diff --git a/sound/soc/codecs/wm5100.c b/sound/soc/codecs/wm5100.c
index b80970dc2d2f..ea09db585aa1 100644
--- a/sound/soc/codecs/wm5100.c
+++ b/sound/soc/codecs/wm5100.c
@@ -775,7 +775,8 @@ static int wm5100_out_ev(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol,
                          int event)
 {
-        struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec);
 
         switch (w->reg) {
         case WM5100_CHANNEL_ENABLES_1:
@@ -839,7 +840,7 @@ static int wm5100_post_ev(struct snd_soc_dapm_widget *w,
                           struct snd_kcontrol *kcontrol,
                           int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm5100_priv *wm5100 = snd_soc_codec_get_drvdata(codec);
         int ret;
 
diff --git a/sound/soc/codecs/wm5102.c b/sound/soc/codecs/wm5102.c
index f439ae052128..6d0fe0ac95a3 100644
--- a/sound/soc/codecs/wm5102.c
+++ b/sound/soc/codecs/wm5102.c
@@ -28,6 +28,7 @@
 
 #include <linux/mfd/arizona/core.h>
 #include <linux/mfd/arizona/registers.h>
+#include <asm/unaligned.h>
 
 #include "arizona.h"
 #include "wm5102.h"
@@ -580,7 +581,7 @@ static const struct reg_default wm5102_sysclk_revb_patch[] = {
 static int wm5102_sysclk_ev(struct snd_soc_dapm_widget *w,
                             struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct arizona *arizona = dev_get_drvdata(codec->dev->parent);
         struct regmap *regmap = arizona->regmap;
         const struct reg_default *patch = NULL;
@@ -617,11 +618,10 @@ static int wm5102_out_comp_coeff_get(struct snd_kcontrol *kcontrol,
 {
         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
         struct arizona *arizona = dev_get_drvdata(codec->dev->parent);
-        uint16_t data;
 
         mutex_lock(&arizona->dac_comp_lock);
-        data = cpu_to_be16(arizona->dac_comp_coeff);
-        memcpy(ucontrol->value.bytes.data, &data, sizeof(data));
+        put_unaligned_be16(arizona->dac_comp_coeff,
+                           ucontrol->value.bytes.data);
         mutex_unlock(&arizona->dac_comp_lock);
 
         return 0;
@@ -1272,19 +1272,24 @@ SND_SOC_DAPM_MUX("AEC Loopback", ARIZONA_DAC_AEC_CONTROL_1,
 
 SND_SOC_DAPM_PGA_E("OUT1L", SND_SOC_NOPM,
                    ARIZONA_OUT1L_ENA_SHIFT, 0, NULL, 0, arizona_hp_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT1R", SND_SOC_NOPM,
                    ARIZONA_OUT1R_ENA_SHIFT, 0, NULL, 0, arizona_hp_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT2L", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT2L_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT2R", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT2R_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT3L", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT3L_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT5L", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT5L_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
                    SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
diff --git a/sound/soc/codecs/wm5110.c b/sound/soc/codecs/wm5110.c
index 4456b38a3ef5..fbaeddb3e903 100644
--- a/sound/soc/codecs/wm5110.c
+++ b/sound/soc/codecs/wm5110.c
@@ -134,7 +134,7 @@ static const struct reg_default wm5110_sysclk_revd_patch[] = {
 static int wm5110_sysclk_ev(struct snd_soc_dapm_widget *w,
                             struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct arizona *arizona = dev_get_drvdata(codec->dev->parent);
         struct regmap *regmap = arizona->regmap;
         const struct reg_default *patch = NULL;
@@ -905,22 +905,28 @@ SND_SOC_DAPM_AIF_IN("AIF3RX2", NULL, 0,
 
 SND_SOC_DAPM_PGA_E("OUT1L", SND_SOC_NOPM,
                    ARIZONA_OUT1L_ENA_SHIFT, 0, NULL, 0, arizona_hp_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT1R", SND_SOC_NOPM,
                    ARIZONA_OUT1R_ENA_SHIFT, 0, NULL, 0, arizona_hp_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT2L", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT2L_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT2R", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT2R_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT3L", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT3L_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT3R", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT3R_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT5L", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT5L_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
                    SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
diff --git a/sound/soc/codecs/wm8350.c b/sound/soc/codecs/wm8350.c
index 574579b98872..c81a9eab3e3e 100644
--- a/sound/soc/codecs/wm8350.c
+++ b/sound/soc/codecs/wm8350.c
@@ -259,7 +259,7 @@ static void wm8350_pga_work(struct work_struct *work)
 static int pga_event(struct snd_soc_dapm_widget *w,
                      struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec);
         struct wm8350_output *out;
 
diff --git a/sound/soc/codecs/wm8400.c b/sound/soc/codecs/wm8400.c
index 8ee446987aa9..b0d84e552fca 100644
--- a/sound/soc/codecs/wm8400.c
+++ b/sound/soc/codecs/wm8400.c
@@ -324,6 +324,7 @@ SOC_SINGLE("RIN34 Mute Switch", WM8400_RIGHT_LINE_INPUT_3_4_VOLUME,
 static int outmixer_event (struct snd_soc_dapm_widget *w,
         struct snd_kcontrol * kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct soc_mixer_control *mc =
                 (struct soc_mixer_control *)kcontrol->private_value;
         u32 reg_shift = mc->shift;
@@ -332,7 +333,7 @@ static int outmixer_event (struct snd_soc_dapm_widget *w,
 
         switch (reg_shift) {
         case WM8400_SPEAKER_MIXER | (WM8400_LDSPK << 8) :
-                reg = snd_soc_read(w->codec, WM8400_OUTPUT_MIXER1);
+                reg = snd_soc_read(codec, WM8400_OUTPUT_MIXER1);
                 if (reg & WM8400_LDLO) {
                         printk(KERN_WARNING
                         "Cannot set as Output Mixer 1 LDLO Set\n");
@@ -340,7 +341,7 @@ static int outmixer_event (struct snd_soc_dapm_widget *w,
                 }
                 break;
         case WM8400_SPEAKER_MIXER | (WM8400_RDSPK << 8):
-                reg = snd_soc_read(w->codec, WM8400_OUTPUT_MIXER2);
+                reg = snd_soc_read(codec, WM8400_OUTPUT_MIXER2);
                 if (reg & WM8400_RDRO) {
                         printk(KERN_WARNING
                         "Cannot set as Output Mixer 2 RDRO Set\n");
@@ -348,7 +349,7 @@ static int outmixer_event (struct snd_soc_dapm_widget *w,
                 }
                 break;
         case WM8400_OUTPUT_MIXER1 | (WM8400_LDLO << 8):
-                reg = snd_soc_read(w->codec, WM8400_SPEAKER_MIXER);
+                reg = snd_soc_read(codec, WM8400_SPEAKER_MIXER);
                 if (reg & WM8400_LDSPK) {
                         printk(KERN_WARNING
                         "Cannot set as Speaker Mixer LDSPK Set\n");
@@ -356,7 +357,7 @@ static int outmixer_event (struct snd_soc_dapm_widget *w,
                 }
                 break;
         case WM8400_OUTPUT_MIXER2 | (WM8400_RDRO << 8):
-                reg = snd_soc_read(w->codec, WM8400_SPEAKER_MIXER);
+                reg = snd_soc_read(codec, WM8400_SPEAKER_MIXER);
                 if (reg & WM8400_RDSPK) {
                         printk(KERN_WARNING
                         "Cannot set as Speaker Mixer RDSPK Set\n");
diff --git a/sound/soc/codecs/wm8731.c b/sound/soc/codecs/wm8731.c
index b115ed815db9..098c143f44d6 100644
--- a/sound/soc/codecs/wm8731.c
+++ b/sound/soc/codecs/wm8731.c
@@ -217,7 +217,8 @@ SND_SOC_DAPM_INPUT("LLINEIN"),
 static int wm8731_check_osc(struct snd_soc_dapm_widget *source,
                             struct snd_soc_dapm_widget *sink)
 {
-        struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(source->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
+        struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec);
 
         return wm8731->sysclk_type == WM8731_SYSCLK_XTAL;
 }
diff --git a/sound/soc/codecs/wm8750.c b/sound/soc/codecs/wm8750.c
index f6847fdd6ddd..eb0a1644ba11 100644
--- a/sound/soc/codecs/wm8750.c
+++ b/sound/soc/codecs/wm8750.c
@@ -323,7 +323,7 @@ static const struct snd_soc_dapm_widget wm8750_dapm_widgets[] = {
         SND_SOC_DAPM_OUTPUT("ROUT2"),
         SND_SOC_DAPM_OUTPUT("MONO1"),
         SND_SOC_DAPM_OUTPUT("OUT3"),
-        SND_SOC_DAPM_OUTPUT("VREF"),
+        SND_SOC_DAPM_VMID("VREF"),
 
         SND_SOC_DAPM_INPUT("LINPUT1"),
         SND_SOC_DAPM_INPUT("LINPUT2"),
diff --git a/sound/soc/codecs/wm8770.c b/sound/soc/codecs/wm8770.c
index 180e7a098726..53e977da2f86 100644
--- a/sound/soc/codecs/wm8770.c
+++ b/sound/soc/codecs/wm8770.c
@@ -308,9 +308,7 @@ static const struct snd_soc_dapm_route wm8770_intercon[] = {
 static int vout12supply_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec;
-
-        codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
@@ -327,9 +325,7 @@ static int vout12supply_event(struct snd_soc_dapm_widget *w,
 static int vout34supply_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec;
-
-        codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
diff --git a/sound/soc/codecs/wm8804.c b/sound/soc/codecs/wm8804.c
index 1315f7642503..b2b0e68f707e 100644
--- a/sound/soc/codecs/wm8804.c
+++ b/sound/soc/codecs/wm8804.c
@@ -648,7 +648,7 @@ static struct snd_soc_dai_driver wm8804_dai = {
         .symmetric_rates = 1
 };
 
-static struct snd_soc_codec_driver soc_codec_dev_wm8804 = {
+static const struct snd_soc_codec_driver soc_codec_dev_wm8804 = {
         .probe = wm8804_probe,
         .remove = wm8804_remove,
         .set_bias_level = wm8804_set_bias_level,
@@ -664,7 +664,7 @@ static const struct of_device_id wm8804_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, wm8804_of_match);
 
-static struct regmap_config wm8804_regmap_config = {
+static const struct regmap_config wm8804_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
 
diff --git a/sound/soc/codecs/wm8900.c b/sound/soc/codecs/wm8900.c
index 3a0d4b7d692f..2eb986c19b88 100644
--- a/sound/soc/codecs/wm8900.c
+++ b/sound/soc/codecs/wm8900.c
@@ -224,7 +224,7 @@ static void wm8900_reset(struct snd_soc_codec *codec)
 static int wm8900_hp_event(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         u16 hpctl1 = snd_soc_read(codec, WM8900_REG_HPCTL1);
 
         switch (event) {
diff --git a/sound/soc/codecs/wm8903.c b/sound/soc/codecs/wm8903.c
index cc6b0ef98a34..dde462c082be 100644
--- a/sound/soc/codecs/wm8903.c
+++ b/sound/soc/codecs/wm8903.c
@@ -260,7 +260,7 @@ static int wm8903_cp_event(struct snd_soc_dapm_widget *w,
 static int wm8903_dcs_event(struct snd_soc_dapm_widget *w,
                             struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm8903_priv *wm8903 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
diff --git a/sound/soc/codecs/wm8904.c b/sound/soc/codecs/wm8904.c
index 75b87c5c0f04..d3b3f57668cc 100644
--- a/sound/soc/codecs/wm8904.c
+++ b/sound/soc/codecs/wm8904.c
@@ -673,7 +673,7 @@ static int cp_event(struct snd_soc_dapm_widget *w,
 static int sysclk_event(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -711,7 +711,7 @@ static int sysclk_event(struct snd_soc_dapm_widget *w,
 static int out_pga_event(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm8904_priv *wm8904 = snd_soc_codec_get_drvdata(codec);
         int reg, val;
         int dcs_mask;
@@ -2105,6 +2105,24 @@ static const struct regmap_config wm8904_regmap = {
         .num_reg_defaults = ARRAY_SIZE(wm8904_reg_defaults),
 };
 
+#ifdef CONFIG_OF
+static enum wm8904_type wm8904_data = WM8904;
+static enum wm8904_type wm8912_data = WM8912;
+
+static const struct of_device_id wm8904_of_match[] = {
+        {
+                .compatible = "wlf,wm8904",
+                .data = &wm8904_data,
+        }, {
+                .compatible = "wlf,wm8912",
+                .data = &wm8912_data,
+        }, {
+                /* sentinel */
+        }
+};
+MODULE_DEVICE_TABLE(of, wm8904_of_match);
+#endif
+
 static int wm8904_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
@@ -2132,7 +2150,17 @@ static int wm8904_i2c_probe(struct i2c_client *i2c,
                 return ret;
         }
 
-        wm8904->devtype = id->driver_data;
+        if (i2c->dev.of_node) {
+                const struct of_device_id *match;
+
+                match = of_match_node(wm8904_of_match, i2c->dev.of_node);
+                if (match == NULL)
+                        return -EINVAL;
+                wm8904->devtype = *((enum wm8904_type *)match->data);
+        } else {
+                wm8904->devtype = id->driver_data;
+        }
+
         i2c_set_clientdata(i2c, wm8904);
         wm8904->pdata = i2c->dev.platform_data;
 
@@ -2266,6 +2294,7 @@ static struct i2c_driver wm8904_i2c_driver = {
         .driver = {
                 .name = "wm8904",
                 .owner = THIS_MODULE,
+                .of_match_table = of_match_ptr(wm8904_of_match),
         },
         .probe =    wm8904_i2c_probe,
         .remove =   wm8904_i2c_remove,
diff --git a/sound/soc/codecs/wm8955.c b/sound/soc/codecs/wm8955.c
index 1173f7fef5a7..1ab2d462afad 100644
--- a/sound/soc/codecs/wm8955.c
+++ b/sound/soc/codecs/wm8955.c
@@ -333,7 +333,7 @@ static int wm8955_configure_clocking(struct snd_soc_codec *codec)
 static int wm8955_sysclk(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         int ret = 0;
 
         /* Always disable the clocks - if we're doing reconfiguration this
diff --git a/sound/soc/codecs/wm8958-dsp2.c b/sound/soc/codecs/wm8958-dsp2.c
index 3cbc82b33292..c799cca5abeb 100644
--- a/sound/soc/codecs/wm8958-dsp2.c
+++ b/sound/soc/codecs/wm8958-dsp2.c
@@ -418,7 +418,7 @@ static void wm8958_dsp_apply(struct snd_soc_codec *codec, int path, int start)
 int wm8958_aif_ev(struct snd_soc_dapm_widget *w,
                   struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         int i;
 
         switch (event) {
diff --git a/sound/soc/codecs/wm8960.c b/sound/soc/codecs/wm8960.c
index a96eb497a379..cf8fecf97f2c 100644
--- a/sound/soc/codecs/wm8960.c
+++ b/sound/soc/codecs/wm8960.c
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
+#include <linux/clk.h>
 #include <linux/i2c.h>
 #include <linux/slab.h>
 #include <sound/core.h>
@@ -117,6 +118,7 @@ static bool wm8960_volatile(struct device *dev, unsigned int reg)
 }
 
 struct wm8960_priv {
+        struct clk *mclk;
         struct regmap *regmap;
         int (*set_bias_level)(struct snd_soc_codec *,
                               enum snd_soc_bias_level level);
@@ -618,14 +620,38 @@ static int wm8960_set_bias_level_out3(struct snd_soc_codec *codec,
                                       enum snd_soc_bias_level level)
 {
         struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
+        int ret;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
                 break;
 
         case SND_SOC_BIAS_PREPARE:
-                /* Set VMID to 2x50k */
-                snd_soc_update_bits(codec, WM8960_POWER1, 0x180, 0x80);
+                switch (codec->dapm.bias_level) {
+                case SND_SOC_BIAS_STANDBY:
+                        if (!IS_ERR(wm8960->mclk)) {
+                                ret = clk_prepare_enable(wm8960->mclk);
+                                if (ret) {
+                                        dev_err(codec->dev,
+                                                "Failed to enable MCLK: %d\n",
+                                                ret);
+                                        return ret;
+                                }
+                        }
+
+                        /* Set VMID to 2x50k */
+                        snd_soc_update_bits(codec, WM8960_POWER1, 0x180, 0x80);
+                        break;
+
+                case SND_SOC_BIAS_ON:
+                        if (!IS_ERR(wm8960->mclk))
+                                clk_disable_unprepare(wm8960->mclk);
+                        break;
+
+                default:
+                        break;
+                }
+
                 break;
 
         case SND_SOC_BIAS_STANDBY:
@@ -674,7 +700,7 @@ static int wm8960_set_bias_level_capless(struct snd_soc_codec *codec,
                                          enum snd_soc_bias_level level)
 {
         struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
-        int reg;
+        int reg, ret;
 
         switch (level) {
         case SND_SOC_BIAS_ON:
@@ -715,9 +741,22 @@ static int wm8960_set_bias_level_capless(struct snd_soc_codec *codec,
                                             WM8960_VREF, WM8960_VREF);
 
                         msleep(100);
+
+                        if (!IS_ERR(wm8960->mclk)) {
+                                ret = clk_prepare_enable(wm8960->mclk);
+                                if (ret) {
+                                        dev_err(codec->dev,
+                                                "Failed to enable MCLK: %d\n",
+                                                ret);
+                                        return ret;
+                                }
+                        }
                         break;
 
                 case SND_SOC_BIAS_ON:
+                        if (!IS_ERR(wm8960->mclk))
+                                clk_disable_unprepare(wm8960->mclk);
+
                         /* Enable anti-pop mode */
                         snd_soc_update_bits(codec, WM8960_APOP1,
                                             WM8960_POBCTRL | WM8960_SOFT_ST |
@@ -1002,6 +1041,12 @@ static int wm8960_i2c_probe(struct i2c_client *i2c,
         if (wm8960 == NULL)
                 return -ENOMEM;
 
+        wm8960->mclk = devm_clk_get(&i2c->dev, "mclk");
+        if (IS_ERR(wm8960->mclk)) {
+                if (PTR_ERR(wm8960->mclk) == -EPROBE_DEFER)
+                        return -EPROBE_DEFER;
+        }
+
         wm8960->regmap = devm_regmap_init_i2c(i2c, &wm8960_regmap);
         if (IS_ERR(wm8960->regmap))
                 return PTR_ERR(wm8960->regmap);
diff --git a/sound/soc/codecs/wm8961.c b/sound/soc/codecs/wm8961.c
index eeffd05384b4..95e2c1bfc809 100644
--- a/sound/soc/codecs/wm8961.c
+++ b/sound/soc/codecs/wm8961.c
@@ -194,7 +194,7 @@ static bool wm8961_readable(struct device *dev, unsigned int reg)
 static int wm8961_hp_event(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         u16 hp_reg = snd_soc_read(codec, WM8961_ANALOGUE_HP_0);
         u16 cp_reg = snd_soc_read(codec, WM8961_CHARGE_PUMP_1);
         u16 pwr_reg = snd_soc_read(codec, WM8961_PWR_MGMT_2);
@@ -286,7 +286,7 @@ static int wm8961_hp_event(struct snd_soc_dapm_widget *w,
 static int wm8961_spk_event(struct snd_soc_dapm_widget *w,
                             struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         u16 pwr_reg = snd_soc_read(codec, WM8961_PWR_MGMT_2);
         u16 spk_reg = snd_soc_read(codec, WM8961_CLASS_D_CONTROL_1);
 
diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c
index d32d554f5b34..118b0034ba23 100644
--- a/sound/soc/codecs/wm8962.c
+++ b/sound/soc/codecs/wm8962.c
@@ -1866,7 +1866,7 @@ static int cp_event(struct snd_soc_dapm_widget *w,
 static int hp_event(struct snd_soc_dapm_widget *w,
                     struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         int timeout;
         int reg;
         int expected = (WM8962_DCS_STARTUP_DONE_HP1L |
@@ -1960,7 +1960,7 @@ static int hp_event(struct snd_soc_dapm_widget *w,
 static int out_pga_event(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         int reg;
 
         switch (w->shift) {
@@ -1993,7 +1993,7 @@ static int out_pga_event(struct snd_soc_dapm_widget *w,
 static int dsp2_event(struct snd_soc_dapm_widget *w,
                       struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
diff --git a/sound/soc/codecs/wm8988.c b/sound/soc/codecs/wm8988.c
index e418199155a8..24968aa8618a 100644
--- a/sound/soc/codecs/wm8988.c
+++ b/sound/soc/codecs/wm8988.c
@@ -244,7 +244,7 @@ SOC_DOUBLE_R_TLV("Output 2 Playback Volume", WM8988_LOUT2V, WM8988_ROUT2V,
 static int wm8988_lrc_control(struct snd_soc_dapm_widget *w,
                               struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         u16 adctl2 = snd_soc_read(codec, WM8988_ADCTL2);
 
         /* Use the DAC to gate LRC if active, otherwise use ADC */
@@ -813,7 +813,7 @@ static int wm8988_probe(struct snd_soc_codec *codec)
         return 0;
 }
 
-static struct snd_soc_codec_driver soc_codec_dev_wm8988 = {
+static const struct snd_soc_codec_driver soc_codec_dev_wm8988 = {
         .probe =        wm8988_probe,
         .set_bias_level = wm8988_set_bias_level,
         .suspend_bias_off = true,
@@ -826,7 +826,7 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8988 = {
         .num_dapm_routes = ARRAY_SIZE(wm8988_dapm_routes),
 };
 
-static struct regmap_config wm8988_regmap = {
+static const struct regmap_config wm8988_regmap = {
         .reg_bits = 7,
         .val_bits = 9,
 
diff --git a/sound/soc/codecs/wm8990.c b/sound/soc/codecs/wm8990.c
index 8a584229310a..c93bffcb3cfb 100644
--- a/sound/soc/codecs/wm8990.c
+++ b/sound/soc/codecs/wm8990.c
@@ -374,13 +374,14 @@ SOC_SINGLE("RIN34 Mute Switch", WM8990_RIGHT_LINE_INPUT_3_4_VOLUME,
 static int outmixer_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         u32 reg_shift = kcontrol->private_value & 0xfff;
         int ret = 0;
         u16 reg;
 
         switch (reg_shift) {
         case WM8990_SPEAKER_MIXER | (WM8990_LDSPK_BIT << 8) :
-                reg = snd_soc_read(w->codec, WM8990_OUTPUT_MIXER1);
+                reg = snd_soc_read(codec, WM8990_OUTPUT_MIXER1);
                 if (reg & WM8990_LDLO) {
                         printk(KERN_WARNING
                         "Cannot set as Output Mixer 1 LDLO Set\n");
@@ -388,7 +389,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w,
                 }
                 break;
         case WM8990_SPEAKER_MIXER | (WM8990_RDSPK_BIT << 8):
-                reg = snd_soc_read(w->codec, WM8990_OUTPUT_MIXER2);
+                reg = snd_soc_read(codec, WM8990_OUTPUT_MIXER2);
                 if (reg & WM8990_RDRO) {
                         printk(KERN_WARNING
                         "Cannot set as Output Mixer 2 RDRO Set\n");
@@ -396,7 +397,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w,
                 }
                 break;
         case WM8990_OUTPUT_MIXER1 | (WM8990_LDLO_BIT << 8):
-                reg = snd_soc_read(w->codec, WM8990_SPEAKER_MIXER);
+                reg = snd_soc_read(codec, WM8990_SPEAKER_MIXER);
                 if (reg & WM8990_LDSPK) {
                         printk(KERN_WARNING
                         "Cannot set as Speaker Mixer LDSPK Set\n");
@@ -404,7 +405,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w,
                 }
                 break;
         case WM8990_OUTPUT_MIXER2 | (WM8990_RDRO_BIT << 8):
-                reg = snd_soc_read(w->codec, WM8990_SPEAKER_MIXER);
+                reg = snd_soc_read(codec, WM8990_SPEAKER_MIXER);
                 if (reg & WM8990_RDSPK) {
                         printk(KERN_WARNING
                         "Cannot set as Speaker Mixer RDSPK Set\n");
diff --git a/sound/soc/codecs/wm8991.c b/sound/soc/codecs/wm8991.c
index b0ac2c3e31b9..49df0dc607e6 100644
--- a/sound/soc/codecs/wm8991.c
+++ b/sound/soc/codecs/wm8991.c
@@ -382,13 +382,14 @@ static const struct snd_kcontrol_new wm8991_snd_controls[] = {
 static int outmixer_event(struct snd_soc_dapm_widget *w,
                           struct snd_kcontrol *kcontrol, int event)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         u32 reg_shift = kcontrol->private_value & 0xfff;
         int ret = 0;
         u16 reg;
 
         switch (reg_shift) {
         case WM8991_SPEAKER_MIXER | (WM8991_LDSPK_BIT << 8):
-                reg = snd_soc_read(w->codec, WM8991_OUTPUT_MIXER1);
+                reg = snd_soc_read(codec, WM8991_OUTPUT_MIXER1);
                 if (reg & WM8991_LDLO) {
                         printk(KERN_WARNING
                                "Cannot set as Output Mixer 1 LDLO Set\n");
@@ -397,7 +398,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w,
                 break;
 
         case WM8991_SPEAKER_MIXER | (WM8991_RDSPK_BIT << 8):
-                reg = snd_soc_read(w->codec, WM8991_OUTPUT_MIXER2);
+                reg = snd_soc_read(codec, WM8991_OUTPUT_MIXER2);
                 if (reg & WM8991_RDRO) {
                         printk(KERN_WARNING
                                "Cannot set as Output Mixer 2 RDRO Set\n");
@@ -406,7 +407,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w,
                 break;
 
         case WM8991_OUTPUT_MIXER1 | (WM8991_LDLO_BIT << 8):
-                reg = snd_soc_read(w->codec, WM8991_SPEAKER_MIXER);
+                reg = snd_soc_read(codec, WM8991_SPEAKER_MIXER);
                 if (reg & WM8991_LDSPK) {
                         printk(KERN_WARNING
                                "Cannot set as Speaker Mixer LDSPK Set\n");
@@ -415,7 +416,7 @@ static int outmixer_event(struct snd_soc_dapm_widget *w,
                 break;
 
         case WM8991_OUTPUT_MIXER2 | (WM8991_RDRO_BIT << 8):
-                reg = snd_soc_read(w->codec, WM8991_SPEAKER_MIXER);
+                reg = snd_soc_read(codec, WM8991_SPEAKER_MIXER);
                 if (reg & WM8991_RDSPK) {
                         printk(KERN_WARNING
                                "Cannot set as Speaker Mixer RDSPK Set\n");
diff --git a/sound/soc/codecs/wm8993.c b/sound/soc/codecs/wm8993.c
index 53c6fe359496..2e70a270eb28 100644
--- a/sound/soc/codecs/wm8993.c
+++ b/sound/soc/codecs/wm8993.c
@@ -810,7 +810,7 @@ SOC_SINGLE_TLV("EQ5 Volume", WM8993_EQ6, 0, 24, 0, eq_tlv),
 static int clk_sys_event(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
diff --git a/sound/soc/codecs/wm8994.c b/sound/soc/codecs/wm8994.c
index 1b97de2e4e67..4fbc7689339a 100644
--- a/sound/soc/codecs/wm8994.c
+++ b/sound/soc/codecs/wm8994.c
@@ -249,7 +249,8 @@ static int configure_clock(struct snd_soc_codec *codec)
 static int check_clk_sys(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
-        int reg = snd_soc_read(source->codec, WM8994_CLOCKING_1);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
+        int reg = snd_soc_read(codec, WM8994_CLOCKING_1);
         const char *clk;
 
         /* Check what we're currently using for CLK_SYS */
@@ -806,7 +807,7 @@ static void active_dereference(struct snd_soc_codec *codec)
 static int clk_sys_event(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -981,7 +982,7 @@ static void vmid_dereference(struct snd_soc_codec *codec)
 static int vmid_event(struct snd_soc_dapm_widget *w,
                       struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
@@ -1037,7 +1038,7 @@ static bool wm8994_check_class_w_digital(struct snd_soc_codec *codec)
 static int aif1clk_ev(struct snd_soc_dapm_widget *w,
                       struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
         struct wm8994 *control = wm8994->wm8994;
         int mask = WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA;
@@ -1135,7 +1136,7 @@ static int aif1clk_ev(struct snd_soc_dapm_widget *w,
 static int aif2clk_ev(struct snd_soc_dapm_widget *w,
                       struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         int i;
         int dac;
         int adc;
@@ -1220,7 +1221,7 @@ static int aif2clk_ev(struct snd_soc_dapm_widget *w,
 static int aif1clk_late_ev(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -1238,7 +1239,7 @@ static int aif1clk_late_ev(struct snd_soc_dapm_widget *w,
 static int aif2clk_late_ev(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -1256,7 +1257,7 @@ static int aif2clk_late_ev(struct snd_soc_dapm_widget *w,
 static int late_enable_ev(struct snd_soc_dapm_widget *w,
                           struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -1289,7 +1290,7 @@ static int late_enable_ev(struct snd_soc_dapm_widget *w,
 static int late_disable_ev(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -1331,7 +1332,7 @@ static int micbias_ev(struct snd_soc_dapm_widget *w,
 static int dac_ev(struct snd_soc_dapm_widget *w,
                   struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         unsigned int mask = 1 << w->shift;
 
         snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_5,
@@ -1372,7 +1373,7 @@ SOC_DAPM_SINGLE("DAC1 Switch", WM8994_SPEAKER_MIXER, 0, 1, 0),
 static int post_ev(struct snd_soc_dapm_widget *w,
             struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         dev_dbg(codec->dev, "SRC status: %x\n",
                 snd_soc_read(codec,
                              WM8994_RATE_STATUS));
diff --git a/sound/soc/codecs/wm8995.c b/sound/soc/codecs/wm8995.c
index c280f0a3a424..66103c2b012e 100644
--- a/sound/soc/codecs/wm8995.c
+++ b/sound/soc/codecs/wm8995.c
@@ -44,7 +44,7 @@ static const char *wm8995_supply_names[WM8995_NUM_SUPPLIES] = {
         "MICVDD"
 };
 
-static struct reg_default wm8995_reg_defaults[] = {
+static const struct reg_default wm8995_reg_defaults[] = {
         { 0, 0x8995 },
         { 5, 0x0100 },
         { 16, 0x000b },
@@ -534,10 +534,11 @@ static void wm8995_update_class_w(struct snd_soc_codec *codec)
 static int check_clk_sys(struct snd_soc_dapm_widget *source,
                          struct snd_soc_dapm_widget *sink)
 {
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(source->dapm);
         unsigned int reg;
         const char *clk;
 
-        reg = snd_soc_read(source->codec, WM8995_CLOCKING_1);
+        reg = snd_soc_read(codec, WM8995_CLOCKING_1);
         /* Check what we're currently using for CLK_SYS */
         if (reg & WM8995_SYSCLK_SRC)
                 clk = "AIF2CLK";
@@ -560,9 +561,7 @@ static int wm8995_put_class_w(struct snd_kcontrol *kcontrol,
 static int hp_supply_event(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec;
-
-        codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
@@ -611,10 +610,9 @@ static void dc_servo_cmd(struct snd_soc_codec *codec,
 static int hp_event(struct snd_soc_dapm_widget *w,
                     struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         unsigned int reg;
 
-        codec = w->codec;
         reg = snd_soc_read(codec, WM8995_ANALOGUE_HP_1);
 
         switch (event) {
@@ -761,9 +759,7 @@ static int configure_clock(struct snd_soc_codec *codec)
 static int clk_sys_event(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec;
-
-        codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
@@ -2190,7 +2186,7 @@ static struct snd_soc_dai_driver wm8995_dai[] = {
         }
 };
 
-static struct snd_soc_codec_driver soc_codec_dev_wm8995 = {
+static const struct snd_soc_codec_driver soc_codec_dev_wm8995 = {
         .probe = wm8995_probe,
         .remove = wm8995_remove,
         .set_bias_level = wm8995_set_bias_level,
@@ -2204,7 +2200,7 @@ static struct snd_soc_codec_driver soc_codec_dev_wm8995 = {
         .num_dapm_routes = ARRAY_SIZE(wm8995_intercon),
 };
 
-static struct regmap_config wm8995_regmap = {
+static const struct regmap_config wm8995_regmap = {
         .reg_bits = 16,
         .val_bits = 16,
 
diff --git a/sound/soc/codecs/wm8996.c b/sound/soc/codecs/wm8996.c
index b1dcc11c1b23..dc92d5e4e942 100644
--- a/sound/soc/codecs/wm8996.c
+++ b/sound/soc/codecs/wm8996.c
@@ -599,7 +599,7 @@ static void wm8996_bg_disable(struct snd_soc_codec *codec)
 static int bg_event(struct snd_soc_dapm_widget *w,
                     struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         int ret = 0;
 
         switch (event) {
@@ -634,7 +634,8 @@ static int cp_event(struct snd_soc_dapm_widget *w,
 static int rmv_short_event(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct wm8996_priv *wm8996 = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct wm8996_priv *wm8996 = snd_soc_codec_get_drvdata(codec);
 
         /* Record which outputs we enabled */
         switch (event) {
@@ -758,7 +759,8 @@ static void wm8996_seq_notifier(struct snd_soc_dapm_context *dapm,
 static int dcs_start(struct snd_soc_dapm_widget *w,
                      struct snd_kcontrol *kcontrol, int event)
 {
-        struct wm8996_priv *wm8996 = snd_soc_codec_get_drvdata(w->codec);
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
+        struct wm8996_priv *wm8996 = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
         case SND_SOC_DAPM_POST_PMU:
diff --git a/sound/soc/codecs/wm8997.c b/sound/soc/codecs/wm8997.c
index 7e8bfe27566b..a4d11770630c 100644
--- a/sound/soc/codecs/wm8997.c
+++ b/sound/soc/codecs/wm8997.c
@@ -84,7 +84,7 @@ static const struct reg_default wm8997_sysclk_reva_patch[] = {
 static int wm8997_sysclk_ev(struct snd_soc_dapm_widget *w,
                             struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct arizona *arizona = dev_get_drvdata(codec->dev->parent);
         struct regmap *regmap = arizona->regmap;
         const struct reg_default *patch = NULL;
@@ -610,13 +610,16 @@ SND_SOC_DAPM_MUX("AEC Loopback", ARIZONA_DAC_AEC_CONTROL_1,
 
 SND_SOC_DAPM_PGA_E("OUT1L", SND_SOC_NOPM,
                    ARIZONA_OUT1L_ENA_SHIFT, 0, NULL, 0, arizona_hp_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT1R", SND_SOC_NOPM,
                    ARIZONA_OUT1R_ENA_SHIFT, 0, NULL, 0, arizona_hp_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT3L", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT3L_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
-                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
+                   SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD |
+                   SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU),
 SND_SOC_DAPM_PGA_E("OUT5L", ARIZONA_OUTPUT_ENABLES_1,
                    ARIZONA_OUT5L_ENA_SHIFT, 0, NULL, 0, arizona_out_ev,
                    SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
diff --git a/sound/soc/codecs/wm9081.c b/sound/soc/codecs/wm9081.c
index b1d946facd57..13a3f335ea5b 100644
--- a/sound/soc/codecs/wm9081.c
+++ b/sound/soc/codecs/wm9081.c
@@ -734,7 +734,7 @@ static int configure_clock(struct snd_soc_codec *codec)
 static int clk_sys_event(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm9081_priv *wm9081 = snd_soc_codec_get_drvdata(codec);
 
         /* This should be done on init() for bypass paths */
diff --git a/sound/soc/codecs/wm9090.c b/sound/soc/codecs/wm9090.c
index 6ffe8dc4f3fa..60d243c904f5 100644
--- a/sound/soc/codecs/wm9090.c
+++ b/sound/soc/codecs/wm9090.c
@@ -254,7 +254,7 @@ SOC_SINGLE_TLV("MIXOUTR IN2B Volume", WM9090_OUTPUT_MIXER4, 0, 3, 1,
 static int hp_ev(struct snd_soc_dapm_widget *w,
                  struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         unsigned int reg = snd_soc_read(codec, WM9090_ANALOGUE_HP_0);
 
         switch (event) {
diff --git a/sound/soc/codecs/wm9713.c b/sound/soc/codecs/wm9713.c
index 6ab1122a3872..68222917b396 100644
--- a/sound/soc/codecs/wm9713.c
+++ b/sound/soc/codecs/wm9713.c
@@ -217,7 +217,7 @@ SOC_SINGLE("3D Depth", AC97_REC_GAIN_MIC, 0, 15, 1),
 static int wm9713_voice_shutdown(struct snd_soc_dapm_widget *w,
                                  struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         u16 status, rate;
 
         if (WARN_ON(event != SND_SOC_DAPM_PRE_PMD))
diff --git a/sound/soc/codecs/wm_adsp.c b/sound/soc/codecs/wm_adsp.c
index 720d6e852986..ff67b334065b 100644
--- a/sound/soc/codecs/wm_adsp.c
+++ b/sound/soc/codecs/wm_adsp.c
@@ -1373,7 +1373,7 @@ int wm_adsp1_event(struct snd_soc_dapm_widget *w,
                    struct snd_kcontrol *kcontrol,
                    int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm_adsp *dsps = snd_soc_codec_get_drvdata(codec);
         struct wm_adsp *dsp = &dsps[w->shift];
         struct wm_adsp_alg_region *alg_region;
@@ -1605,7 +1605,7 @@ err:
 int wm_adsp2_early_event(struct snd_soc_dapm_widget *w,
                    struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm_adsp *dsps = snd_soc_codec_get_drvdata(codec);
         struct wm_adsp *dsp = &dsps[w->shift];
 
@@ -1626,7 +1626,7 @@ EXPORT_SYMBOL_GPL(wm_adsp2_early_event);
 int wm_adsp2_event(struct snd_soc_dapm_widget *w,
                    struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm_adsp *dsps = snd_soc_codec_get_drvdata(codec);
         struct wm_adsp *dsp = &dsps[w->shift];
         struct wm_adsp_alg_region *alg_region;
diff --git a/sound/soc/codecs/wm_hubs.c b/sound/soc/codecs/wm_hubs.c
index 374537d5e179..8366e19657a7 100644
--- a/sound/soc/codecs/wm_hubs.c
+++ b/sound/soc/codecs/wm_hubs.c
@@ -500,7 +500,7 @@ SOC_SINGLE_TLV("LINEOUT2 Volume", WM8993_LINE_OUTPUTS_VOLUME, 0, 1, 1,
 static int hp_supply_event(struct snd_soc_dapm_widget *w,
                            struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm_hubs_data *hubs = snd_soc_codec_get_drvdata(codec);
 
         switch (event) {
@@ -542,7 +542,7 @@ static int hp_supply_event(struct snd_soc_dapm_widget *w,
 static int hp_event(struct snd_soc_dapm_widget *w,
                     struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         unsigned int reg = snd_soc_read(codec, WM8993_ANALOGUE_HP_0);
 
         switch (event) {
@@ -594,7 +594,7 @@ static int hp_event(struct snd_soc_dapm_widget *w,
 static int earpiece_event(struct snd_soc_dapm_widget *w,
                           struct snd_kcontrol *control, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         u16 reg = snd_soc_read(codec, WM8993_ANTIPOP1) & ~WM8993_HPOUT2_IN_ENA;
 
         switch (event) {
@@ -619,7 +619,7 @@ static int earpiece_event(struct snd_soc_dapm_widget *w,
 static int lineout_event(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *control, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm_hubs_data *hubs = snd_soc_codec_get_drvdata(codec);
         bool *flag;
 
@@ -649,7 +649,7 @@ static int lineout_event(struct snd_soc_dapm_widget *w,
 static int micbias_event(struct snd_soc_dapm_widget *w,
                          struct snd_kcontrol *kcontrol, int event)
 {
-        struct snd_soc_codec *codec = w->codec;
+        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
         struct wm_hubs_data *hubs = snd_soc_codec_get_drvdata(codec);
 
         switch (w->shift) {
diff --git a/sound/soc/davinci/Kconfig b/sound/soc/davinci/Kconfig
index 8e948c63f3d9..2b81ca418d2a 100644
--- a/sound/soc/davinci/Kconfig
+++ b/sound/soc/davinci/Kconfig
@@ -58,13 +58,12 @@ choice
         depends on MACH_DAVINCI_DM365_EVM
 
 config SND_DM365_AIC3X_CODEC
-        bool "Audio Codec - AIC3101"
+        tristate "Audio Codec - AIC3101"
         help
           Say Y if you want to add support for AIC3101 audio codec
 
 config SND_DM365_VOICE_CODEC
         tristate "Voice Codec - CQ93VC"
-        depends on SND_DAVINCI_SOC
         select MFD_DAVINCI_VOICECODEC
         select SND_DAVINCI_SOC_VCIF
         select SND_SOC_CQ0093VC
diff --git a/sound/soc/davinci/davinci-evm.c b/sound/soc/davinci/davinci-evm.c
index 158cb3d1db70..b6bb5947a8a8 100644
--- a/sound/soc/davinci/davinci-evm.c
+++ b/sound/soc/davinci/davinci-evm.c
@@ -14,7 +14,6 @@
 #include <linux/timer.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
-#include <linux/platform_data/edma.h>
 #include <linux/i2c.h>
 #include <linux/of_platform.h>
 #include <linux/clk.h>
@@ -25,11 +24,6 @@
 #include <asm/dma.h>
 #include <asm/mach-types.h>
 
-#include <linux/edma.h>
-
-#include "davinci-pcm.h"
-#include "davinci-i2s.h"
-
 struct snd_soc_card_drvdata_davinci {
         struct clk *mclk;
         unsigned sysclk;
diff --git a/sound/soc/davinci/davinci-mcasp.c b/sound/soc/davinci/davinci-mcasp.c
index 30b94d4f9c5d..de3b155a5011 100644
--- a/sound/soc/davinci/davinci-mcasp.c
+++ b/sound/soc/davinci/davinci-mcasp.c
@@ -364,6 +364,20 @@ static irqreturn_t davinci_mcasp_rx_irq_handler(int irq, void *data)
         return IRQ_RETVAL(handled_mask);
 }
 
+static irqreturn_t davinci_mcasp_common_irq_handler(int irq, void *data)
+{
+        struct davinci_mcasp *mcasp = (struct davinci_mcasp *)data;
+        irqreturn_t ret = IRQ_NONE;
+
+        if (mcasp->substreams[SNDRV_PCM_STREAM_PLAYBACK])
+                ret = davinci_mcasp_tx_irq_handler(irq, data);
+
+        if (mcasp->substreams[SNDRV_PCM_STREAM_CAPTURE])
+                ret |= davinci_mcasp_rx_irq_handler(irq, data);
+
+        return ret;
+}
+
 static int davinci_mcasp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
                                          unsigned int fmt)
 {
@@ -1313,16 +1327,19 @@ static struct davinci_mcasp_pdata *davinci_mcasp_set_pdata_from_of(
 
         pdata->tx_dma_channel = dma_spec.args[0];
 
-        ret = of_property_match_string(np, "dma-names", "rx");
-        if (ret < 0)
-                goto nodata;
+        /* RX is not valid in DIT mode */
+        if (pdata->op_mode != DAVINCI_MCASP_DIT_MODE) {
+                ret = of_property_match_string(np, "dma-names", "rx");
+                if (ret < 0)
+                        goto nodata;
 
-        ret = of_parse_phandle_with_args(np, "dmas", "#dma-cells", ret,
-                                         &dma_spec);
-        if (ret < 0)
-                goto nodata;
+                ret = of_parse_phandle_with_args(np, "dmas", "#dma-cells", ret,
+                                                 &dma_spec);
+                if (ret < 0)
+                        goto nodata;
 
-        pdata->rx_dma_channel = dma_spec.args[0];
+                pdata->rx_dma_channel = dma_spec.args[0];
+        }
 
         ret = of_property_read_u32(np, "tx-num-evt", &val);
         if (ret >= 0)
@@ -1441,6 +1458,23 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
 
         mcasp->dev = &pdev->dev;
 
+        irq = platform_get_irq_byname(pdev, "common");
+        if (irq >= 0) {
+                irq_name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "%s_common\n",
+                                          dev_name(&pdev->dev));
+                ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
+                                                davinci_mcasp_common_irq_handler,
+                                                IRQF_ONESHOT | IRQF_SHARED,
+                                                irq_name, mcasp);
+                if (ret) {
+                        dev_err(&pdev->dev, "common IRQ request failed\n");
+                        goto err;
+                }
+
+                mcasp->irq_request[SNDRV_PCM_STREAM_PLAYBACK] = XUNDRN;
+                mcasp->irq_request[SNDRV_PCM_STREAM_CAPTURE] = ROVRN;
+        }
+
         irq = platform_get_irq_byname(pdev, "rx");
         if (irq >= 0) {
                 irq_name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "%s_rx\n",
@@ -1501,19 +1535,34 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
         else
                 dma_data->filter_data = &dma_params->channel;
 
-        dma_params = &mcasp->dma_params[SNDRV_PCM_STREAM_CAPTURE];
-        dma_data = &mcasp->dma_data[SNDRV_PCM_STREAM_CAPTURE];
-        dma_params->asp_chan_q = pdata->asp_chan_q;
-        dma_params->ram_chan_q = pdata->ram_chan_q;
-        dma_params->sram_pool = pdata->sram_pool;
-        dma_params->sram_size = pdata->sram_size_capture;
-        if (dat)
-                dma_params->dma_addr = dat->start;
-        else
-                dma_params->dma_addr = mem->start + pdata->rx_dma_offset;
-
-        /* Unconditional dmaengine stuff */
-        dma_data->addr = dma_params->dma_addr;
+        /* RX is not valid in DIT mode */
+        if (mcasp->op_mode != DAVINCI_MCASP_DIT_MODE) {
+                dma_params = &mcasp->dma_params[SNDRV_PCM_STREAM_CAPTURE];
+                dma_data = &mcasp->dma_data[SNDRV_PCM_STREAM_CAPTURE];
+                dma_params->asp_chan_q = pdata->asp_chan_q;
+                dma_params->ram_chan_q = pdata->ram_chan_q;
+                dma_params->sram_pool = pdata->sram_pool;
+                dma_params->sram_size = pdata->sram_size_capture;
+                if (dat)
+                        dma_params->dma_addr = dat->start;
+                else
+                        dma_params->dma_addr = mem->start + pdata->rx_dma_offset;
+
+                /* Unconditional dmaengine stuff */
+                dma_data->addr = dma_params->dma_addr;
+
+                res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
+                if (res)
+                        dma_params->channel = res->start;
+                else
+                        dma_params->channel = pdata->rx_dma_channel;
+
+                /* dmaengine filter data for DT and non-DT boot */
+                if (pdev->dev.of_node)
+                        dma_data->filter_data = "rx";
+                else
+                        dma_data->filter_data = &dma_params->channel;
+        }
 
         if (mcasp->version < MCASP_VERSION_3) {
                 mcasp->fifo_base = DAVINCI_MCASP_V2_AFIFO_BASE;
@@ -1523,18 +1572,6 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
                 mcasp->fifo_base = DAVINCI_MCASP_V3_AFIFO_BASE;
         }
 
-        res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
-        if (res)
-                dma_params->channel = res->start;
-        else
-                dma_params->channel = pdata->rx_dma_channel;
-
-        /* dmaengine filter data for DT and non-DT boot */
-        if (pdev->dev.of_node)
-                dma_data->filter_data = "rx";
-        else
-                dma_data->filter_data = &dma_params->channel;
-
         dev_set_drvdata(&pdev->dev, mcasp);
 
         mcasp_reparent_fck(pdev);
diff --git a/sound/soc/dwc/Kconfig b/sound/soc/dwc/Kconfig
index e334900cf0b8..d50e08517dce 100644
--- a/sound/soc/dwc/Kconfig
+++ b/sound/soc/dwc/Kconfig
@@ -1,6 +1,7 @@
 config SND_DESIGNWARE_I2S
         tristate "Synopsys I2S Device Driver"
         depends on CLKDEV_LOOKUP
+        select SND_SOC_GENERIC_DMAENGINE_PCM
         help
          Say Y or M if you want to add support for I2S driver for
          Synopsys desigwnware I2S device. The device supports upto
diff --git a/sound/soc/dwc/designware_i2s.c b/sound/soc/dwc/designware_i2s.c
index 8d18bbda661b..a3e97b46b64e 100644
--- a/sound/soc/dwc/designware_i2s.c
+++ b/sound/soc/dwc/designware_i2s.c
@@ -22,6 +22,7 @@
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
+#include <sound/dmaengine_pcm.h>
 
 /* common register for all channel */
 #define IER             0x000
@@ -54,9 +55,39 @@
 #define I2S_COMP_VERSION        0x01F8
 #define I2S_COMP_TYPE           0x01FC
 
+/*
+ * Component parameter register fields - define the I2S block's
+ * configuration.
+ */
+#define COMP1_TX_WORDSIZE_3(r)  (((r) & GENMASK(27, 25)) >> 25)
+#define COMP1_TX_WORDSIZE_2(r)  (((r) & GENMASK(24, 22)) >> 22)
+#define COMP1_TX_WORDSIZE_1(r)  (((r) & GENMASK(21, 19)) >> 19)
+#define COMP1_TX_WORDSIZE_0(r)  (((r) & GENMASK(18, 16)) >> 16)
+#define COMP1_TX_CHANNELS(r)    (((r) & GENMASK(10, 9)) >> 9)
+#define COMP1_RX_CHANNELS(r)    (((r) & GENMASK(8, 7)) >> 7)
+#define COMP1_RX_ENABLED(r)     (((r) & BIT(6)) >> 6)
+#define COMP1_TX_ENABLED(r)     (((r) & BIT(5)) >> 5)
+#define COMP1_MODE_EN(r)        (((r) & BIT(4)) >> 4)
+#define COMP1_FIFO_DEPTH_GLOBAL(r)      (((r) & GENMASK(3, 2)) >> 2)
+#define COMP1_APB_DATA_WIDTH(r) (((r) & GENMASK(1, 0)) >> 0)
+
+#define COMP2_RX_WORDSIZE_3(r)  (((r) & GENMASK(12, 10)) >> 10)
+#define COMP2_RX_WORDSIZE_2(r)  (((r) & GENMASK(9, 7)) >> 7)
+#define COMP2_RX_WORDSIZE_1(r)  (((r) & GENMASK(5, 3)) >> 3)
+#define COMP2_RX_WORDSIZE_0(r)  (((r) & GENMASK(2, 0)) >> 0)
+
+/* Number of entries in WORDSIZE and DATA_WIDTH parameter registers */
+#define COMP_MAX_WORDSIZE       (1 << 3)
+#define COMP_MAX_DATA_WIDTH     (1 << 2)
+
 #define MAX_CHANNEL_NUM         8
 #define MIN_CHANNEL_NUM         2
 
+union dw_i2s_snd_dma_data {
+        struct i2s_dma_data pd;
+        struct snd_dmaengine_dai_dma_data dt;
+};
+
 struct dw_i2s_dev {
         void __iomem *i2s_base;
         struct clk *clk;
@@ -65,8 +96,8 @@ struct dw_i2s_dev {
         struct device *dev;
 
         /* data related to DMA transfers b/w i2s and DMAC */
-        struct i2s_dma_data play_dma_data;
-        struct i2s_dma_data capture_dma_data;
+        union dw_i2s_snd_dma_data play_dma_data;
+        union dw_i2s_snd_dma_data capture_dma_data;
         struct i2s_clk_config_data config;
         int (*i2s_clk_cfg)(struct i2s_clk_config_data *config);
 };
@@ -153,7 +184,7 @@ static int dw_i2s_startup(struct snd_pcm_substream *substream,
                 struct snd_soc_dai *cpu_dai)
 {
         struct dw_i2s_dev *dev = snd_soc_dai_get_drvdata(cpu_dai);
-        struct i2s_dma_data *dma_data = NULL;
+        union dw_i2s_snd_dma_data *dma_data = NULL;
 
         if (!(dev->capability & DWC_I2S_RECORD) &&
                         (substream->stream == SNDRV_PCM_STREAM_CAPTURE))
@@ -242,13 +273,21 @@ static int dw_i2s_hw_params(struct snd_pcm_substream *substream,
 
         config->sample_rate = params_rate(params);
 
-        if (!dev->i2s_clk_cfg)
-                return -EINVAL;
+        if (dev->i2s_clk_cfg) {
+                ret = dev->i2s_clk_cfg(config);
+                if (ret < 0) {
+                        dev_err(dev->dev, "runtime audio clk config fail\n");
+                        return ret;
+                }
+        } else {
+                u32 bitclk = config->sample_rate * config->data_width * 2;
 
-        ret = dev->i2s_clk_cfg(config);
-        if (ret < 0) {
-                dev_err(dev->dev, "runtime audio clk config fail\n");
-                return ret;
+                ret = clk_set_rate(dev->clk, bitclk);
+                if (ret) {
+                        dev_err(dev->dev, "Can't set I2S clock rate: %d\n",
+                                ret);
+                        return ret;
+                }
         }
 
         return 0;
@@ -335,20 +374,162 @@ static int dw_i2s_resume(struct snd_soc_dai *dai)
 #define dw_i2s_resume   NULL
 #endif
 
+/*
+ * The following tables allow a direct lookup of various parameters
+ * defined in the I2S block's configuration in terms of sound system
+ * parameters.  Each table is sized to the number of entries possible
+ * according to the number of configuration bits describing an I2S
+ * block parameter.
+ */
+
+/* Maximum bit resolution of a channel - not uniformly spaced */
+static const u32 fifo_width[COMP_MAX_WORDSIZE] = {
+        12, 16, 20, 24, 32, 0, 0, 0
+};
+
+/* Width of (DMA) bus */
+static const u32 bus_widths[COMP_MAX_DATA_WIDTH] = {
+        DMA_SLAVE_BUSWIDTH_1_BYTE,
+        DMA_SLAVE_BUSWIDTH_2_BYTES,
+        DMA_SLAVE_BUSWIDTH_4_BYTES,
+        DMA_SLAVE_BUSWIDTH_UNDEFINED
+};
+
+/* PCM format to support channel resolution */
+static const u32 formats[COMP_MAX_WORDSIZE] = {
+        SNDRV_PCM_FMTBIT_S16_LE,
+        SNDRV_PCM_FMTBIT_S16_LE,
+        SNDRV_PCM_FMTBIT_S24_LE,
+        SNDRV_PCM_FMTBIT_S24_LE,
+        SNDRV_PCM_FMTBIT_S32_LE,
+        0,
+        0,
+        0
+};
+
+static int dw_configure_dai(struct dw_i2s_dev *dev,
+                                   struct snd_soc_dai_driver *dw_i2s_dai,
+                                   unsigned int rates)
+{
+        /*
+         * Read component parameter registers to extract
+         * the I2S block's configuration.
+         */
+        u32 comp1 = i2s_read_reg(dev->i2s_base, I2S_COMP_PARAM_1);
+        u32 comp2 = i2s_read_reg(dev->i2s_base, I2S_COMP_PARAM_2);
+        u32 idx;
+
+        if (COMP1_TX_ENABLED(comp1)) {
+                dev_dbg(dev->dev, " designware: play supported\n");
+                idx = COMP1_TX_WORDSIZE_0(comp1);
+                if (WARN_ON(idx >= ARRAY_SIZE(formats)))
+                        return -EINVAL;
+                dw_i2s_dai->playback.channels_min = MIN_CHANNEL_NUM;
+                dw_i2s_dai->playback.channels_max =
+                                1 << (COMP1_TX_CHANNELS(comp1) + 1);
+                dw_i2s_dai->playback.formats = formats[idx];
+                dw_i2s_dai->playback.rates = rates;
+        }
+
+        if (COMP1_RX_ENABLED(comp1)) {
+                dev_dbg(dev->dev, "designware: record supported\n");
+                idx = COMP2_RX_WORDSIZE_0(comp2);
+                if (WARN_ON(idx >= ARRAY_SIZE(formats)))
+                        return -EINVAL;
+                dw_i2s_dai->capture.channels_min = MIN_CHANNEL_NUM;
+                dw_i2s_dai->capture.channels_max =
+                                1 << (COMP1_RX_CHANNELS(comp1) + 1);
+                dw_i2s_dai->capture.formats = formats[idx];
+                dw_i2s_dai->capture.rates = rates;
+        }
+
+        return 0;
+}
+
+static int dw_configure_dai_by_pd(struct dw_i2s_dev *dev,
+                                   struct snd_soc_dai_driver *dw_i2s_dai,
+                                   struct resource *res,
+                                   const struct i2s_platform_data *pdata)
+{
+        u32 comp1 = i2s_read_reg(dev->i2s_base, I2S_COMP_PARAM_1);
+        u32 idx = COMP1_APB_DATA_WIDTH(comp1);
+        int ret;
+
+        if (WARN_ON(idx >= ARRAY_SIZE(bus_widths)))
+                return -EINVAL;
+
+        ret = dw_configure_dai(dev, dw_i2s_dai, pdata->snd_rates);
+        if (ret < 0)
+                return ret;
+
+        /* Set DMA slaves info */
+        dev->play_dma_data.pd.data = pdata->play_dma_data;
+        dev->capture_dma_data.pd.data = pdata->capture_dma_data;
+        dev->play_dma_data.pd.addr = res->start + I2S_TXDMA;
+        dev->capture_dma_data.pd.addr = res->start + I2S_RXDMA;
+        dev->play_dma_data.pd.max_burst = 16;
+        dev->capture_dma_data.pd.max_burst = 16;
+        dev->play_dma_data.pd.addr_width = bus_widths[idx];
+        dev->capture_dma_data.pd.addr_width = bus_widths[idx];
+        dev->play_dma_data.pd.filter = pdata->filter;
+        dev->capture_dma_data.pd.filter = pdata->filter;
+
+        return 0;
+}
+
+static int dw_configure_dai_by_dt(struct dw_i2s_dev *dev,
+                                   struct snd_soc_dai_driver *dw_i2s_dai,
+                                   struct resource *res)
+{
+        u32 comp1 = i2s_read_reg(dev->i2s_base, I2S_COMP_PARAM_1);
+        u32 comp2 = i2s_read_reg(dev->i2s_base, I2S_COMP_PARAM_2);
+        u32 fifo_depth = 1 << (1 + COMP1_FIFO_DEPTH_GLOBAL(comp1));
+        u32 idx = COMP1_APB_DATA_WIDTH(comp1);
+        u32 idx2;
+        int ret;
+
+        if (WARN_ON(idx >= ARRAY_SIZE(bus_widths)))
+                return -EINVAL;
+
+        ret = dw_configure_dai(dev, dw_i2s_dai, SNDRV_PCM_RATE_8000_192000);
+        if (ret < 0)
+                return ret;
+
+        if (COMP1_TX_ENABLED(comp1)) {
+                idx2 = COMP1_TX_WORDSIZE_0(comp1);
+
+                dev->capability |= DWC_I2S_PLAY;
+                dev->play_dma_data.dt.addr = res->start + I2S_TXDMA;
+                dev->play_dma_data.dt.addr_width = bus_widths[idx];
+                dev->play_dma_data.dt.chan_name = "TX";
+                dev->play_dma_data.dt.fifo_size = fifo_depth *
+                        (fifo_width[idx2]) >> 8;
+                dev->play_dma_data.dt.maxburst = 16;
+        }
+        if (COMP1_RX_ENABLED(comp1)) {
+                idx2 = COMP2_RX_WORDSIZE_0(comp2);
+
+                dev->capability |= DWC_I2S_RECORD;
+                dev->capture_dma_data.dt.addr = res->start + I2S_RXDMA;
+                dev->capture_dma_data.dt.addr_width = bus_widths[idx];
+                dev->capture_dma_data.dt.chan_name = "RX";
+                dev->capture_dma_data.dt.fifo_size = fifo_depth *
+                        (fifo_width[idx2] >> 8);
+                dev->capture_dma_data.dt.maxburst = 16;
+        }
+
+        return 0;
+
+}
+
 static int dw_i2s_probe(struct platform_device *pdev)
 {
         const struct i2s_platform_data *pdata = pdev->dev.platform_data;
         struct dw_i2s_dev *dev;
         struct resource *res;
         int ret;
-        unsigned int cap;
         struct snd_soc_dai_driver *dw_i2s_dai;
 
-        if (!pdata) {
-                dev_err(&pdev->dev, "Invalid platform data\n");
-                return -EINVAL;
-        }
-
         dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
         if (!dev) {
                 dev_warn(&pdev->dev, "kzalloc fail\n");
@@ -356,83 +537,67 @@ static int dw_i2s_probe(struct platform_device *pdev)
         }
 
         dw_i2s_dai = devm_kzalloc(&pdev->dev, sizeof(*dw_i2s_dai), GFP_KERNEL);
-        if (!dw_i2s_dai) {
-                dev_err(&pdev->dev, "mem allocation failed for dai driver\n");
+        if (!dw_i2s_dai)
                 return -ENOMEM;
-        }
 
         dw_i2s_dai->ops = &dw_i2s_dai_ops;
         dw_i2s_dai->suspend = dw_i2s_suspend;
         dw_i2s_dai->resume = dw_i2s_resume;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(&pdev->dev, "no i2s resource defined\n");
-                return -ENODEV;
-        }
-
         dev->i2s_base = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(dev->i2s_base)) {
-                dev_err(&pdev->dev, "ioremap fail for i2s_region\n");
+        if (IS_ERR(dev->i2s_base))
                 return PTR_ERR(dev->i2s_base);
-        }
 
-        cap = pdata->cap;
-        dev->capability = cap;
-        dev->i2s_clk_cfg = pdata->i2s_clk_cfg;
+        dev->dev = &pdev->dev;
+        if (pdata) {
+                ret = dw_configure_dai_by_pd(dev, dw_i2s_dai, res, pdata);
+                if (ret < 0)
+                        return ret;
+
+                dev->capability = pdata->cap;
+                dev->i2s_clk_cfg = pdata->i2s_clk_cfg;
+                if (!dev->i2s_clk_cfg) {
+                        dev_err(&pdev->dev, "no clock configure method\n");
+                        return -ENODEV;
+                }
 
-        /* Set DMA slaves info */
+                dev->clk = devm_clk_get(&pdev->dev, NULL);
+        } else {
+                ret = dw_configure_dai_by_dt(dev, dw_i2s_dai, res);
+                if (ret < 0)
+                        return ret;
 
-        dev->play_dma_data.data = pdata->play_dma_data;
-        dev->capture_dma_data.data = pdata->capture_dma_data;
-        dev->play_dma_data.addr = res->start + I2S_TXDMA;
-        dev->capture_dma_data.addr = res->start + I2S_RXDMA;
-        dev->play_dma_data.max_burst = 16;
-        dev->capture_dma_data.max_burst = 16;
-        dev->play_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
-        dev->capture_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
-        dev->play_dma_data.filter = pdata->filter;
-        dev->capture_dma_data.filter = pdata->filter;
-
-        dev->clk = clk_get(&pdev->dev, NULL);
+                dev->clk = devm_clk_get(&pdev->dev, "i2sclk");
+        }
         if (IS_ERR(dev->clk))
-                return  PTR_ERR(dev->clk);
+                return PTR_ERR(dev->clk);
 
-        ret = clk_enable(dev->clk);
+        ret = clk_prepare_enable(dev->clk);
         if (ret < 0)
-                goto err_clk_put;
-
-        if (cap & DWC_I2S_PLAY) {
-                dev_dbg(&pdev->dev, " designware: play supported\n");
-                dw_i2s_dai->playback.channels_min = MIN_CHANNEL_NUM;
-                dw_i2s_dai->playback.channels_max = pdata->channel;
-                dw_i2s_dai->playback.formats = pdata->snd_fmts;
-                dw_i2s_dai->playback.rates = pdata->snd_rates;
-        }
-
-        if (cap & DWC_I2S_RECORD) {
-                dev_dbg(&pdev->dev, "designware: record supported\n");
-                dw_i2s_dai->capture.channels_min = MIN_CHANNEL_NUM;
-                dw_i2s_dai->capture.channels_max = pdata->channel;
-                dw_i2s_dai->capture.formats = pdata->snd_fmts;
-                dw_i2s_dai->capture.rates = pdata->snd_rates;
-        }
+                return ret;
 
-        dev->dev = &pdev->dev;
         dev_set_drvdata(&pdev->dev, dev);
-        ret = snd_soc_register_component(&pdev->dev, &dw_i2s_component,
+        ret = devm_snd_soc_register_component(&pdev->dev, &dw_i2s_component,
                                          dw_i2s_dai, 1);
         if (ret != 0) {
                 dev_err(&pdev->dev, "not able to register dai\n");
                 goto err_clk_disable;
         }
 
+        if (!pdata) {
+                ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 0);
+                if (ret) {
+                        dev_err(&pdev->dev,
+                                "Could not register PCM: %d\n", ret);
+                        goto err_clk_disable;
+                }
+        }
+
         return 0;
 
 err_clk_disable:
-        clk_disable(dev->clk);
-err_clk_put:
-        clk_put(dev->clk);
+        clk_disable_unprepare(dev->clk);
         return ret;
 }
 
@@ -440,18 +605,26 @@ static int dw_i2s_remove(struct platform_device *pdev)
 {
         struct dw_i2s_dev *dev = dev_get_drvdata(&pdev->dev);
 
-        snd_soc_unregister_component(&pdev->dev);
-
-        clk_put(dev->clk);
+        clk_disable_unprepare(dev->clk);
 
         return 0;
 }
 
+#ifdef CONFIG_OF
+static const struct of_device_id dw_i2s_of_match[] = {
+        { .compatible = "snps,designware-i2s",   },
+        {},
+};
+
+MODULE_DEVICE_TABLE(of, dw_i2s_of_match);
+#endif
+
 static struct platform_driver dw_i2s_driver = {
         .probe          = dw_i2s_probe,
         .remove         = dw_i2s_remove,
         .driver         = {
                 .name   = "designware-i2s",
+                .of_match_table = of_match_ptr(dw_i2s_of_match),
         },
 };
 
diff --git a/sound/soc/fsl/eukrea-tlv320.c b/sound/soc/fsl/eukrea-tlv320.c
index 9ce70fc67b09..e1aa3834b101 100644
--- a/sound/soc/fsl/eukrea-tlv320.c
+++ b/sound/soc/fsl/eukrea-tlv320.c
@@ -42,25 +42,6 @@ static int eukrea_tlv320_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
         int ret;
 
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
-                                  SND_SOC_DAIFMT_NB_NF |
-                                  SND_SOC_DAIFMT_CBM_CFM);
-        /* fsl_ssi lacks the set_fmt ops. */
-        if (ret && ret != -ENOTSUPP) {
-                dev_err(cpu_dai->dev,
-                        "Failed to set the cpu dai format.\n");
-                return ret;
-        }
-
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
-                                  SND_SOC_DAIFMT_NB_NF |
-                                  SND_SOC_DAIFMT_CBM_CFM);
-        if (ret) {
-                dev_err(cpu_dai->dev,
-                        "Failed to set the codec format.\n");
-                return ret;
-        }
-
         ret = snd_soc_dai_set_sysclk(codec_dai, 0,
                                      CODEC_CLOCK, SND_SOC_CLOCK_OUT);
         if (ret) {
@@ -69,7 +50,7 @@ static int eukrea_tlv320_hw_params(struct snd_pcm_substream *substream,
                 return ret;
         }
 
-        snd_soc_dai_set_tdm_slot(cpu_dai, 0xffffffc, 0xffffffc, 2, 0);
+        snd_soc_dai_set_tdm_slot(cpu_dai, 0x3, 0x3, 2, 0);
 
         ret = snd_soc_dai_set_sysclk(cpu_dai, IMX_SSP_SYS_CLK, 0,
                                 SND_SOC_CLOCK_IN);
@@ -91,6 +72,8 @@ static struct snd_soc_dai_link eukrea_tlv320_dai = {
         .name           = "tlv320aic23",
         .stream_name    = "TLV320AIC23",
         .codec_dai_name = "tlv320aic23-hifi",
+        .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                          SND_SOC_DAIFMT_CBM_CFM,
         .ops            = &eukrea_tlv320_snd_ops,
 };
 
diff --git a/sound/soc/fsl/fsl_asrc.c b/sound/soc/fsl/fsl_asrc.c
index 026a80117540..c068494bae30 100644
--- a/sound/soc/fsl/fsl_asrc.c
+++ b/sound/soc/fsl/fsl_asrc.c
@@ -818,7 +818,6 @@ static int fsl_asrc_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         asrc_priv->pdev = pdev;
-        strncpy(asrc_priv->name, np->name, sizeof(asrc_priv->name) - 1);
 
         /* Get the addresses and IRQ */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -837,12 +836,12 @@ static int fsl_asrc_probe(struct platform_device *pdev)
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
-                dev_err(&pdev->dev, "no irq for node %s\n", np->full_name);
+                dev_err(&pdev->dev, "no irq for node %s\n", pdev->name);
                 return irq;
         }
 
         ret = devm_request_irq(&pdev->dev, irq, fsl_asrc_isr, 0,
-                               asrc_priv->name, asrc_priv);
+                               dev_name(&pdev->dev), asrc_priv);
         if (ret) {
                 dev_err(&pdev->dev, "failed to claim irq %u: %d\n", irq, ret);
                 return ret;
diff --git a/sound/soc/fsl/fsl_asrc.h b/sound/soc/fsl/fsl_asrc.h
index a3f211f53c23..4aed63c4b431 100644
--- a/sound/soc/fsl/fsl_asrc.h
+++ b/sound/soc/fsl/fsl_asrc.h
@@ -433,7 +433,6 @@ struct fsl_asrc_pair {
  * @channel_avail: non-occupied channel numbers
  * @asrc_rate: default sample rate for ASoC Back-Ends
  * @asrc_width: default sample width for ASoC Back-Ends
- * @name: driver name
  */
 struct fsl_asrc {
         struct snd_dmaengine_dai_dma_data dma_params_rx;
@@ -452,8 +451,6 @@ struct fsl_asrc {
 
         int asrc_rate;
         int asrc_width;
-
-        char name[32];
 };
 
 extern struct snd_soc_platform_driver fsl_asrc_platform;
diff --git a/sound/soc/fsl/fsl_esai.c b/sound/soc/fsl/fsl_esai.c
index 1c08ab13637c..5c7597191e3f 100644
--- a/sound/soc/fsl/fsl_esai.c
+++ b/sound/soc/fsl/fsl_esai.c
@@ -774,7 +774,7 @@ static int fsl_esai_probe(struct platform_device *pdev)
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
-                dev_err(&pdev->dev, "no irq for node %s\n", np->full_name);
+                dev_err(&pdev->dev, "no irq for node %s\n", pdev->name);
                 return irq;
         }
 
diff --git a/sound/soc/fsl/fsl_sai.c b/sound/soc/fsl/fsl_sai.c
index 032d2d33619c..ec79c3d5e65e 100644
--- a/sound/soc/fsl/fsl_sai.c
+++ b/sound/soc/fsl/fsl_sai.c
@@ -612,7 +612,7 @@ static int fsl_sai_probe(struct platform_device *pdev)
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
-                dev_err(&pdev->dev, "no irq for node %s\n", np->full_name);
+                dev_err(&pdev->dev, "no irq for node %s\n", pdev->name);
                 return irq;
         }
 
diff --git a/sound/soc/fsl/fsl_spdif.c b/sound/soc/fsl/fsl_spdif.c
index af0429421fc8..75870c0ea2c9 100644
--- a/sound/soc/fsl/fsl_spdif.c
+++ b/sound/soc/fsl/fsl_spdif.c
@@ -90,7 +90,6 @@ struct spdif_mixer_control {
  * @sysclk: system clock for rx clock rate measurement
  * @dma_params_tx: DMA parameters for transmit channel
  * @dma_params_rx: DMA parameters for receive channel
- * @name: driver name
  */
 struct fsl_spdif_priv {
         struct spdif_mixer_control fsl_spdif_control;
@@ -109,12 +108,8 @@ struct fsl_spdif_priv {
         struct clk *sysclk;
         struct snd_dmaengine_dai_dma_data dma_params_tx;
         struct snd_dmaengine_dai_dma_data dma_params_rx;
-
-        /* The name space will be allocated dynamically */
-        char name[0];
 };
 
-
 /* DPLL locked and lock loss interrupt handler */
 static void spdif_irq_dpll_lock(struct fsl_spdif_priv *spdif_priv)
 {
@@ -1169,19 +1164,15 @@ static int fsl_spdif_probe(struct platform_device *pdev)
         if (!np)
                 return -ENODEV;
 
-        spdif_priv = devm_kzalloc(&pdev->dev,
-                        sizeof(struct fsl_spdif_priv) + strlen(np->name) + 1,
-                        GFP_KERNEL);
+        spdif_priv = devm_kzalloc(&pdev->dev, sizeof(*spdif_priv), GFP_KERNEL);
         if (!spdif_priv)
                 return -ENOMEM;
 
-        strcpy(spdif_priv->name, np->name);
-
         spdif_priv->pdev = pdev;
 
         /* Initialize this copy of the CPU DAI driver structure */
         memcpy(&spdif_priv->cpu_dai_drv, &fsl_spdif_dai, sizeof(fsl_spdif_dai));
-        spdif_priv->cpu_dai_drv.name = spdif_priv->name;
+        spdif_priv->cpu_dai_drv.name = dev_name(&pdev->dev);
 
         /* Get the addresses and IRQ */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -1198,12 +1189,12 @@ static int fsl_spdif_probe(struct platform_device *pdev)
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
-                dev_err(&pdev->dev, "no irq for node %s\n", np->full_name);
+                dev_err(&pdev->dev, "no irq for node %s\n", pdev->name);
                 return irq;
         }
 
         ret = devm_request_irq(&pdev->dev, irq, spdif_isr, 0,
-                        spdif_priv->name, spdif_priv);
+                               dev_name(&pdev->dev), spdif_priv);
         if (ret) {
                 dev_err(&pdev->dev, "could not claim irq %u\n", irq);
                 return ret;
diff --git a/sound/soc/fsl/fsl_ssi.c b/sound/soc/fsl/fsl_ssi.c
index 059496ed9ad7..b9fabbf69db6 100644
--- a/sound/soc/fsl/fsl_ssi.c
+++ b/sound/soc/fsl/fsl_ssi.c
@@ -160,7 +160,7 @@ struct fsl_ssi_soc_data {
  */
 struct fsl_ssi_private {
         struct regmap *regs;
-        unsigned int irq;
+        int irq;
         struct snd_soc_dai_driver cpu_dai_drv;
 
         unsigned int dai_fmt;
@@ -603,10 +603,6 @@ static int fsl_ssi_set_bclk(struct snd_pcm_substream *substream,
         factor = (div2 + 1) * (7 * psr + 1) * 2;
 
         for (i = 0; i < 255; i++) {
-                /* The bclk rate must be smaller than 1/5 sysclk rate */
-                if (factor * (i + 1) < 5)
-                        continue;
-
                 tmprate = freq * factor * (i + 2);
 
                 if (baudclk_is_used)
@@ -614,6 +610,13 @@ static int fsl_ssi_set_bclk(struct snd_pcm_substream *substream,
                 else
                         clkrate = clk_round_rate(ssi_private->baudclk, tmprate);
 
+                /*
+                 * Hardware limitation: The bclk rate must be
+                 * never greater than 1/5 IPG clock rate
+                 */
+                if (clkrate * 5 > clk_get_rate(ssi_private->clk))
+                        continue;
+
                 clkrate /= factor;
                 afreq = clkrate / (i + 1);
 
@@ -992,8 +995,8 @@ static int fsl_ssi_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai, u32 tx_mask,
         regmap_update_bits(regs, CCSR_SSI_SCR, CCSR_SSI_SCR_SSIEN,
                         CCSR_SSI_SCR_SSIEN);
 
-        regmap_write(regs, CCSR_SSI_STMSK, tx_mask);
-        regmap_write(regs, CCSR_SSI_SRMSK, rx_mask);
+        regmap_write(regs, CCSR_SSI_STMSK, ~tx_mask);
+        regmap_write(regs, CCSR_SSI_SRMSK, ~rx_mask);
 
         regmap_update_bits(regs, CCSR_SSI_SCR, CCSR_SSI_SCR_SSIEN, val);
 
@@ -1362,8 +1365,8 @@ static int fsl_ssi_probe(struct platform_device *pdev)
         }
 
         ssi_private->irq = platform_get_irq(pdev, 0);
-        if (ssi_private->irq < 0) {
-                dev_err(&pdev->dev, "no irq for node %s\n", np->full_name);
+        if (!ssi_private->irq) {
+                dev_err(&pdev->dev, "no irq for node %s\n", pdev->name);
                 return ssi_private->irq;
         }
 
diff --git a/sound/soc/fsl/fsl_utils.c b/sound/soc/fsl/fsl_utils.c
index 2ac7755da876..b9e42b503a37 100644
--- a/sound/soc/fsl/fsl_utils.c
+++ b/sound/soc/fsl/fsl_utils.c
@@ -86,33 +86,6 @@ int fsl_asoc_get_dma_channel(struct device_node *ssi_np,
 }
 EXPORT_SYMBOL(fsl_asoc_get_dma_channel);
 
-/**
- * fsl_asoc_xlate_tdm_slot_mask - generate TDM slot TX/RX mask.
- *
- * @slots: Number of slots in use.
- * @tx_mask: bitmask representing active TX slots.
- * @rx_mask: bitmask representing active RX slots.
- *
- * This function used to generate the TDM slot TX/RX mask. And the TX/RX
- * mask will use a 0 bit for an active slot as default, and the default
- * active bits are at the LSB of the mask value.
- */
-int fsl_asoc_xlate_tdm_slot_mask(unsigned int slots,
-                                    unsigned int *tx_mask,
-                                    unsigned int *rx_mask)
-{
-        if (!slots)
-                return -EINVAL;
-
-        if (tx_mask)
-                *tx_mask = ~((1 << slots) - 1);
-        if (rx_mask)
-                *rx_mask = ~((1 << slots) - 1);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(fsl_asoc_xlate_tdm_slot_mask);
-
 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
 MODULE_DESCRIPTION("Freescale ASoC utility code");
 MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/fsl/fsl_utils.h b/sound/soc/fsl/fsl_utils.h
index df535db40313..1687b66ef18e 100644
--- a/sound/soc/fsl/fsl_utils.h
+++ b/sound/soc/fsl/fsl_utils.h
@@ -22,7 +22,4 @@ int fsl_asoc_get_dma_channel(struct device_node *ssi_np, const char *name,
                              struct snd_soc_dai_link *dai,
                              unsigned int *dma_channel_id,
                              unsigned int *dma_id);
-int fsl_asoc_xlate_tdm_slot_mask(unsigned int slots,
-                                    unsigned int *tx_mask,
-                                    unsigned int *rx_mask);
 #endif /* _FSL_UTILS_H */
diff --git a/sound/soc/fsl/imx-mc13783.c b/sound/soc/fsl/imx-mc13783.c
index 6bf5bce01a92..9e6493d4e7ff 100644
--- a/sound/soc/fsl/imx-mc13783.c
+++ b/sound/soc/fsl/imx-mc13783.c
@@ -37,8 +37,7 @@ static int imx_mc13783_hifi_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_dai *codec_dai = rtd->codec_dai;
         int ret;
 
-        ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xfffffffc, 0xfffffffc,
-                                        4, 16);
+        ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x3, 0x3, 4, 16);
         if (ret)
                 return ret;
 
@@ -46,7 +45,7 @@ static int imx_mc13783_hifi_hw_params(struct snd_pcm_substream *substream,
         if (ret)
                 return ret;
 
-        ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0x0, 0xfffffffc, 2, 16);
+        ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0x3, 0x3, 2, 16);
         if (ret)
                 return ret;
 
diff --git a/sound/soc/fsl/imx-spdif.c b/sound/soc/fsl/imx-spdif.c
index e94704f1b9ee..33da26a12457 100644
--- a/sound/soc/fsl/imx-spdif.c
+++ b/sound/soc/fsl/imx-spdif.c
@@ -60,6 +60,7 @@ static int imx_spdif_audio_probe(struct platform_device *pdev)
         data->card.dev = &pdev->dev;
         data->card.dai_link = &data->dai;
         data->card.num_links = 1;
+        data->card.owner = THIS_MODULE;
 
         ret = snd_soc_of_parse_card_name(&data->card, "model");
         if (ret)
diff --git a/sound/soc/fsl/imx-ssi.c b/sound/soc/fsl/imx-ssi.c
index fa801e17c51e..461ce27b884f 100644
--- a/sound/soc/fsl/imx-ssi.c
+++ b/sound/soc/fsl/imx-ssi.c
@@ -74,8 +74,8 @@ static int imx_ssi_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai,
         sccr |= SSI_STCCR_DC(slots - 1);
         writel(sccr, ssi->base + SSI_SRCCR);
 
-        writel(tx_mask, ssi->base + SSI_STMSK);
-        writel(rx_mask, ssi->base + SSI_SRMSK);
+        writel(~tx_mask, ssi->base + SSI_STMSK);
+        writel(~rx_mask, ssi->base + SSI_SRMSK);
 
         return 0;
 }
@@ -340,7 +340,6 @@ static const struct snd_soc_dai_ops imx_ssi_pcm_dai_ops = {
         .set_fmt        = imx_ssi_set_dai_fmt,
         .set_clkdiv     = imx_ssi_set_dai_clkdiv,
         .set_sysclk     = imx_ssi_set_dai_sysclk,
-        .xlate_tdm_slot_mask = fsl_asoc_xlate_tdm_slot_mask,
         .set_tdm_slot   = imx_ssi_set_dai_tdm_slot,
         .trigger        = imx_ssi_trigger,
 };
diff --git a/sound/soc/fsl/mx27vis-aic32x4.c b/sound/soc/fsl/mx27vis-aic32x4.c
index b1ced7b8d80c..198eeb3f3f7a 100644
--- a/sound/soc/fsl/mx27vis-aic32x4.c
+++ b/sound/soc/fsl/mx27vis-aic32x4.c
@@ -55,16 +55,6 @@ static int mx27vis_aic32x4_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_dai *codec_dai = rtd->codec_dai;
         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
         int ret;
-        u32 dai_format;
-
-        dai_format = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_NB_NF |
-                SND_SOC_DAIFMT_CBM_CFM;
-
-        /* set codec DAI configuration */
-        snd_soc_dai_set_fmt(codec_dai, dai_format);
-
-        /* set cpu DAI configuration */
-        snd_soc_dai_set_fmt(cpu_dai, dai_format);
 
         ret = snd_soc_dai_set_sysclk(codec_dai, 0,
                                      25000000, SND_SOC_CLOCK_OUT);
@@ -164,6 +154,8 @@ static struct snd_soc_dai_link mx27vis_aic32x4_dai = {
         .platform_name  = "imx-ssi.0",
         .codec_name     = "tlv320aic32x4.0-0018",
         .cpu_dai_name   = "imx-ssi.0",
+        .dai_fmt        = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_NB_NF |
+                          SND_SOC_DAIFMT_CBM_CFM,
         .ops            = &mx27vis_aic32x4_snd_ops,
 };
 
diff --git a/sound/soc/fsl/wm1133-ev1.c b/sound/soc/fsl/wm1133-ev1.c
index 804749a6c61e..a958937ab405 100644
--- a/sound/soc/fsl/wm1133-ev1.c
+++ b/sound/soc/fsl/wm1133-ev1.c
@@ -87,7 +87,6 @@ static int wm1133_ev1_hw_params(struct snd_pcm_substream *substream,
         snd_pcm_format_t format = params_format(params);
         unsigned int rate = params_rate(params);
         unsigned int channels = params_channels(params);
-        u32 dai_format;
 
         /* find the correct audio parameters */
         for (i = 0; i < ARRAY_SIZE(wm8350_audio); i++) {
@@ -104,22 +103,13 @@ static int wm1133_ev1_hw_params(struct snd_pcm_substream *substream,
         /* codec FLL input is 14.75 MHz from MCLK */
         snd_soc_dai_set_pll(codec_dai, 0, 0, 14750000, wm8350_audio[i].sysclk);
 
-        dai_format = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
-                SND_SOC_DAIFMT_CBM_CFM;
-
-        /* set codec DAI configuration */
-        snd_soc_dai_set_fmt(codec_dai, dai_format);
-
-        /* set cpu DAI configuration */
-        snd_soc_dai_set_fmt(cpu_dai, dai_format);
-
         /* TODO: The SSI driver should figure this out for us */
         switch (channels) {
         case 2:
-                snd_soc_dai_set_tdm_slot(cpu_dai, 0xffffffc, 0xffffffc, 2, 0);
+                snd_soc_dai_set_tdm_slot(cpu_dai, 0x3, 0x3, 2, 0);
                 break;
         case 1:
-                snd_soc_dai_set_tdm_slot(cpu_dai, 0xffffffe, 0xffffffe, 1, 0);
+                snd_soc_dai_set_tdm_slot(cpu_dai, 0x1, 0x1, 1, 0);
                 break;
         default:
                 return -EINVAL;
@@ -244,6 +234,8 @@ static struct snd_soc_dai_link wm1133_ev1_dai = {
         .init = wm1133_ev1_init,
         .ops = &wm1133_ev1_ops,
         .symmetric_rates = 1,
+        .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                   SND_SOC_DAIFMT_CBM_CFM,
 };
 
 static struct snd_soc_card wm1133_ev1 = {
diff --git a/sound/soc/generic/simple-card.c b/sound/soc/generic/simple-card.c
index 7fe3009b1c43..f7c6734bd5da 100644
--- a/sound/soc/generic/simple-card.c
+++ b/sound/soc/generic/simple-card.c
@@ -39,6 +39,37 @@ struct simple_card_data {
 #define simple_priv_to_link(priv, i) ((priv)->snd_card.dai_link + i)
 #define simple_priv_to_props(priv, i) ((priv)->dai_props + i)
 
+static int asoc_simple_card_startup(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
+        struct simple_dai_props *dai_props =
+                &priv->dai_props[rtd - rtd->card->rtd];
+        int ret;
+
+        ret = clk_prepare_enable(dai_props->cpu_dai.clk);
+        if (ret)
+                return ret;
+        
+        ret = clk_prepare_enable(dai_props->codec_dai.clk);
+        if (ret)
+                clk_disable_unprepare(dai_props->cpu_dai.clk);
+
+        return ret;
+}
+
+static void asoc_simple_card_shutdown(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
+        struct simple_dai_props *dai_props =
+                &priv->dai_props[rtd - rtd->card->rtd];
+
+        clk_disable_unprepare(dai_props->cpu_dai.clk);
+
+        clk_disable_unprepare(dai_props->codec_dai.clk);
+}
+
 static int asoc_simple_card_hw_params(struct snd_pcm_substream *substream,
                                       struct snd_pcm_hw_params *params)
 {
@@ -58,6 +89,8 @@ static int asoc_simple_card_hw_params(struct snd_pcm_substream *substream,
 }
 
 static struct snd_soc_ops asoc_simple_card_ops = {
+        .startup = asoc_simple_card_startup,
+        .shutdown = asoc_simple_card_shutdown,
         .hw_params = asoc_simple_card_hw_params,
 };
 
@@ -219,6 +252,7 @@ asoc_simple_card_sub_parse_of(struct device_node *np,
                 }
 
                 dai->sysclk = clk_get_rate(clk);
+                dai->clk = clk;
         } else if (!of_property_read_u32(np, "system-clock-frequency", &val)) {
                 dai->sysclk = val;
         } else {
diff --git a/sound/soc/intel/Kconfig b/sound/soc/intel/Kconfig
index f86de1211b96..ee03dbdda235 100644
--- a/sound/soc/intel/Kconfig
+++ b/sound/soc/intel/Kconfig
@@ -46,7 +46,7 @@ config SND_SOC_INTEL_BAYTRAIL
 
 config SND_SOC_INTEL_HASWELL_MACH
         tristate "ASoC Audio DSP support for Intel Haswell Lynxpoint"
-        depends on SND_SOC_INTEL_SST && X86_INTEL_LPSS && I2C && \\
+        depends on SND_SOC_INTEL_SST && X86_INTEL_LPSS && I2C && \
                    I2C_DESIGNWARE_PLATFORM
         select SND_SOC_INTEL_HASWELL
         select SND_SOC_RT5640
@@ -76,7 +76,7 @@ config SND_SOC_INTEL_BYT_MAX98090_MACH
 
 config SND_SOC_INTEL_BROADWELL_MACH
         tristate "ASoC Audio DSP support for Intel Broadwell Wildcatpoint"
-        depends on SND_SOC_INTEL_SST && X86_INTEL_LPSS && DW_DMAC && \\
+        depends on SND_SOC_INTEL_SST && X86_INTEL_LPSS && DW_DMAC && \
                    I2C_DESIGNWARE_PLATFORM
         select SND_SOC_INTEL_HASWELL
         select SND_COMPRESS_OFFLOAD
@@ -110,3 +110,14 @@ config SND_SOC_INTEL_CHT_BSW_RT5672_MACH
           platforms with RT5672 audio codec.
           Say Y if you have such a device
           If unsure select "N".
+
+config SND_SOC_INTEL_CHT_BSW_RT5645_MACH
+        tristate "ASoC Audio driver for Intel Cherrytrail & Braswell with RT5645 codec"
+        depends on X86_INTEL_LPSS
+        select SND_SOC_RT5645
+        select SND_SST_MFLD_PLATFORM
+        select SND_SST_IPC_ACPI
+        help
+          This adds support for ASoC machine driver for Intel(R) Cherrytrail & Braswell
+          platforms with RT5645 audio codec.
+          If unsure select "N".
diff --git a/sound/soc/intel/Makefile b/sound/soc/intel/Makefile
index e928ec385300..a8e53c45c6b6 100644
--- a/sound/soc/intel/Makefile
+++ b/sound/soc/intel/Makefile
@@ -28,6 +28,7 @@ snd-soc-sst-byt-max98090-mach-objs := byt-max98090.o
 snd-soc-sst-broadwell-objs := broadwell.o
 snd-soc-sst-bytcr-dpcm-rt5640-objs := bytcr_dpcm_rt5640.o
 snd-soc-sst-cht-bsw-rt5672-objs := cht_bsw_rt5672.o
+snd-soc-sst-cht-bsw-rt5645-objs := cht_bsw_rt5645.o
 
 obj-$(CONFIG_SND_SOC_INTEL_HASWELL_MACH) += snd-soc-sst-haswell.o
 obj-$(CONFIG_SND_SOC_INTEL_BYT_RT5640_MACH) += snd-soc-sst-byt-rt5640-mach.o
@@ -35,6 +36,7 @@ obj-$(CONFIG_SND_SOC_INTEL_BYT_MAX98090_MACH) += snd-soc-sst-byt-max98090-mach.o
 obj-$(CONFIG_SND_SOC_INTEL_BROADWELL_MACH) += snd-soc-sst-broadwell.o
 obj-$(CONFIG_SND_SOC_INTEL_BYTCR_RT5640_MACH) += snd-soc-sst-bytcr-dpcm-rt5640.o
 obj-$(CONFIG_SND_SOC_INTEL_CHT_BSW_RT5672_MACH) += snd-soc-sst-cht-bsw-rt5672.o
+obj-$(CONFIG_SND_SOC_INTEL_CHT_BSW_RT5645_MACH) += snd-soc-sst-cht-bsw-rt5645.o
 
 # DSP driver
 obj-$(CONFIG_SND_SST_IPC) += sst/
diff --git a/sound/soc/intel/broadwell.c b/sound/soc/intel/broadwell.c
index 7cf95d5d5d80..9cf7d01479ad 100644
--- a/sound/soc/intel/broadwell.c
+++ b/sound/soc/intel/broadwell.c
@@ -140,8 +140,6 @@ static struct snd_soc_ops broadwell_rt286_ops = {
 
 static int broadwell_rtd_init(struct snd_soc_pcm_runtime *rtd)
 {
-        struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
         struct sst_pdata *pdata = dev_get_platdata(rtd->platform->dev);
         struct sst_hsw *broadwell = pdata->dsp;
         int ret;
@@ -155,14 +153,6 @@ static int broadwell_rtd_init(struct snd_soc_pcm_runtime *rtd)
                 return ret;
         }
 
-        /* always connected - check HP for jack detect */
-        snd_soc_dapm_enable_pin(dapm, "Headphone Jack");
-        snd_soc_dapm_enable_pin(dapm, "Speaker");
-        snd_soc_dapm_enable_pin(dapm, "Mic Jack");
-        snd_soc_dapm_enable_pin(dapm, "Line Jack");
-        snd_soc_dapm_enable_pin(dapm, "DMIC1");
-        snd_soc_dapm_enable_pin(dapm, "DMIC2");
-
         return 0;
 }
 
diff --git a/sound/soc/intel/byt-rt5640.c b/sound/soc/intel/byt-rt5640.c
index 0cba7830c5e9..354eaad886e1 100644
--- a/sound/soc/intel/byt-rt5640.c
+++ b/sound/soc/intel/byt-rt5640.c
@@ -132,7 +132,6 @@ static int byt_rt5640_init(struct snd_soc_pcm_runtime *runtime)
 {
         int ret;
         struct snd_soc_codec *codec = runtime->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
         struct snd_soc_card *card = runtime->card;
         const struct snd_soc_dapm_route *custom_map;
         int num_routes;
@@ -161,7 +160,7 @@ static int byt_rt5640_init(struct snd_soc_pcm_runtime *runtime)
                 num_routes = ARRAY_SIZE(byt_rt5640_intmic_dmic1_map);
         }
 
-        ret = snd_soc_dapm_add_routes(dapm, custom_map, num_routes);
+        ret = snd_soc_dapm_add_routes(&card->dapm, custom_map, num_routes);
         if (ret)
                 return ret;
 
@@ -171,13 +170,8 @@ static int byt_rt5640_init(struct snd_soc_pcm_runtime *runtime)
                         return ret;
         }
 
-        snd_soc_dapm_ignore_suspend(dapm, "HPOL");
-        snd_soc_dapm_ignore_suspend(dapm, "HPOR");
-
-        snd_soc_dapm_ignore_suspend(dapm, "SPOLP");
-        snd_soc_dapm_ignore_suspend(dapm, "SPOLN");
-        snd_soc_dapm_ignore_suspend(dapm, "SPORP");
-        snd_soc_dapm_ignore_suspend(dapm, "SPORN");
+        snd_soc_dapm_ignore_suspend(&card->dapm, "Headphone");
+        snd_soc_dapm_ignore_suspend(&card->dapm, "Speaker");
 
         return ret;
 }
diff --git a/sound/soc/intel/bytcr_dpcm_rt5640.c b/sound/soc/intel/bytcr_dpcm_rt5640.c
index eef0c56ec32e..59308629043e 100644
--- a/sound/soc/intel/bytcr_dpcm_rt5640.c
+++ b/sound/soc/intel/bytcr_dpcm_rt5640.c
@@ -215,7 +215,6 @@ static int snd_byt_mc_probe(struct platform_device *pdev)
 
 static struct platform_driver snd_byt_mc_driver = {
         .driver = {
-                .owner = THIS_MODULE,
                 .name = "bytt100_rt5640",
                 .pm = &snd_soc_pm_ops,
         },
diff --git a/sound/soc/intel/cht_bsw_rt5645.c b/sound/soc/intel/cht_bsw_rt5645.c
new file mode 100644
index 000000000000..bd29617a9ab9
--- /dev/null
+++ b/sound/soc/intel/cht_bsw_rt5645.c
@@ -0,0 +1,326 @@
+/*
+ *  cht-bsw-rt5645.c - ASoc Machine driver for Intel Cherryview-based platforms
+ *                     Cherrytrail and Braswell, with RT5645 codec.
+ *
+ *  Copyright (C) 2015 Intel Corp
+ *  Author: Fang, Yang A <yang.a.fang@intel.com>
+ *              N,Harshapriya <harshapriya.n@intel.com>
+ *  This file is modified from cht_bsw_rt5672.c
+ *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  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; version 2 of the License.
+ *
+ *  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.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/jack.h>
+#include "../codecs/rt5645.h"
+#include "sst-atom-controls.h"
+
+#define CHT_PLAT_CLK_3_HZ       19200000
+#define CHT_CODEC_DAI   "rt5645-aif1"
+
+struct cht_mc_private {
+        struct snd_soc_jack hp_jack;
+        struct snd_soc_jack mic_jack;
+};
+
+static inline struct snd_soc_dai *cht_get_codec_dai(struct snd_soc_card *card)
+{
+        int i;
+
+        for (i = 0; i < card->num_rtd; i++) {
+                struct snd_soc_pcm_runtime *rtd;
+
+                rtd = card->rtd + i;
+                if (!strncmp(rtd->codec_dai->name, CHT_CODEC_DAI,
+                             strlen(CHT_CODEC_DAI)))
+                        return rtd->codec_dai;
+        }
+        return NULL;
+}
+
+static int platform_clock_control(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *k, int  event)
+{
+        struct snd_soc_dapm_context *dapm = w->dapm;
+        struct snd_soc_card *card = dapm->card;
+        struct snd_soc_dai *codec_dai;
+        int ret;
+
+        codec_dai = cht_get_codec_dai(card);
+        if (!codec_dai) {
+                dev_err(card->dev, "Codec dai not found; Unable to set platform clock\n");
+                return -EIO;
+        }
+
+        if (!SND_SOC_DAPM_EVENT_OFF(event))
+                return 0;
+
+        /* Set codec sysclk source to its internal clock because codec PLL will
+         * be off when idle and MCLK will also be off by ACPI when codec is
+         * runtime suspended. Codec needs clock for jack detection and button
+         * press.
+         */
+        ret = snd_soc_dai_set_sysclk(codec_dai, RT5645_SCLK_S_RCCLK,
+                        0, SND_SOC_CLOCK_IN);
+        if (ret < 0) {
+                dev_err(card->dev, "can't set codec sysclk: %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static const struct snd_soc_dapm_widget cht_dapm_widgets[] = {
+        SND_SOC_DAPM_HP("Headphone", NULL),
+        SND_SOC_DAPM_MIC("Headset Mic", NULL),
+        SND_SOC_DAPM_MIC("Int Mic", NULL),
+        SND_SOC_DAPM_SPK("Ext Spk", NULL),
+        SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
+                        platform_clock_control, SND_SOC_DAPM_POST_PMD),
+};
+
+static const struct snd_soc_dapm_route cht_audio_map[] = {
+        {"IN1P", NULL, "Headset Mic"},
+        {"IN1N", NULL, "Headset Mic"},
+        {"DMIC L1", NULL, "Int Mic"},
+        {"DMIC R1", NULL, "Int Mic"},
+        {"Headphone", NULL, "HPOL"},
+        {"Headphone", NULL, "HPOR"},
+        {"Ext Spk", NULL, "SPOL"},
+        {"Ext Spk", NULL, "SPOR"},
+        {"AIF1 Playback", NULL, "ssp2 Tx"},
+        {"ssp2 Tx", NULL, "codec_out0"},
+        {"ssp2 Tx", NULL, "codec_out1"},
+        {"codec_in0", NULL, "ssp2 Rx" },
+        {"codec_in1", NULL, "ssp2 Rx" },
+        {"ssp2 Rx", NULL, "AIF1 Capture"},
+        {"Headphone", NULL, "Platform Clock"},
+        {"Headset Mic", NULL, "Platform Clock"},
+        {"Int Mic", NULL, "Platform Clock"},
+        {"Ext Spk", NULL, "Platform Clock"},
+};
+
+static const struct snd_kcontrol_new cht_mc_controls[] = {
+        SOC_DAPM_PIN_SWITCH("Headphone"),
+        SOC_DAPM_PIN_SWITCH("Headset Mic"),
+        SOC_DAPM_PIN_SWITCH("Int Mic"),
+        SOC_DAPM_PIN_SWITCH("Ext Spk"),
+};
+
+static int cht_aif1_hw_params(struct snd_pcm_substream *substream,
+                             struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->codec_dai;
+        int ret;
+
+        /* set codec PLL source to the 19.2MHz platform clock (MCLK) */
+        ret = snd_soc_dai_set_pll(codec_dai, 0, RT5645_PLL1_S_MCLK,
+                                  CHT_PLAT_CLK_3_HZ, params_rate(params) * 512);
+        if (ret < 0) {
+                dev_err(rtd->dev, "can't set codec pll: %d\n", ret);
+                return ret;
+        }
+
+        ret = snd_soc_dai_set_sysclk(codec_dai, RT5645_SCLK_S_PLL1,
+                                params_rate(params) * 512, SND_SOC_CLOCK_IN);
+        if (ret < 0) {
+                dev_err(rtd->dev, "can't set codec sysclk: %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static int cht_codec_init(struct snd_soc_pcm_runtime *runtime)
+{
+        int ret;
+        struct snd_soc_codec *codec = runtime->codec;
+        struct snd_soc_dai *codec_dai = runtime->codec_dai;
+        struct cht_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);
+
+        /* Select clk_i2s1_asrc as ASRC clock source */
+        rt5645_sel_asrc_clk_src(codec,
+                                RT5645_DA_STEREO_FILTER |
+                                RT5645_DA_MONO_L_FILTER |
+                                RT5645_DA_MONO_R_FILTER |
+                                RT5645_AD_STEREO_FILTER,
+                                RT5645_CLK_SEL_I2S1_ASRC);
+
+        /* TDM 4 slots 24 bit, set Rx & Tx bitmask to 4 active slots */
+        ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xF, 0xF, 4, 24);
+        if (ret < 0) {
+                dev_err(runtime->dev, "can't set codec TDM slot %d\n", ret);
+                return ret;
+        }
+
+        ret = snd_soc_jack_new(codec, "Headphone Jack",
+                                SND_JACK_HEADPHONE,
+                                &ctx->hp_jack);
+        if (ret) {
+                dev_err(runtime->dev, "HP jack creation failed %d\n", ret);
+                return ret;
+        }
+
+        ret = snd_soc_jack_new(codec, "Mic Jack",
+                                SND_JACK_MICROPHONE,
+                                &ctx->mic_jack);
+        if (ret) {
+                dev_err(runtime->dev, "Mic jack creation failed %d\n", ret);
+                return ret;
+        }
+
+        rt5645_set_jack_detect(codec, &ctx->hp_jack, &ctx->mic_jack);
+
+        return ret;
+}
+
+static int cht_codec_fixup(struct snd_soc_pcm_runtime *rtd,
+                            struct snd_pcm_hw_params *params)
+{
+        struct snd_interval *rate = hw_param_interval(params,
+                        SNDRV_PCM_HW_PARAM_RATE);
+        struct snd_interval *channels = hw_param_interval(params,
+                                                SNDRV_PCM_HW_PARAM_CHANNELS);
+
+        /* The DSP will covert the FE rate to 48k, stereo, 24bits */
+        rate->min = rate->max = 48000;
+        channels->min = channels->max = 2;
+
+        /* set SSP2 to 24-bit */
+        snd_mask_set(&params->masks[SNDRV_PCM_HW_PARAM_FORMAT -
+                                    SNDRV_PCM_HW_PARAM_FIRST_MASK],
+                                    SNDRV_PCM_FORMAT_S24_LE);
+        return 0;
+}
+
+static unsigned int rates_48000[] = {
+        48000,
+};
+
+static struct snd_pcm_hw_constraint_list constraints_48000 = {
+        .count = ARRAY_SIZE(rates_48000),
+        .list  = rates_48000,
+};
+
+static int cht_aif1_startup(struct snd_pcm_substream *substream)
+{
+        return snd_pcm_hw_constraint_list(substream->runtime, 0,
+                        SNDRV_PCM_HW_PARAM_RATE,
+                        &constraints_48000);
+}
+
+static struct snd_soc_ops cht_aif1_ops = {
+        .startup = cht_aif1_startup,
+};
+
+static struct snd_soc_ops cht_be_ssp2_ops = {
+        .hw_params = cht_aif1_hw_params,
+};
+
+static struct snd_soc_dai_link cht_dailink[] = {
+        [MERR_DPCM_AUDIO] = {
+                .name = "Audio Port",
+                .stream_name = "Audio",
+                .cpu_dai_name = "media-cpu-dai",
+                .codec_dai_name = "snd-soc-dummy-dai",
+                .codec_name = "snd-soc-dummy",
+                .platform_name = "sst-mfld-platform",
+                .ignore_suspend = 1,
+                .dynamic = 1,
+                .dpcm_playback = 1,
+                .dpcm_capture = 1,
+                .ops = &cht_aif1_ops,
+        },
+        [MERR_DPCM_COMPR] = {
+                .name = "Compressed Port",
+                .stream_name = "Compress",
+                .cpu_dai_name = "compress-cpu-dai",
+                .codec_dai_name = "snd-soc-dummy-dai",
+                .codec_name = "snd-soc-dummy",
+                .platform_name = "sst-mfld-platform",
+        },
+        /* CODEC<->CODEC link */
+        /* back ends */
+        {
+                .name = "SSP2-Codec",
+                .be_id = 1,
+                .cpu_dai_name = "ssp2-port",
+                .platform_name = "sst-mfld-platform",
+                .no_pcm = 1,
+                .codec_dai_name = "rt5645-aif1",
+                .codec_name = "i2c-10EC5645:00",
+                .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_IB_NF
+                                        | SND_SOC_DAIFMT_CBS_CFS,
+                .init = cht_codec_init,
+                .be_hw_params_fixup = cht_codec_fixup,
+                .ignore_suspend = 1,
+                .dpcm_playback = 1,
+                .dpcm_capture = 1,
+                .ops = &cht_be_ssp2_ops,
+        },
+};
+
+/* SoC card */
+static struct snd_soc_card snd_soc_card_cht = {
+        .name = "chtrt5645",
+        .dai_link = cht_dailink,
+        .num_links = ARRAY_SIZE(cht_dailink),
+        .dapm_widgets = cht_dapm_widgets,
+        .num_dapm_widgets = ARRAY_SIZE(cht_dapm_widgets),
+        .dapm_routes = cht_audio_map,
+        .num_dapm_routes = ARRAY_SIZE(cht_audio_map),
+        .controls = cht_mc_controls,
+        .num_controls = ARRAY_SIZE(cht_mc_controls),
+};
+
+static int snd_cht_mc_probe(struct platform_device *pdev)
+{
+        int ret_val = 0;
+        struct cht_mc_private *drv;
+
+        drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_ATOMIC);
+        if (!drv)
+                return -ENOMEM;
+
+        snd_soc_card_cht.dev = &pdev->dev;
+        snd_soc_card_set_drvdata(&snd_soc_card_cht, drv);
+        ret_val = devm_snd_soc_register_card(&pdev->dev, &snd_soc_card_cht);
+        if (ret_val) {
+                dev_err(&pdev->dev,
+                        "snd_soc_register_card failed %d\n", ret_val);
+                return ret_val;
+        }
+        platform_set_drvdata(pdev, &snd_soc_card_cht);
+        return ret_val;
+}
+
+static struct platform_driver snd_cht_mc_driver = {
+        .driver = {
+                .name = "cht-bsw-rt5645",
+                .pm = &snd_soc_pm_ops,
+        },
+        .probe = snd_cht_mc_probe,
+};
+
+module_platform_driver(snd_cht_mc_driver)
+
+MODULE_DESCRIPTION("ASoC Intel(R) Braswell Machine driver");
+MODULE_AUTHOR("Fang, Yang A,N,Harshapriya");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:cht-bsw-rt5645");
diff --git a/sound/soc/intel/cht_bsw_rt5672.c b/sound/soc/intel/cht_bsw_rt5672.c
index 9b8b561171b7..ff016621583a 100644
--- a/sound/soc/intel/cht_bsw_rt5672.c
+++ b/sound/soc/intel/cht_bsw_rt5672.c
@@ -140,6 +140,7 @@ static int cht_codec_init(struct snd_soc_pcm_runtime *runtime)
 {
         int ret;
         struct snd_soc_dai *codec_dai = runtime->codec_dai;
+        struct snd_soc_codec *codec = codec_dai->codec;
 
         /* TDM 4 slots 24 bit, set Rx & Tx bitmask to 4 active slots */
         ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xF, 0xF, 4, 24);
@@ -148,6 +149,19 @@ static int cht_codec_init(struct snd_soc_pcm_runtime *runtime)
                 return ret;
         }
 
+        /* Select codec ASRC clock source to track I2S1 clock, because codec
+         * is in slave mode and 100fs I2S format (BCLK = 100 * LRCLK) cannot
+         * be supported by RT5672. Otherwise, ASRC will be disabled and cause
+         * noise.
+         */
+        rt5670_sel_asrc_clk_src(codec,
+                                RT5670_DA_STEREO_FILTER
+                                | RT5670_DA_MONO_L_FILTER
+                                | RT5670_DA_MONO_R_FILTER
+                                | RT5670_AD_STEREO_FILTER
+                                | RT5670_AD_MONO_L_FILTER
+                                | RT5670_AD_MONO_R_FILTER,
+                                RT5670_CLK_SEL_I2S1_ASRC);
         return 0;
 }
 
@@ -270,7 +284,6 @@ static int snd_cht_mc_probe(struct platform_device *pdev)
 
 static struct platform_driver snd_cht_mc_driver = {
         .driver = {
-                .owner = THIS_MODULE,
                 .name = "cht-bsw-rt5672",
                 .pm = &snd_soc_pm_ops,
         },
diff --git a/sound/soc/intel/sst-atom-controls.h b/sound/soc/intel/sst-atom-controls.h
index dfebfdd5eb2a..daecc58f28af 100644
--- a/sound/soc/intel/sst-atom-controls.h
+++ b/sound/soc/intel/sst-atom-controls.h
@@ -150,7 +150,7 @@ enum sst_cmd_type {
 
 enum sst_task {
         SST_TASK_SBA = 1,
-        SST_TASK_MMX,
+        SST_TASK_MMX = 3,
 };
 
 enum sst_type {
diff --git a/sound/soc/intel/sst-baytrail-pcm.c b/sound/soc/intel/sst-baytrail-pcm.c
index 3bb6288d8b4d..224c49c9f135 100644
--- a/sound/soc/intel/sst-baytrail-pcm.c
+++ b/sound/soc/intel/sst-baytrail-pcm.c
@@ -320,11 +320,6 @@ static struct snd_pcm_ops sst_byt_pcm_ops = {
         .mmap           = sst_byt_pcm_mmap,
 };
 
-static void sst_byt_pcm_free(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 static int sst_byt_pcm_new(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_pcm *pcm = rtd->pcm;
@@ -403,7 +398,6 @@ static struct snd_soc_platform_driver byt_soc_platform = {
         .remove         = sst_byt_pcm_remove,
         .ops            = &sst_byt_pcm_ops,
         .pcm_new        = sst_byt_pcm_new,
-        .pcm_free       = sst_byt_pcm_free,
 };
 
 static const struct snd_soc_component_driver byt_dai_component = {
diff --git a/sound/soc/intel/sst-dsp.c b/sound/soc/intel/sst-dsp.c
index 86e410845670..64e94212d2d2 100644
--- a/sound/soc/intel/sst-dsp.c
+++ b/sound/soc/intel/sst-dsp.c
@@ -410,8 +410,7 @@ void sst_dsp_free(struct sst_dsp *sst)
         if (sst->ops->free)
                 sst->ops->free(sst);
 
-        if (sst->dma)
-                sst_dma_free(sst->dma);
+        sst_dma_free(sst->dma);
 }
 EXPORT_SYMBOL_GPL(sst_dsp_free);
 
diff --git a/sound/soc/intel/sst-firmware.c b/sound/soc/intel/sst-firmware.c
index b3f9489794a6..5f71ef607a57 100644
--- a/sound/soc/intel/sst-firmware.c
+++ b/sound/soc/intel/sst-firmware.c
@@ -497,6 +497,7 @@ struct sst_module *sst_module_new(struct sst_fw *sst_fw,
         sst_module->sst_fw = sst_fw;
         sst_module->scratch_size = template->scratch_size;
         sst_module->persistent_size = template->persistent_size;
+        sst_module->entry = template->entry;
 
         INIT_LIST_HEAD(&sst_module->block_list);
         INIT_LIST_HEAD(&sst_module->runtime_list);
@@ -790,6 +791,7 @@ int sst_module_alloc_blocks(struct sst_module *module)
         struct sst_block_allocator ba;
         int ret;
 
+        memset(&ba, 0, sizeof(ba));
         ba.size = module->size;
         ba.type = module->type;
         ba.offset = module->offset;
@@ -863,6 +865,7 @@ int sst_module_runtime_alloc_blocks(struct sst_module_runtime *runtime,
         if (module->persistent_size == 0)
                 return 0;
 
+        memset(&ba, 0, sizeof(ba));
         ba.size = module->persistent_size;
         ba.type = SST_MEM_DRAM;
 
diff --git a/sound/soc/intel/sst-haswell-dsp.c b/sound/soc/intel/sst-haswell-dsp.c
index 57039b00efc2..c42ffae5fe9f 100644
--- a/sound/soc/intel/sst-haswell-dsp.c
+++ b/sound/soc/intel/sst-haswell-dsp.c
@@ -306,7 +306,7 @@ static void hsw_reset(struct sst_dsp *sst)
 static int hsw_set_dsp_D0(struct sst_dsp *sst)
 {
         int tries = 10;
-        u32 reg;
+        u32 reg, fw_dump_bit;
 
         /* Disable core clock gating (VDRTCTL2.DCLCGE = 0) */
         reg = readl(sst->addr.pci_cfg + SST_VDRTCTL2);
@@ -368,7 +368,9 @@ finish:
         can't be accessed, please enable each block before accessing. */
         reg = readl(sst->addr.pci_cfg + SST_VDRTCTL0);
         reg |= SST_VDRTCL0_DSRAMPGE_MASK | SST_VDRTCL0_ISRAMPGE_MASK;
-        writel(reg, sst->addr.pci_cfg + SST_VDRTCTL0);
+        /* for D0, always enable the block(DSRAM[0]) used for FW dump */
+        fw_dump_bit = 1 << SST_VDRTCL0_DSRAMPGE_SHIFT;
+        writel(reg & ~fw_dump_bit, sst->addr.pci_cfg + SST_VDRTCTL0);
 
 
         /* disable DMA finish function for SSP0 & SSP1 */
@@ -491,6 +493,7 @@ static const struct sst_sram_shift sram_shift[] = {
         {SST_DEV_ID_LYNX_POINT, 6, 16}, /* lp */
         {SST_DEV_ID_WILDCAT_POINT, 2, 12}, /* wpt */
 };
+
 static u32 hsw_block_get_bit(struct sst_mem_block *block)
 {
         u32 bit = 0, shift = 0, index;
@@ -587,7 +590,9 @@ static int hsw_block_disable(struct sst_mem_block *block)
 
         val = readl(sst->addr.pci_cfg + SST_VDRTCTL0);
         bit = hsw_block_get_bit(block);
-        writel(val | bit, sst->addr.pci_cfg + SST_VDRTCTL0);
+        /* don't disable DSRAM[0], keep it always enable for FW dump*/
+        if (bit != (1 << SST_VDRTCL0_DSRAMPGE_SHIFT))
+                writel(val | bit, sst->addr.pci_cfg + SST_VDRTCTL0);
 
         /* wait 18 DSP clock ticks */
         udelay(10);
@@ -612,7 +617,7 @@ static int hsw_init(struct sst_dsp *sst, struct sst_pdata *pdata)
         const struct sst_adsp_memregion *region;
         struct device *dev;
         int ret = -ENODEV, i, j, region_count;
-        u32 offset, size;
+        u32 offset, size, fw_dump_bit;
 
         dev = sst->dma_dev;
 
@@ -669,9 +674,11 @@ static int hsw_init(struct sst_dsp *sst, struct sst_pdata *pdata)
                 }
         }
 
+        /* always enable the block(DSRAM[0]) used for FW dump */
+        fw_dump_bit = 1 << SST_VDRTCL0_DSRAMPGE_SHIFT;
         /* set default power gating control, enable power gating control for all blocks. that is,
         can't be accessed, please enable each block before accessing. */
-        writel(0xffffffff, sst->addr.pci_cfg + SST_VDRTCTL0);
+        writel(0xffffffff & ~fw_dump_bit, sst->addr.pci_cfg + SST_VDRTCTL0);
 
         return 0;
 }
diff --git a/sound/soc/intel/sst-haswell-ipc.c b/sound/soc/intel/sst-haswell-ipc.c
index 8156cc1accb7..394af5684c05 100644
--- a/sound/soc/intel/sst-haswell-ipc.c
+++ b/sound/soc/intel/sst-haswell-ipc.c
@@ -31,6 +31,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/debugfs.h>
 #include <linux/pm_runtime.h>
+#include <sound/asound.h>
 
 #include "sst-haswell-ipc.h"
 #include "sst-dsp.h"
@@ -94,6 +95,8 @@
 /* Mailbox */
 #define IPC_MAX_MAILBOX_BYTES   256
 
+#define INVALID_STREAM_HW_ID    0xffffffff
+
 /* Global Message - Types and Replies */
 enum ipc_glb_type {
         IPC_GLB_GET_FW_VERSION = 0,             /* Retrieves firmware version */
@@ -240,6 +243,9 @@ struct sst_hsw_stream {
         u32 (*notify_position)(struct sst_hsw_stream *stream, void *data);
         void *pdata;
 
+        /* record the fw read position when playback */
+        snd_pcm_uframes_t old_position;
+        bool play_silence;
         struct list_head node;
 };
 
@@ -275,7 +281,6 @@ struct sst_hsw {
         /* FW config */
         struct sst_hsw_ipc_fw_ready fw_ready;
         struct sst_hsw_ipc_fw_version version;
-        struct sst_module *scratch;
         bool fw_done;
         struct sst_fw *sst_fw;
 
@@ -337,12 +342,6 @@ static inline u32 msg_get_stage_type(u32 msg)
         return (msg & IPC_STG_TYPE_MASK) >>  IPC_STG_TYPE_SHIFT;
 }
 
-static inline u32 msg_set_stage_type(u32 msg, u32 type)
-{
-        return (msg & ~IPC_STG_TYPE_MASK) +
-                (type << IPC_STG_TYPE_SHIFT);
-}
-
 static inline u32 msg_get_stream_id(u32 msg)
 {
         return (msg & IPC_STR_ID_MASK) >>  IPC_STR_ID_SHIFT;
@@ -969,45 +968,6 @@ int sst_hsw_fw_get_version(struct sst_hsw *hsw,
 }
 
 /* Mixer Controls */
-int sst_hsw_stream_mute(struct sst_hsw *hsw, struct sst_hsw_stream *stream,
-        u32 stage_id, u32 channel)
-{
-        int ret;
-
-        ret = sst_hsw_stream_get_volume(hsw, stream, stage_id, channel,
-                &stream->mute_volume[channel]);
-        if (ret < 0)
-                return ret;
-
-        ret = sst_hsw_stream_set_volume(hsw, stream, stage_id, channel, 0);
-        if (ret < 0) {
-                dev_err(hsw->dev, "error: can't unmute stream %d channel %d\n",
-                        stream->reply.stream_hw_id, channel);
-                return ret;
-        }
-
-        stream->mute[channel] = 1;
-        return 0;
-}
-
-int sst_hsw_stream_unmute(struct sst_hsw *hsw, struct sst_hsw_stream *stream,
-        u32 stage_id, u32 channel)
-
-{
-        int ret;
-
-        stream->mute[channel] = 0;
-        ret = sst_hsw_stream_set_volume(hsw, stream, stage_id, channel,
-                stream->mute_volume[channel]);
-        if (ret < 0) {
-                dev_err(hsw->dev, "error: can't unmute stream %d channel %d\n",
-                        stream->reply.stream_hw_id, channel);
-                return ret;
-        }
-
-        return 0;
-}
-
 int sst_hsw_stream_get_volume(struct sst_hsw *hsw, struct sst_hsw_stream *stream,
         u32 stage_id, u32 channel, u32 *volume)
 {
@@ -1021,17 +981,6 @@ int sst_hsw_stream_get_volume(struct sst_hsw *hsw, struct sst_hsw_stream *stream
         return 0;
 }
 
-int sst_hsw_stream_set_volume_curve(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream, u64 curve_duration,
-        enum sst_hsw_volume_curve curve)
-{
-        /* curve duration in steps of 100ns */
-        stream->vol_req.curve_duration = curve_duration;
-        stream->vol_req.curve_type = curve;
-
-        return 0;
-}
-
 /* stream volume */
 int sst_hsw_stream_set_volume(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream, u32 stage_id, u32 channel, u32 volume)
@@ -1083,42 +1032,6 @@ int sst_hsw_stream_set_volume(struct sst_hsw *hsw,
         return 0;
 }
 
-int sst_hsw_mixer_mute(struct sst_hsw *hsw, u32 stage_id, u32 channel)
-{
-        int ret;
-
-        ret = sst_hsw_mixer_get_volume(hsw, stage_id, channel,
-                &hsw->mute_volume[channel]);
-        if (ret < 0)
-                return ret;
-
-        ret = sst_hsw_mixer_set_volume(hsw, stage_id, channel, 0);
-        if (ret < 0) {
-                dev_err(hsw->dev, "error: failed to unmute mixer channel %d\n",
-                        channel);
-                return ret;
-        }
-
-        hsw->mute[channel] = 1;
-        return 0;
-}
-
-int sst_hsw_mixer_unmute(struct sst_hsw *hsw, u32 stage_id, u32 channel)
-{
-        int ret;
-
-        ret = sst_hsw_mixer_set_volume(hsw, stage_id, channel,
-                hsw->mixer_info.volume_register_address[channel]);
-        if (ret < 0) {
-                dev_err(hsw->dev, "error: failed to unmute mixer channel %d\n",
-                        channel);
-                return ret;
-        }
-
-        hsw->mute[channel] = 0;
-        return 0;
-}
-
 int sst_hsw_mixer_get_volume(struct sst_hsw *hsw, u32 stage_id, u32 channel,
         u32 *volume)
 {
@@ -1132,16 +1045,6 @@ int sst_hsw_mixer_get_volume(struct sst_hsw *hsw, u32 stage_id, u32 channel,
         return 0;
 }
 
-int sst_hsw_mixer_set_volume_curve(struct sst_hsw *hsw,
-         u64 curve_duration, enum sst_hsw_volume_curve curve)
-{
-        /* curve duration in steps of 100ns */
-        hsw->curve_duration = curve_duration;
-        hsw->curve_type = curve;
-
-        return 0;
-}
-
 /* global mixer volume */
 int sst_hsw_mixer_set_volume(struct sst_hsw *hsw, u32 stage_id, u32 channel,
         u32 volume)
@@ -1208,6 +1111,7 @@ struct sst_hsw_stream *sst_hsw_stream_new(struct sst_hsw *hsw, int id,
                 return NULL;
 
         spin_lock_irqsave(&sst->spinlock, flags);
+        stream->reply.stream_hw_id = INVALID_STREAM_HW_ID;
         list_add(&stream->node, &hsw->stream_list);
         stream->notify_position = notify_position;
         stream->pdata = data;
@@ -1447,50 +1351,32 @@ int sst_hsw_stream_commit(struct sst_hsw *hsw, struct sst_hsw_stream *stream)
         return 0;
 }
 
-/* Stream Information - these calls could be inline but we want the IPC
- ABI to be opaque to client PCM drivers to cope with any future ABI changes */
-int sst_hsw_stream_get_hw_id(struct sst_hsw *hsw,
+snd_pcm_uframes_t sst_hsw_stream_get_old_position(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream)
 {
-        return stream->reply.stream_hw_id;
+        return stream->old_position;
 }
 
-int sst_hsw_stream_get_mixer_id(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream)
+void sst_hsw_stream_set_old_position(struct sst_hsw *hsw,
+        struct sst_hsw_stream *stream, snd_pcm_uframes_t val)
 {
-        return stream->reply.mixer_hw_id;
+        stream->old_position = val;
 }
 
-u32 sst_hsw_stream_get_read_reg(struct sst_hsw *hsw,
+bool sst_hsw_stream_get_silence_start(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream)
 {
-        return stream->reply.read_position_register_address;
-}
-
-u32 sst_hsw_stream_get_pointer_reg(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream)
-{
-        return stream->reply.presentation_position_register_address;
-}
-
-u32 sst_hsw_stream_get_peak_reg(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream, u32 channel)
-{
-        if (channel >= 2)
-                return 0;
-
-        return stream->reply.peak_meter_register_address[channel];
+        return stream->play_silence;
 }
 
-u32 sst_hsw_stream_get_vol_reg(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream, u32 channel)
+void sst_hsw_stream_set_silence_start(struct sst_hsw *hsw,
+        struct sst_hsw_stream *stream, bool val)
 {
-        if (channel >= 2)
-                return 0;
-
-        return stream->reply.volume_register_address[channel];
+        stream->play_silence = val;
 }
 
+/* Stream Information - these calls could be inline but we want the IPC
+ ABI to be opaque to client PCM drivers to cope with any future ABI changes */
 int sst_hsw_mixer_get_info(struct sst_hsw *hsw)
 {
         struct sst_hsw_ipc_stream_info_reply *reply;
@@ -1628,30 +1514,6 @@ u64 sst_hsw_get_dsp_presentation_position(struct sst_hsw *hsw,
         return ppos;
 }
 
-int sst_hsw_stream_set_write_position(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream, u32 stage_id, u32 position)
-{
-        u32 header;
-        int ret;
-
-        trace_stream_write_position(stream->reply.stream_hw_id, position);
-
-        header = IPC_GLB_TYPE(IPC_GLB_STREAM_MESSAGE) |
-                IPC_STR_TYPE(IPC_STR_STAGE_MESSAGE);
-        header |= (stream->reply.stream_hw_id << IPC_STR_ID_SHIFT);
-        header |= (IPC_STG_SET_WRITE_POSITION << IPC_STG_TYPE_SHIFT);
-        header |= (stage_id << IPC_STG_ID_SHIFT);
-        stream->wpos.position = position;
-
-        ret = ipc_tx_message_nowait(hsw, header, &stream->wpos,
-                sizeof(stream->wpos));
-        if (ret < 0)
-                dev_err(hsw->dev, "error: stream %d set position %d failed\n",
-                        stream->reply.stream_hw_id, position);
-
-        return ret;
-}
-
 /* physical BE config */
 int sst_hsw_device_set_config(struct sst_hsw *hsw,
         enum sst_hsw_device_id dev, enum sst_hsw_device_mclk mclk,
@@ -2132,7 +1994,6 @@ void sst_hsw_dsp_free(struct device *dev, struct sst_pdata *pdata)
         dma_free_coherent(hsw->dsp->dma_dev, SST_HSW_DX_CONTEXT_SIZE,
                         hsw->dx_context, hsw->dx_context_paddr);
         sst_dsp_free(hsw->dsp);
-        kfree(hsw->scratch);
         kthread_stop(hsw->tx_thread);
         kfree(hsw->msg);
 }
diff --git a/sound/soc/intel/sst-haswell-ipc.h b/sound/soc/intel/sst-haswell-ipc.h
index 138e894ab413..858096041cb1 100644
--- a/sound/soc/intel/sst-haswell-ipc.h
+++ b/sound/soc/intel/sst-haswell-ipc.h
@@ -20,6 +20,7 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
+#include <sound/asound.h>
 
 #define SST_HSW_NO_CHANNELS             4
 #define SST_HSW_MAX_DX_REGIONS          14
@@ -376,32 +377,17 @@ int sst_hsw_fw_get_version(struct sst_hsw *hsw,
 u32 create_channel_map(enum sst_hsw_channel_config config);
 
 /* Stream Mixer Controls - */
-int sst_hsw_stream_mute(struct sst_hsw *hsw, struct sst_hsw_stream *stream,
-        u32 stage_id, u32 channel);
-int sst_hsw_stream_unmute(struct sst_hsw *hsw, struct sst_hsw_stream *stream,
-        u32 stage_id, u32 channel);
-
 int sst_hsw_stream_set_volume(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream, u32 stage_id, u32 channel, u32 volume);
 int sst_hsw_stream_get_volume(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream, u32 stage_id, u32 channel, u32 *volume);
 
-int sst_hsw_stream_set_volume_curve(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream, u64 curve_duration,
-        enum sst_hsw_volume_curve curve);
-
 /* Global Mixer Controls - */
-int sst_hsw_mixer_mute(struct sst_hsw *hsw, u32 stage_id, u32 channel);
-int sst_hsw_mixer_unmute(struct sst_hsw *hsw, u32 stage_id, u32 channel);
-
 int sst_hsw_mixer_set_volume(struct sst_hsw *hsw, u32 stage_id, u32 channel,
         u32 volume);
 int sst_hsw_mixer_get_volume(struct sst_hsw *hsw, u32 stage_id, u32 channel,
         u32 *volume);
 
-int sst_hsw_mixer_set_volume_curve(struct sst_hsw *hsw,
-        u64 curve_duration, enum sst_hsw_volume_curve curve);
-
 /* Stream API */
 struct sst_hsw_stream *sst_hsw_stream_new(struct sst_hsw *hsw, int id,
         u32 (*get_write_position)(struct sst_hsw_stream *stream, void *data),
@@ -440,18 +426,14 @@ int sst_hsw_stream_set_pmemory_info(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream, u32 offset, u32 size);
 int sst_hsw_stream_set_smemory_info(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream, u32 offset, u32 size);
-int sst_hsw_stream_get_hw_id(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream);
-int sst_hsw_stream_get_mixer_id(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream);
-u32 sst_hsw_stream_get_read_reg(struct sst_hsw *hsw,
+snd_pcm_uframes_t sst_hsw_stream_get_old_position(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream);
-u32 sst_hsw_stream_get_pointer_reg(struct sst_hsw *hsw,
+void sst_hsw_stream_set_old_position(struct sst_hsw *hsw,
+        struct sst_hsw_stream *stream, snd_pcm_uframes_t val);
+bool sst_hsw_stream_get_silence_start(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream);
-u32 sst_hsw_stream_get_peak_reg(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream, u32 channel);
-u32 sst_hsw_stream_get_vol_reg(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream, u32 channel);
+void sst_hsw_stream_set_silence_start(struct sst_hsw *hsw,
+        struct sst_hsw_stream *stream, bool val);
 int sst_hsw_mixer_get_info(struct sst_hsw *hsw);
 
 /* Stream ALSA trigger operations */
@@ -466,8 +448,6 @@ int sst_hsw_stream_get_read_pos(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream, u32 *position);
 int sst_hsw_stream_get_write_pos(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream, u32 *position);
-int sst_hsw_stream_set_write_position(struct sst_hsw *hsw,
-        struct sst_hsw_stream *stream, u32 stage_id, u32 position);
 u32 sst_hsw_get_dsp_position(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream);
 u64 sst_hsw_get_dsp_presentation_position(struct sst_hsw *hsw,
@@ -481,8 +461,6 @@ int sst_hsw_device_set_config(struct sst_hsw *hsw,
 /* DX Config */
 int sst_hsw_dx_set_state(struct sst_hsw *hsw,
         enum sst_hsw_dx_state state, struct sst_hsw_ipc_dx_reply *dx);
-int sst_hsw_dx_get_state(struct sst_hsw *hsw, u32 item,
-        u32 *offset, u32 *size, u32 *source);
 
 /* init */
 int sst_hsw_dsp_init(struct device *dev, struct sst_pdata *pdata);
diff --git a/sound/soc/intel/sst-haswell-pcm.c b/sound/soc/intel/sst-haswell-pcm.c
index 619525200705..7e21e8f85885 100644
--- a/sound/soc/intel/sst-haswell-pcm.c
+++ b/sound/soc/intel/sst-haswell-pcm.c
@@ -36,6 +36,11 @@
 #define HSW_PCM_COUNT           6
 #define HSW_VOLUME_MAX          0x7FFFFFFF      /* 0dB */
 
+#define SST_OLD_POSITION(d, r, o) ((d) +                \
+                        frames_to_bytes(r, o))
+#define SST_SAMPLES(r, x) (bytes_to_samples(r,  \
+                        frames_to_bytes(r, (x))))
+
 /* simple volume table */
 static const u32 volume_map[] = {
         HSW_VOLUME_MAX >> 30,
@@ -78,7 +83,6 @@ static const u32 volume_map[] = {
 #define HSW_PCM_DAI_ID_OFFLOAD0 1
 #define HSW_PCM_DAI_ID_OFFLOAD1 2
 #define HSW_PCM_DAI_ID_LOOPBACK 3
-#define HSW_PCM_DAI_ID_CAPTURE  4
 
 
 static const struct snd_pcm_hardware hsw_pcm_hardware = {
@@ -87,7 +91,8 @@ static const struct snd_pcm_hardware hsw_pcm_hardware = {
                                   SNDRV_PCM_INFO_INTERLEAVED |
                                   SNDRV_PCM_INFO_PAUSE |
                                   SNDRV_PCM_INFO_RESUME |
-                                  SNDRV_PCM_INFO_NO_PERIOD_WAKEUP,
+                                  SNDRV_PCM_INFO_NO_PERIOD_WAKEUP |
+                                  SNDRV_PCM_INFO_DRAIN_TRIGGER,
         .formats                = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE |
                                   SNDRV_PCM_FMTBIT_S32_LE,
         .period_bytes_min       = PAGE_SIZE,
@@ -99,6 +104,7 @@ static const struct snd_pcm_hardware hsw_pcm_hardware = {
 
 struct hsw_pcm_module_map {
         int dai_id;
+        int stream;
         enum sst_hsw_module_id mod_id;
 };
 
@@ -119,8 +125,9 @@ struct hsw_pcm_data {
 };
 
 enum hsw_pm_state {
-        HSW_PM_STATE_D3 = 0,
-        HSW_PM_STATE_D0 = 1,
+        HSW_PM_STATE_D0 = 0,
+        HSW_PM_STATE_RTD3 = 1,
+        HSW_PM_STATE_D3 = 2,
 };
 
 /* private data for the driver */
@@ -135,7 +142,17 @@ struct hsw_priv_data {
         struct snd_dma_buffer dmab[HSW_PCM_COUNT][2];
 
         /* DAI data */
-        struct hsw_pcm_data pcm[HSW_PCM_COUNT];
+        struct hsw_pcm_data pcm[HSW_PCM_COUNT][2];
+};
+
+
+/* static mappings between PCMs and modules - may be dynamic in future */
+static struct hsw_pcm_module_map mod_map[] = {
+        {HSW_PCM_DAI_ID_SYSTEM, 0, SST_HSW_MODULE_PCM_SYSTEM},
+        {HSW_PCM_DAI_ID_OFFLOAD0, 0, SST_HSW_MODULE_PCM},
+        {HSW_PCM_DAI_ID_OFFLOAD1, 0, SST_HSW_MODULE_PCM},
+        {HSW_PCM_DAI_ID_LOOPBACK, 1, SST_HSW_MODULE_PCM_REFERENCE},
+        {HSW_PCM_DAI_ID_SYSTEM, 1, SST_HSW_MODULE_PCM_CAPTURE},
 };
 
 static u32 hsw_notify_pointer(struct sst_hsw_stream *stream, void *data);
@@ -168,9 +185,14 @@ static int hsw_stream_volume_put(struct snd_kcontrol *kcontrol,
                 (struct soc_mixer_control *)kcontrol->private_value;
         struct hsw_priv_data *pdata =
                 snd_soc_platform_get_drvdata(platform);
-        struct hsw_pcm_data *pcm_data = &pdata->pcm[mc->reg];
+        struct hsw_pcm_data *pcm_data;
         struct sst_hsw *hsw = pdata->hsw;
         u32 volume;
+        int dai, stream;
+
+        dai = mod_map[mc->reg].dai_id;
+        stream = mod_map[mc->reg].stream;
+        pcm_data = &pdata->pcm[dai][stream];
 
         mutex_lock(&pcm_data->mutex);
         pm_runtime_get_sync(pdata->dev);
@@ -212,9 +234,14 @@ static int hsw_stream_volume_get(struct snd_kcontrol *kcontrol,
                 (struct soc_mixer_control *)kcontrol->private_value;
         struct hsw_priv_data *pdata =
                 snd_soc_platform_get_drvdata(platform);
-        struct hsw_pcm_data *pcm_data = &pdata->pcm[mc->reg];
+        struct hsw_pcm_data *pcm_data;
         struct sst_hsw *hsw = pdata->hsw;
         u32 volume;
+        int dai, stream;
+
+        dai = mod_map[mc->reg].dai_id;
+        stream = mod_map[mc->reg].stream;
+        pcm_data = &pdata->pcm[dai][stream];
 
         mutex_lock(&pcm_data->mutex);
         pm_runtime_get_sync(pdata->dev);
@@ -309,7 +336,7 @@ static const struct snd_kcontrol_new hsw_volume_controls[] = {
                 ARRAY_SIZE(volume_map) - 1, 0,
                 hsw_stream_volume_get, hsw_stream_volume_put, hsw_vol_tlv),
         /* Mic Capture volume */
-        SOC_DOUBLE_EXT_TLV("Mic Capture Volume", 0, 0, 8,
+        SOC_DOUBLE_EXT_TLV("Mic Capture Volume", 4, 0, 8,
                 ARRAY_SIZE(volume_map) - 1, 0,
                 hsw_stream_volume_get, hsw_stream_volume_put, hsw_vol_tlv),
 };
@@ -353,7 +380,7 @@ static int hsw_pcm_hw_params(struct snd_pcm_substream *substream,
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct hsw_priv_data *pdata =
                 snd_soc_platform_get_drvdata(rtd->platform);
-        struct hsw_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);
+        struct hsw_pcm_data *pcm_data;
         struct sst_hsw *hsw = pdata->hsw;
         struct sst_module *module_data;
         struct sst_dsp *dsp;
@@ -362,7 +389,10 @@ static int hsw_pcm_hw_params(struct snd_pcm_substream *substream,
         enum sst_hsw_stream_path_id path_id;
         u32 rate, bits, map, pages, module_id;
         u8 channels;
-        int ret;
+        int ret, dai;
+
+        dai = mod_map[rtd->cpu_dai->id].dai_id;
+        pcm_data = &pdata->pcm[dai][substream->stream];
 
         /* check if we are being called a subsequent time */
         if (pcm_data->allocated) {
@@ -552,20 +582,35 @@ static int hsw_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct hsw_priv_data *pdata =
                 snd_soc_platform_get_drvdata(rtd->platform);
-        struct hsw_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);
+        struct hsw_pcm_data *pcm_data;
+        struct sst_hsw_stream *sst_stream;
         struct sst_hsw *hsw = pdata->hsw;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        snd_pcm_uframes_t pos;
+        int dai;
+
+        dai = mod_map[rtd->cpu_dai->id].dai_id;
+        pcm_data = &pdata->pcm[dai][substream->stream];
+        sst_stream = pcm_data->stream;
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
         case SNDRV_PCM_TRIGGER_RESUME:
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                sst_hsw_stream_set_silence_start(hsw, sst_stream, false);
                 sst_hsw_stream_resume(hsw, pcm_data->stream, 0);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
         case SNDRV_PCM_TRIGGER_SUSPEND:
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                sst_hsw_stream_set_silence_start(hsw, sst_stream, false);
                 sst_hsw_stream_pause(hsw, pcm_data->stream, 0);
                 break;
+        case SNDRV_PCM_TRIGGER_DRAIN:
+                pos = runtime->control->appl_ptr % runtime->buffer_size;
+                sst_hsw_stream_set_old_position(hsw, pcm_data->stream, pos);
+                sst_hsw_stream_set_silence_start(hsw, sst_stream, true);
+                break;
         default:
                 break;
         }
@@ -579,13 +624,62 @@ static u32 hsw_notify_pointer(struct sst_hsw_stream *stream, void *data)
         struct snd_pcm_substream *substream = pcm_data->substream;
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct hsw_priv_data *pdata =
+                snd_soc_platform_get_drvdata(rtd->platform);
+        struct sst_hsw *hsw = pdata->hsw;
         u32 pos;
+        snd_pcm_uframes_t position = bytes_to_frames(runtime,
+                 sst_hsw_get_dsp_position(hsw, pcm_data->stream));
+        unsigned char *dma_area = runtime->dma_area;
+        snd_pcm_uframes_t dma_frames =
+                bytes_to_frames(runtime, runtime->dma_bytes);
+        snd_pcm_uframes_t old_position;
+        ssize_t samples;
 
         pos = frames_to_bytes(runtime,
                 (runtime->control->appl_ptr % runtime->buffer_size));
 
         dev_vdbg(rtd->dev, "PCM: App pointer %d bytes\n", pos);
 
+        /* SST fw don't know where to stop dma
+         * So, SST driver need to clean the data which has been consumed
+         */
+        if (dma_area == NULL || dma_frames <= 0
+                || (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                || !sst_hsw_stream_get_silence_start(hsw, stream)) {
+                snd_pcm_period_elapsed(substream);
+                return pos;
+        }
+
+        old_position = sst_hsw_stream_get_old_position(hsw, stream);
+        if (position > old_position) {
+                if (position < dma_frames) {
+                        samples = SST_SAMPLES(runtime, position - old_position);
+                        snd_pcm_format_set_silence(runtime->format,
+                                SST_OLD_POSITION(dma_area,
+                                        runtime, old_position),
+                                samples);
+                } else
+                        dev_err(rtd->dev, "PCM: position is wrong\n");
+        } else {
+                if (old_position < dma_frames) {
+                        samples = SST_SAMPLES(runtime,
+                                dma_frames - old_position);
+                        snd_pcm_format_set_silence(runtime->format,
+                                SST_OLD_POSITION(dma_area,
+                                        runtime, old_position),
+                                samples);
+                } else
+                        dev_err(rtd->dev, "PCM: dma_bytes is wrong\n");
+                if (position < dma_frames) {
+                        samples = SST_SAMPLES(runtime, position);
+                        snd_pcm_format_set_silence(runtime->format,
+                                dma_area, samples);
+                } else
+                        dev_err(rtd->dev, "PCM: position is wrong\n");
+        }
+        sst_hsw_stream_set_old_position(hsw, stream, position);
+
         /* let alsa know we have play a period */
         snd_pcm_period_elapsed(substream);
         return pos;
@@ -597,11 +691,16 @@ static snd_pcm_uframes_t hsw_pcm_pointer(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct hsw_priv_data *pdata =
                 snd_soc_platform_get_drvdata(rtd->platform);
-        struct hsw_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);
+        struct hsw_pcm_data *pcm_data;
         struct sst_hsw *hsw = pdata->hsw;
         snd_pcm_uframes_t offset;
         uint64_t ppos;
-        u32 position = sst_hsw_get_dsp_position(hsw, pcm_data->stream);
+        u32 position;
+        int dai;
+
+        dai = mod_map[rtd->cpu_dai->id].dai_id;
+        pcm_data = &pdata->pcm[dai][substream->stream];
+        position = sst_hsw_get_dsp_position(hsw, pcm_data->stream);
 
         offset = bytes_to_frames(runtime, position);
         ppos = sst_hsw_get_dsp_presentation_position(hsw, pcm_data->stream);
@@ -618,8 +717,10 @@ static int hsw_pcm_open(struct snd_pcm_substream *substream)
                 snd_soc_platform_get_drvdata(rtd->platform);
         struct hsw_pcm_data *pcm_data;
         struct sst_hsw *hsw = pdata->hsw;
+        int dai;
 
-        pcm_data = &pdata->pcm[rtd->cpu_dai->id];
+        dai = mod_map[rtd->cpu_dai->id].dai_id;
+        pcm_data = &pdata->pcm[dai][substream->stream];
 
         mutex_lock(&pcm_data->mutex);
         pm_runtime_get_sync(pdata->dev);
@@ -648,9 +749,12 @@ static int hsw_pcm_close(struct snd_pcm_substream *substream)
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct hsw_priv_data *pdata =
                 snd_soc_platform_get_drvdata(rtd->platform);
-        struct hsw_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);
+        struct hsw_pcm_data *pcm_data;
         struct sst_hsw *hsw = pdata->hsw;
-        int ret;
+        int ret, dai;
+
+        dai = mod_map[rtd->cpu_dai->id].dai_id;
+        pcm_data = &pdata->pcm[dai][substream->stream];
 
         mutex_lock(&pcm_data->mutex);
         ret = sst_hsw_stream_reset(hsw, pcm_data->stream);
@@ -685,15 +789,6 @@ static struct snd_pcm_ops hsw_pcm_ops = {
         .page           = snd_pcm_sgbuf_ops_page,
 };
 
-/* static mappings between PCMs and modules - may be dynamic in future */
-static struct hsw_pcm_module_map mod_map[] = {
-        {HSW_PCM_DAI_ID_SYSTEM, SST_HSW_MODULE_PCM_SYSTEM},
-        {HSW_PCM_DAI_ID_OFFLOAD0, SST_HSW_MODULE_PCM},
-        {HSW_PCM_DAI_ID_OFFLOAD1, SST_HSW_MODULE_PCM},
-        {HSW_PCM_DAI_ID_LOOPBACK, SST_HSW_MODULE_PCM_REFERENCE},
-        {HSW_PCM_DAI_ID_CAPTURE, SST_HSW_MODULE_PCM_CAPTURE},
-};
-
 static int hsw_pcm_create_modules(struct hsw_priv_data *pdata)
 {
         struct sst_hsw *hsw = pdata->hsw;
@@ -701,7 +796,7 @@ static int hsw_pcm_create_modules(struct hsw_priv_data *pdata)
         int i;
 
         for (i = 0; i < ARRAY_SIZE(mod_map); i++) {
-                pcm_data = &pdata->pcm[i];
+                pcm_data = &pdata->pcm[mod_map[i].dai_id][mod_map[i].stream];
 
                 /* create new runtime module, use same offset if recreated */
                 pcm_data->runtime = sst_hsw_runtime_module_create(hsw,
@@ -716,7 +811,7 @@ static int hsw_pcm_create_modules(struct hsw_priv_data *pdata)
 
 err:
         for (--i; i >= 0; i--) {
-                pcm_data = &pdata->pcm[i];
+                pcm_data = &pdata->pcm[mod_map[i].dai_id][mod_map[i].stream];
                 sst_hsw_runtime_module_free(pcm_data->runtime);
         }
 
@@ -729,17 +824,12 @@ static void hsw_pcm_free_modules(struct hsw_priv_data *pdata)
         int i;
 
         for (i = 0; i < ARRAY_SIZE(mod_map); i++) {
-                pcm_data = &pdata->pcm[i];
+                pcm_data = &pdata->pcm[mod_map[i].dai_id][mod_map[i].stream];
 
                 sst_hsw_runtime_module_free(pcm_data->runtime);
         }
 }
 
-static void hsw_pcm_free(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 static int hsw_pcm_new(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_pcm *pcm = rtd->pcm;
@@ -762,7 +852,10 @@ static int hsw_pcm_new(struct snd_soc_pcm_runtime *rtd)
                         return ret;
                 }
         }
-        priv_data->pcm[rtd->cpu_dai->id].hsw_pcm = pcm;
+        if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream)
+                priv_data->pcm[rtd->cpu_dai->id][SNDRV_PCM_STREAM_PLAYBACK].hsw_pcm = pcm;
+        if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream)
+                priv_data->pcm[rtd->cpu_dai->id][SNDRV_PCM_STREAM_CAPTURE].hsw_pcm = pcm;
 
         return ret;
 }
@@ -871,10 +964,9 @@ static int hsw_pcm_probe(struct snd_soc_platform *platform)
         /* allocate DSP buffer page tables */
         for (i = 0; i < ARRAY_SIZE(hsw_dais); i++) {
 
-                mutex_init(&priv_data->pcm[i].mutex);
-
                 /* playback */
                 if (hsw_dais[i].playback.channels_min) {
+                        mutex_init(&priv_data->pcm[i][SNDRV_PCM_STREAM_PLAYBACK].mutex);
                         ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, dma_dev,
                                 PAGE_SIZE, &priv_data->dmab[i][0]);
                         if (ret < 0)
@@ -883,6 +975,7 @@ static int hsw_pcm_probe(struct snd_soc_platform *platform)
 
                 /* capture */
                 if (hsw_dais[i].capture.channels_min) {
+                        mutex_init(&priv_data->pcm[i][SNDRV_PCM_STREAM_CAPTURE].mutex);
                         ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, dma_dev,
                                 PAGE_SIZE, &priv_data->dmab[i][1]);
                         if (ret < 0)
@@ -936,7 +1029,6 @@ static struct snd_soc_platform_driver hsw_soc_platform = {
         .remove         = hsw_pcm_remove,
         .ops            = &hsw_pcm_ops,
         .pcm_new        = hsw_pcm_new,
-        .pcm_free       = hsw_pcm_free,
 };
 
 static const struct snd_soc_component_driver hsw_dai_component = {
@@ -1010,12 +1102,12 @@ static int hsw_pcm_runtime_suspend(struct device *dev)
         struct hsw_priv_data *pdata = dev_get_drvdata(dev);
         struct sst_hsw *hsw = pdata->hsw;
 
-        if (pdata->pm_state == HSW_PM_STATE_D3)
+        if (pdata->pm_state >= HSW_PM_STATE_RTD3)
                 return 0;
 
         sst_hsw_dsp_runtime_suspend(hsw);
         sst_hsw_dsp_runtime_sleep(hsw);
-        pdata->pm_state = HSW_PM_STATE_D3;
+        pdata->pm_state = HSW_PM_STATE_RTD3;
 
         return 0;
 }
@@ -1026,7 +1118,7 @@ static int hsw_pcm_runtime_resume(struct device *dev)
         struct sst_hsw *hsw = pdata->hsw;
         int ret;
 
-        if (pdata->pm_state == HSW_PM_STATE_D0)
+        if (pdata->pm_state != HSW_PM_STATE_RTD3)
                 return 0;
 
         ret = sst_hsw_dsp_load(hsw);
@@ -1066,7 +1158,7 @@ static void hsw_pcm_complete(struct device *dev)
         struct hsw_pcm_data *pcm_data;
         int i, err;
 
-        if (pdata->pm_state == HSW_PM_STATE_D0)
+        if (pdata->pm_state != HSW_PM_STATE_D3)
                 return;
 
         err = sst_hsw_dsp_load(hsw);
@@ -1081,8 +1173,8 @@ static void hsw_pcm_complete(struct device *dev)
                 return;
         }
 
-        for (i = 0; i < HSW_PCM_DAI_ID_CAPTURE + 1; i++) {
-                pcm_data = &pdata->pcm[i];
+        for (i = 0; i < ARRAY_SIZE(mod_map); i++) {
+                pcm_data = &pdata->pcm[mod_map[i].dai_id][mod_map[i].stream];
 
                 if (!pcm_data->substream)
                         continue;
@@ -1114,41 +1206,42 @@ static int hsw_pcm_prepare(struct device *dev)
 
         if (pdata->pm_state == HSW_PM_STATE_D3)
                 return 0;
-        /* suspend all active streams */
-        for (i = 0; i < HSW_PCM_DAI_ID_CAPTURE + 1; i++) {
-                pcm_data = &pdata->pcm[i];
+        else if (pdata->pm_state == HSW_PM_STATE_D0) {
+                /* suspend all active streams */
+                for (i = 0; i < ARRAY_SIZE(mod_map); i++) {
+                        pcm_data = &pdata->pcm[mod_map[i].dai_id][mod_map[i].stream];
+
+                        if (!pcm_data->substream)
+                                continue;
+                        dev_dbg(dev, "suspending pcm %d\n", i);
+                        snd_pcm_suspend_all(pcm_data->hsw_pcm);
+
+                        /* We need to wait until the DSP FW stops the streams */
+                        msleep(2);
+                }
 
-                if (!pcm_data->substream)
-                        continue;
-                dev_dbg(dev, "suspending pcm %d\n", i);
-                snd_pcm_suspend_all(pcm_data->hsw_pcm);
+                /* preserve persistent memory */
+                for (i = 0; i < ARRAY_SIZE(mod_map); i++) {
+                        pcm_data = &pdata->pcm[mod_map[i].dai_id][mod_map[i].stream];
+
+                        if (!pcm_data->substream)
+                                continue;
 
-                /* We need to wait until the DSP FW stops the streams */
-                msleep(2);
+                        dev_dbg(dev, "saving context pcm %d\n", i);
+                        err = sst_module_runtime_save(pcm_data->runtime,
+                                &pcm_data->context);
+                        if (err < 0)
+                                dev_err(dev, "failed to save context for PCM %d\n", i);
+                }
+                /* enter D3 state and stall */
+                sst_hsw_dsp_runtime_suspend(hsw);
+                /* put the DSP to sleep */
+                sst_hsw_dsp_runtime_sleep(hsw);
         }
 
         snd_soc_suspend(pdata->soc_card->dev);
         snd_soc_poweroff(pdata->soc_card->dev);
 
-        /* enter D3 state and stall */
-        sst_hsw_dsp_runtime_suspend(hsw);
-
-        /* preserve persistent memory */
-        for (i = 0; i < HSW_PCM_DAI_ID_CAPTURE + 1; i++) {
-                pcm_data = &pdata->pcm[i];
-
-                if (!pcm_data->substream)
-                        continue;
-
-                dev_dbg(dev, "saving context pcm %d\n", i);
-                err = sst_module_runtime_save(pcm_data->runtime,
-                        &pcm_data->context);
-                if (err < 0)
-                        dev_err(dev, "failed to save context for PCM %d\n", i);
-        }
-
-        /* put the DSP to sleep */
-        sst_hsw_dsp_runtime_sleep(hsw);
         pdata->pm_state = HSW_PM_STATE_D3;
 
         return 0;
diff --git a/sound/soc/intel/sst-mfld-platform-pcm.c b/sound/soc/intel/sst-mfld-platform-pcm.c
index a1a8d9d91539..7523cbef8780 100644
--- a/sound/soc/intel/sst-mfld-platform-pcm.c
+++ b/sound/soc/intel/sst-mfld-platform-pcm.c
@@ -643,12 +643,6 @@ static struct snd_pcm_ops sst_platform_ops = {
         .pointer = sst_platform_pcm_pointer,
 };
 
-static void sst_pcm_free(struct snd_pcm *pcm)
-{
-        dev_dbg(pcm->dev, "sst_pcm_free called\n");
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 static int sst_pcm_new(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_soc_dai *dai = rtd->cpu_dai;
@@ -679,7 +673,6 @@ static struct snd_soc_platform_driver sst_soc_platform_drv  = {
         .ops            = &sst_platform_ops,
         .compr_ops      = &sst_platform_compr_ops,
         .pcm_new        = sst_pcm_new,
-        .pcm_free       = sst_pcm_free,
 };
 
 static const struct snd_soc_component_driver sst_component = {
diff --git a/sound/soc/intel/sst/sst.c b/sound/soc/intel/sst/sst.c
index 8a8d56a146e7..11c578651c1c 100644
--- a/sound/soc/intel/sst/sst.c
+++ b/sound/soc/intel/sst/sst.c
@@ -350,7 +350,9 @@ static inline void sst_save_shim64(struct intel_sst_drv *ctx,
 
         spin_lock_irqsave(&ctx->ipc_spin_lock, irq_flags);
 
-        shim_regs->imrx = sst_shim_read64(shim, SST_IMRX),
+        shim_regs->imrx = sst_shim_read64(shim, SST_IMRX);
+        shim_regs->csr = sst_shim_read64(shim, SST_CSR);
+
 
         spin_unlock_irqrestore(&ctx->ipc_spin_lock, irq_flags);
 }
@@ -367,6 +369,7 @@ static inline void sst_restore_shim64(struct intel_sst_drv *ctx,
          */
         spin_lock_irqsave(&ctx->ipc_spin_lock, irq_flags);
         sst_shim_write64(shim, SST_IMRX, shim_regs->imrx),
+        sst_shim_write64(shim, SST_CSR, shim_regs->csr),
         spin_unlock_irqrestore(&ctx->ipc_spin_lock, irq_flags);
 }
 
@@ -379,6 +382,10 @@ void sst_configure_runtime_pm(struct intel_sst_drv *ctx)
          * initially active. So change the state to active before
          * enabling the pm
          */
+
+        if (!acpi_disabled)
+                pm_runtime_set_active(ctx->dev);
+
         pm_runtime_enable(ctx->dev);
 
         if (acpi_disabled)
@@ -409,6 +416,7 @@ static int intel_sst_runtime_suspend(struct device *dev)
         synchronize_irq(ctx->irq_num);
         flush_workqueue(ctx->post_msg_wq);
 
+        ctx->ops->reset(ctx);
         /* save the shim registers because PMC doesn't save state */
         sst_save_shim64(ctx, ctx->shim, ctx->shim_regs64);
 
diff --git a/sound/soc/intel/sst/sst.h b/sound/soc/intel/sst/sst.h
index 7f4bbfcbc6f5..562bc483d6b7 100644
--- a/sound/soc/intel/sst/sst.h
+++ b/sound/soc/intel/sst/sst.h
@@ -58,6 +58,7 @@ enum sst_algo_ops {
 #define SST_BLOCK_TIMEOUT       1000
 
 #define FW_SIGNATURE_SIZE       4
+#define FW_NAME_SIZE            32
 
 /* stream states */
 enum sst_stream_states {
@@ -426,7 +427,7 @@ struct intel_sst_drv {
          * Holder for firmware name. Due to async call it needs to be
          * persistent till worker thread gets called
          */
-        char firmware_name[20];
+        char firmware_name[FW_NAME_SIZE];
 };
 
 /* misc definitions */
diff --git a/sound/soc/intel/sst/sst_acpi.c b/sound/soc/intel/sst/sst_acpi.c
index b3360139c41a..b782dfdcdbba 100644
--- a/sound/soc/intel/sst/sst_acpi.c
+++ b/sound/soc/intel/sst/sst_acpi.c
@@ -47,7 +47,7 @@ struct sst_machines {
         char board[32];
         char machine[32];
         void (*machine_quirk)(void);
-        char firmware[32];
+        char firmware[FW_NAME_SIZE];
         struct sst_platform_info *pdata;
 
 };
@@ -245,7 +245,7 @@ static struct sst_machines *sst_acpi_find_machine(
         return NULL;
 }
 
-int sst_acpi_probe(struct platform_device *pdev)
+static int sst_acpi_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         int ret = 0;
@@ -332,7 +332,7 @@ do_sst_cleanup:
 * This function is called by OS when a device is unloaded
 * This frees the interrupt etc
 */
-int sst_acpi_remove(struct platform_device *pdev)
+static int sst_acpi_remove(struct platform_device *pdev)
 {
         struct intel_sst_drv *ctx;
 
@@ -352,6 +352,8 @@ static struct sst_machines sst_acpi_bytcr[] = {
 static struct sst_machines sst_acpi_chv[] = {
         {"10EC5670", "cht-bsw", "cht-bsw-rt5672", NULL, "intel/fw_sst_22a8.bin",
                                                 &chv_platform_data },
+        {"10EC5645", "cht-bsw", "cht-bsw-rt5645", NULL, "intel/fw_sst_22a8.bin",
+                                                &chv_platform_data },
         {},
 };
 
@@ -366,7 +368,6 @@ MODULE_DEVICE_TABLE(acpi, sst_acpi_ids);
 static struct platform_driver sst_acpi_driver = {
         .driver = {
                 .name                   = "intel_sst_acpi",
-                .owner                  = THIS_MODULE,
                 .acpi_match_table       = ACPI_PTR(sst_acpi_ids),
                 .pm                     = &intel_sst_pm,
         },
diff --git a/sound/soc/intel/sst/sst_loader.c b/sound/soc/intel/sst/sst_loader.c
index b580f96e25e5..7888cd707853 100644
--- a/sound/soc/intel/sst/sst_loader.c
+++ b/sound/soc/intel/sst/sst_loader.c
@@ -324,8 +324,7 @@ void sst_firmware_load_cb(const struct firmware *fw, void *context)
 
         if (ctx->sst_state != SST_RESET ||
                         ctx->fw_in_mem != NULL) {
-                if (fw != NULL)
-                        release_firmware(fw);
+                release_firmware(fw);
                 mutex_unlock(&ctx->sst_lock);
                 return;
         }
diff --git a/sound/soc/jz4740/jz4740-i2s.c b/sound/soc/jz4740/jz4740-i2s.c
index d3d45c6f064f..07f77815a586 100644
--- a/sound/soc/jz4740/jz4740-i2s.c
+++ b/sound/soc/jz4740/jz4740-i2s.c
@@ -14,6 +14,8 @@
 
 #include <linux/init.h>
 #include <linux/io.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
@@ -83,6 +85,8 @@
 #define JZ_AIC_I2S_STATUS_BUSY BIT(2)
 
 #define JZ_AIC_CLK_DIV_MASK 0xf
+#define I2SDIV_DV_SHIFT 8
+#define I2SDIV_DV_MASK (0xf << I2SDIV_DV_SHIFT)
 
 struct jz4740_i2s {
         struct resource *mem;
@@ -237,10 +241,14 @@ static int jz4740_i2s_hw_params(struct snd_pcm_substream *substream,
 {
         struct jz4740_i2s *i2s = snd_soc_dai_get_drvdata(dai);
         unsigned int sample_size;
-        uint32_t ctrl;
+        uint32_t ctrl, div_reg;
+        int div;
 
         ctrl = jz4740_i2s_read(i2s, JZ_REG_AIC_CTRL);
 
+        div_reg = jz4740_i2s_read(i2s, JZ_REG_AIC_CLK_DIV);
+        div = clk_get_rate(i2s->clk_i2s) / (64 * params_rate(params));
+
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_S8:
                 sample_size = 0;
@@ -264,7 +272,10 @@ static int jz4740_i2s_hw_params(struct snd_pcm_substream *substream,
                 ctrl |= sample_size << JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_OFFSET;
         }
 
+        div_reg &= ~I2SDIV_DV_MASK;
+        div_reg |= (div - 1) << I2SDIV_DV_SHIFT;
         jz4740_i2s_write(i2s, JZ_REG_AIC_CTRL, ctrl);
+        jz4740_i2s_write(i2s, JZ_REG_AIC_CLK_DIV, div_reg);
 
         return 0;
 }
@@ -415,6 +426,13 @@ static const struct snd_soc_component_driver jz4740_i2s_component = {
         .name           = "jz4740-i2s",
 };
 
+#ifdef CONFIG_OF
+static const struct of_device_id jz4740_of_matches[] = {
+        { .compatible = "ingenic,jz4740-i2s" },
+        { /* sentinel */ }
+};
+#endif
+
 static int jz4740_i2s_dev_probe(struct platform_device *pdev)
 {
         struct jz4740_i2s *i2s;
@@ -455,6 +473,7 @@ static struct platform_driver jz4740_i2s_driver = {
         .probe = jz4740_i2s_dev_probe,
         .driver = {
                 .name = "jz4740-i2s",
+                .of_match_table = of_match_ptr(jz4740_of_matches)
         },
 };
 
diff --git a/sound/soc/mxs/mxs-saif.c b/sound/soc/mxs/mxs-saif.c
index d9865082160c..c866ade28ad0 100644
--- a/sound/soc/mxs/mxs-saif.c
+++ b/sound/soc/mxs/mxs-saif.c
@@ -710,7 +710,7 @@ static int mxs_saif_probe(struct platform_device *pdev)
         struct device_node *np = pdev->dev.of_node;
         struct resource *iores;
         struct mxs_saif *saif;
-        int ret = 0;
+        int irq, ret = 0;
         struct device_node *master;
 
         if (!np)
@@ -763,16 +763,16 @@ static int mxs_saif_probe(struct platform_device *pdev)
         if (IS_ERR(saif->base))
                 return PTR_ERR(saif->base);
 
-        saif->irq = platform_get_irq(pdev, 0);
-        if (saif->irq < 0) {
-                ret = saif->irq;
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                ret = irq;
                 dev_err(&pdev->dev, "failed to get irq resource: %d\n",
                         ret);
                 return ret;
         }
 
         saif->dev = &pdev->dev;
-        ret = devm_request_irq(&pdev->dev, saif->irq, mxs_saif_irq, 0,
+        ret = devm_request_irq(&pdev->dev, irq, mxs_saif_irq, 0,
                                dev_name(&pdev->dev), saif);
         if (ret) {
                 dev_err(&pdev->dev, "failed to request irq\n");
diff --git a/sound/soc/mxs/mxs-saif.h b/sound/soc/mxs/mxs-saif.h
index fbaf7badfdfb..9a4c0b291b9e 100644
--- a/sound/soc/mxs/mxs-saif.h
+++ b/sound/soc/mxs/mxs-saif.h
@@ -116,7 +116,6 @@ struct mxs_saif {
         unsigned int mclk;
         unsigned int mclk_in_use;
         void __iomem *base;
-        int irq;
         unsigned int id;
         unsigned int master_id;
         unsigned int cur_rate;
diff --git a/sound/soc/mxs/mxs-sgtl5000.c b/sound/soc/mxs/mxs-sgtl5000.c
index 6f1916b71815..6e6fce6a14ba 100644
--- a/sound/soc/mxs/mxs-sgtl5000.c
+++ b/sound/soc/mxs/mxs-sgtl5000.c
@@ -36,7 +36,7 @@ static int mxs_sgtl5000_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_dai *codec_dai = rtd->codec_dai;
         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
         unsigned int rate = params_rate(params);
-        u32 dai_format, mclk;
+        u32 mclk;
         int ret;
 
         /* sgtl5000 does not support 512*rate when in 96000 fs */
@@ -65,26 +65,6 @@ static int mxs_sgtl5000_hw_params(struct snd_pcm_substream *substream,
                 return ret;
         }
 
-        /* set codec to slave mode */
-        dai_format = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
-                        SND_SOC_DAIFMT_CBS_CFS;
-
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, dai_format);
-        if (ret) {
-                dev_err(codec_dai->dev, "Failed to set dai format to %08x\n",
-                        dai_format);
-                return ret;
-        }
-
-        /* set cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, dai_format);
-        if (ret) {
-                dev_err(cpu_dai->dev, "Failed to set dai format to %08x\n",
-                        dai_format);
-                return ret;
-        }
-
         return 0;
 }
 
@@ -92,17 +72,22 @@ static struct snd_soc_ops mxs_sgtl5000_hifi_ops = {
         .hw_params = mxs_sgtl5000_hw_params,
 };
 
+#define MXS_SGTL5000_DAI_FMT (SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | \
+        SND_SOC_DAIFMT_CBS_CFS)
+
 static struct snd_soc_dai_link mxs_sgtl5000_dai[] = {
         {
                 .name           = "HiFi Tx",
                 .stream_name    = "HiFi Playback",
                 .codec_dai_name = "sgtl5000",
+                .dai_fmt        = MXS_SGTL5000_DAI_FMT,
                 .ops            = &mxs_sgtl5000_hifi_ops,
                 .playback_only  = true,
         }, {
                 .name           = "HiFi Rx",
                 .stream_name    = "HiFi Capture",
                 .codec_dai_name = "sgtl5000",
+                .dai_fmt        = MXS_SGTL5000_DAI_FMT,
                 .ops            = &mxs_sgtl5000_hifi_ops,
                 .capture_only   = true,
         },
diff --git a/sound/soc/nuc900/nuc900-pcm.c b/sound/soc/nuc900/nuc900-pcm.c
index b779a3d9b5dd..b809fa909e4d 100644
--- a/sound/soc/nuc900/nuc900-pcm.c
+++ b/sound/soc/nuc900/nuc900-pcm.c
@@ -306,11 +306,6 @@ static struct snd_pcm_ops nuc900_dma_ops = {
         .mmap           = nuc900_dma_mmap,
 };
 
-static void nuc900_dma_free_dma_buffers(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 static int nuc900_dma_new(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_card *card = rtd->card->snd_card;
@@ -330,7 +325,6 @@ static int nuc900_dma_new(struct snd_soc_pcm_runtime *rtd)
 static struct snd_soc_platform_driver nuc900_soc_platform = {
         .ops            = &nuc900_dma_ops,
         .pcm_new        = nuc900_dma_new,
-        .pcm_free       = nuc900_dma_free_dma_buffers,
 };
 
 static int nuc900_soc_platform_probe(struct platform_device *pdev)
diff --git a/sound/soc/omap/ams-delta.c b/sound/soc/omap/ams-delta.c
index 4c6afb75eea6..706613077c15 100644
--- a/sound/soc/omap/ams-delta.c
+++ b/sound/soc/omap/ams-delta.c
@@ -412,21 +412,7 @@ static struct tty_ldisc_ops cx81801_ops = {
  * over the modem port.
  */
 
-static int ams_delta_hw_params(struct snd_pcm_substream *substream,
-                         struct snd_pcm_hw_params *params)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-
-        /* Set cpu DAI configuration */
-        return snd_soc_dai_set_fmt(rtd->cpu_dai,
-                                   SND_SOC_DAIFMT_DSP_A |
-                                   SND_SOC_DAIFMT_NB_NF |
-                                   SND_SOC_DAIFMT_CBM_CFM);
-}
-
-static struct snd_soc_ops ams_delta_ops = {
-        .hw_params = ams_delta_hw_params,
-};
+static struct snd_soc_ops ams_delta_ops;
 
 
 /* Digital mute implemented using modem/CPU multiplexer.
@@ -546,6 +532,8 @@ static struct snd_soc_dai_link ams_delta_dai_link = {
         .platform_name = "omap-mcbsp.1",
         .codec_name = "cx20442-codec",
         .ops = &ams_delta_ops,
+        .dai_fmt = SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_NB_NF |
+                   SND_SOC_DAIFMT_CBM_CFM,
 };
 
 /* Audio card driver */
diff --git a/sound/soc/omap/omap-hdmi-audio.c b/sound/soc/omap/omap-hdmi-audio.c
index 3f9ac7dbdc80..f7eb42aa3f38 100644
--- a/sound/soc/omap/omap-hdmi-audio.c
+++ b/sound/soc/omap/omap-hdmi-audio.c
@@ -352,6 +352,9 @@ static int omap_hdmi_audio_probe(struct platform_device *pdev)
                 return ret;
 
         card = devm_kzalloc(dev, sizeof(*card), GFP_KERNEL);
+        if (!card)
+                return -ENOMEM;
+
         card->name = devm_kasprintf(dev, GFP_KERNEL,
                                     "HDMI %s", dev_name(ad->dssdev));
         card->owner = THIS_MODULE;
@@ -393,7 +396,6 @@ static int omap_hdmi_audio_remove(struct platform_device *pdev)
 static struct platform_driver hdmi_audio_driver = {
         .driver = {
                 .name = DRV_NAME,
-                .owner = THIS_MODULE,
         },
         .probe = omap_hdmi_audio_probe,
         .remove = omap_hdmi_audio_remove,
diff --git a/sound/soc/omap/omap-mcbsp.c b/sound/soc/omap/omap-mcbsp.c
index c7eb9dd67f60..fd99d89de6a8 100644
--- a/sound/soc/omap/omap-mcbsp.c
+++ b/sound/soc/omap/omap-mcbsp.c
@@ -530,8 +530,19 @@ static int omap_mcbsp_dai_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
 
         case OMAP_MCBSP_SYSCLK_CLKX_EXT:
                 regs->srgr2     |= CLKSM;
+                regs->pcr0      |= SCLKME;
+                /*
+                 * If McBSP is master but yet the CLKX/CLKR pin drives the SRG,
+                 * disable output on those pins. This enables to inject the
+                 * reference clock through CLKX/CLKR. For this to work
+                 * set_dai_sysclk() _needs_ to be called after set_dai_fmt().
+                 */
+                regs->pcr0      &= ~CLKXM;
+                break;
         case OMAP_MCBSP_SYSCLK_CLKR_EXT:
                 regs->pcr0      |= SCLKME;
+                /* Disable ouput on CLKR pin in master mode */
+                regs->pcr0      &= ~CLKRM;
                 break;
         default:
                 err = -ENODEV;
diff --git a/sound/soc/omap/omap-pcm.c b/sound/soc/omap/omap-pcm.c
index f4b05bc23e4b..1343ecbf0bd5 100644
--- a/sound/soc/omap/omap-pcm.c
+++ b/sound/soc/omap/omap-pcm.c
@@ -201,7 +201,7 @@ static int omap_pcm_new(struct snd_soc_pcm_runtime *rtd)
         struct snd_pcm *pcm = rtd->pcm;
         int ret;
 
-        ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(64));
+        ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
         if (ret)
                 return ret;
 
diff --git a/sound/soc/omap/omap-twl4030.c b/sound/soc/omap/omap-twl4030.c
index 5e551c762b7a..fb1f6bb87cd4 100644
--- a/sound/soc/omap/omap-twl4030.c
+++ b/sound/soc/omap/omap-twl4030.c
@@ -53,11 +53,7 @@ static int omap_twl4030_hw_params(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *codec_dai = rtd->codec_dai;
-        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-        struct snd_soc_card *card = rtd->card;
         unsigned int fmt;
-        int ret;
 
         switch (params_channels(params)) {
         case 2: /* Stereo I2S mode */
@@ -74,21 +70,7 @@ static int omap_twl4030_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        /* Set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, fmt);
-        if (ret < 0) {
-                dev_err(card->dev, "can't set codec DAI configuration\n");
-                return ret;
-        }
-
-        /* Set cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, fmt);
-        if (ret < 0) {
-                dev_err(card->dev, "can't set cpu DAI configuration\n");
-                return ret;
-        }
-
-        return 0;
+        return snd_soc_runtime_set_dai_fmt(rtd, fmt);
 }
 
 static struct snd_soc_ops omap_twl4030_ops = {
diff --git a/sound/soc/omap/rx51.c b/sound/soc/omap/rx51.c
index 04896d6252a2..7f299357c2d2 100644
--- a/sound/soc/omap/rx51.c
+++ b/sound/soc/omap/rx51.c
@@ -250,14 +250,14 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"FM Transmitter", NULL, "LLOUT"},
         {"FM Transmitter", NULL, "RLOUT"},
 
-        {"DMic Rate 64", NULL, "Mic Bias"},
-        {"Mic Bias", NULL, "DMic"},
+        {"DMic Rate 64", NULL, "DMic"},
+        {"DMic", NULL, "Mic Bias"},
 
         {"b LINE2R", NULL, "MONO_LOUT"},
         {"Earphone", NULL, "b HPLOUT"},
 
-        {"LINE1L", NULL, "b Mic Bias"},
-        {"b Mic Bias", NULL, "HS Mic"}
+        {"LINE1L", NULL, "HS Mic"},
+        {"HS Mic", NULL, "b Mic Bias"},
 };
 
 static const char * const spk_function[] = {"Off", "On"};
diff --git a/sound/soc/pxa/Kconfig b/sound/soc/pxa/Kconfig
index 2434b6d61675..39cea80846c3 100644
--- a/sound/soc/pxa/Kconfig
+++ b/sound/soc/pxa/Kconfig
@@ -140,7 +140,7 @@ config SND_PXA910_SOC
           Marvell PXA910 reference platform.
 
 config SND_SOC_TTC_DKB
-        bool "SoC Audio support for TTC DKB"
+        tristate "SoC Audio support for TTC DKB"
         depends on SND_PXA910_SOC && MACH_TTC_DKB && I2C=y
         select PXA_SSP
         select SND_PXA_SOC_SSP
diff --git a/sound/soc/pxa/corgi.c b/sound/soc/pxa/corgi.c
index b7cd0a71fd70..3580d10c9f28 100644
--- a/sound/soc/pxa/corgi.c
+++ b/sound/soc/pxa/corgi.c
@@ -259,20 +259,6 @@ static const struct snd_kcontrol_new wm8731_corgi_controls[] = {
                 corgi_set_spk),
 };
 
-/*
- * Logic for a wm8731 as connected on a Sharp SL-C7x0 Device
- */
-static int corgi_wm8731_init(struct snd_soc_pcm_runtime *rtd)
-{
-        struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-
-        snd_soc_dapm_nc_pin(dapm, "LLINEIN");
-        snd_soc_dapm_nc_pin(dapm, "RLINEIN");
-
-        return 0;
-}
-
 /* corgi digital audio interface glue - connects codec <--> CPU */
 static struct snd_soc_dai_link corgi_dai = {
         .name = "WM8731",
@@ -281,7 +267,6 @@ static struct snd_soc_dai_link corgi_dai = {
         .codec_dai_name = "wm8731-hifi",
         .platform_name = "pxa-pcm-audio",
         .codec_name = "wm8731.0-001b",
-        .init = corgi_wm8731_init,
         .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
                    SND_SOC_DAIFMT_CBS_CFS,
         .ops = &corgi_ops,
@@ -300,6 +285,7 @@ static struct snd_soc_card corgi = {
         .num_dapm_widgets = ARRAY_SIZE(wm8731_dapm_widgets),
         .dapm_routes = corgi_audio_map,
         .num_dapm_routes = ARRAY_SIZE(corgi_audio_map),
+        .fully_routed = true,
 };
 
 static int corgi_probe(struct platform_device *pdev)
diff --git a/sound/soc/pxa/e740_wm9705.c b/sound/soc/pxa/e740_wm9705.c
index 7c691aae8af2..d72e124a3676 100644
--- a/sound/soc/pxa/e740_wm9705.c
+++ b/sound/soc/pxa/e740_wm9705.c
@@ -88,24 +88,6 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"Mic Amp", NULL, "Mic (Internal)"},
 };
 
-static int e740_ac97_init(struct snd_soc_pcm_runtime *rtd)
-{
-        struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-
-        snd_soc_dapm_nc_pin(dapm, "HPOUTL");
-        snd_soc_dapm_nc_pin(dapm, "HPOUTR");
-        snd_soc_dapm_nc_pin(dapm, "PHONE");
-        snd_soc_dapm_nc_pin(dapm, "LINEINL");
-        snd_soc_dapm_nc_pin(dapm, "LINEINR");
-        snd_soc_dapm_nc_pin(dapm, "CDINL");
-        snd_soc_dapm_nc_pin(dapm, "CDINR");
-        snd_soc_dapm_nc_pin(dapm, "PCBEEP");
-        snd_soc_dapm_nc_pin(dapm, "MIC2");
-
-        return 0;
-}
-
 static struct snd_soc_dai_link e740_dai[] = {
         {
                 .name = "AC97",
@@ -114,7 +96,6 @@ static struct snd_soc_dai_link e740_dai[] = {
                 .codec_dai_name = "wm9705-hifi",
                 .platform_name = "pxa-pcm-audio",
                 .codec_name = "wm9705-codec",
-                .init = e740_ac97_init,
         },
         {
                 .name = "AC97 Aux",
@@ -136,6 +117,7 @@ static struct snd_soc_card e740 = {
         .num_dapm_widgets = ARRAY_SIZE(e740_dapm_widgets),
         .dapm_routes = audio_map,
         .num_dapm_routes = ARRAY_SIZE(audio_map),
+        .fully_routed = true,
 };
 
 static struct gpio e740_audio_gpios[] = {
diff --git a/sound/soc/pxa/e750_wm9705.c b/sound/soc/pxa/e750_wm9705.c
index 30544b65b5a8..48f2d7c2e68c 100644
--- a/sound/soc/pxa/e750_wm9705.c
+++ b/sound/soc/pxa/e750_wm9705.c
@@ -70,24 +70,6 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"MIC1", NULL, "Mic (Internal)"},
 };
 
-static int e750_ac97_init(struct snd_soc_pcm_runtime *rtd)
-{
-        struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-
-        snd_soc_dapm_nc_pin(dapm, "LOUT");
-        snd_soc_dapm_nc_pin(dapm, "ROUT");
-        snd_soc_dapm_nc_pin(dapm, "PHONE");
-        snd_soc_dapm_nc_pin(dapm, "LINEINL");
-        snd_soc_dapm_nc_pin(dapm, "LINEINR");
-        snd_soc_dapm_nc_pin(dapm, "CDINL");
-        snd_soc_dapm_nc_pin(dapm, "CDINR");
-        snd_soc_dapm_nc_pin(dapm, "PCBEEP");
-        snd_soc_dapm_nc_pin(dapm, "MIC2");
-
-        return 0;
-}
-
 static struct snd_soc_dai_link e750_dai[] = {
         {
                 .name = "AC97",
@@ -96,7 +78,6 @@ static struct snd_soc_dai_link e750_dai[] = {
                 .codec_dai_name = "wm9705-hifi",
                 .platform_name = "pxa-pcm-audio",
                 .codec_name = "wm9705-codec",
-                .init = e750_ac97_init,
                 /* use ops to check startup state */
         },
         {
@@ -119,6 +100,7 @@ static struct snd_soc_card e750 = {
         .num_dapm_widgets = ARRAY_SIZE(e750_dapm_widgets),
         .dapm_routes = audio_map,
         .num_dapm_routes = ARRAY_SIZE(audio_map),
+        .fully_routed = true,
 };
 
 static struct gpio e750_audio_gpios[] = {
diff --git a/sound/soc/pxa/hx4700.c b/sound/soc/pxa/hx4700.c
index ce26551052a3..73eb5ddf9753 100644
--- a/sound/soc/pxa/hx4700.c
+++ b/sound/soc/pxa/hx4700.c
@@ -127,15 +127,8 @@ static const struct snd_soc_dapm_route hx4700_audio_map[] = {
 static int hx4700_ak4641_init(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
         int err;
 
-        /* NC codec pins */
-        /* FIXME: is anything connected here? */
-        snd_soc_dapm_nc_pin(dapm, "MOUT1");
-        snd_soc_dapm_nc_pin(dapm, "MICEXT");
-        snd_soc_dapm_nc_pin(dapm, "AUX");
-
         /* Jack detection API stuff */
         err = snd_soc_jack_new(codec, "Headphone Jack",
                                 SND_JACK_HEADPHONE, &hs_jack);
@@ -184,6 +177,7 @@ static struct snd_soc_card snd_soc_card_hx4700 = {
         .num_dapm_widgets       = ARRAY_SIZE(hx4700_dapm_widgets),
         .dapm_routes            = hx4700_audio_map,
         .num_dapm_routes        = ARRAY_SIZE(hx4700_audio_map),
+        .fully_routed           = true,
 };
 
 static struct gpio hx4700_audio_gpios[] = {
diff --git a/sound/soc/pxa/magician.c b/sound/soc/pxa/magician.c
index 259e048681c0..241d0be42d7a 100644
--- a/sound/soc/pxa/magician.c
+++ b/sound/soc/pxa/magician.c
@@ -391,25 +391,6 @@ static const struct snd_kcontrol_new uda1380_magician_controls[] = {
                         magician_get_input, magician_set_input),
 };
 
-/*
- * Logic for a uda1380 as connected on a HTC Magician
- */
-static int magician_uda1380_init(struct snd_soc_pcm_runtime *rtd)
-{
-        struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-
-        /* NC codec pins */
-        snd_soc_dapm_nc_pin(dapm, "VOUTLHP");
-        snd_soc_dapm_nc_pin(dapm, "VOUTRHP");
-
-        /* FIXME: is anything connected here? */
-        snd_soc_dapm_nc_pin(dapm, "VINL");
-        snd_soc_dapm_nc_pin(dapm, "VINR");
-
-        return 0;
-}
-
 /* magician digital audio interface glue - connects codec <--> CPU */
 static struct snd_soc_dai_link magician_dai[] = {
 {
@@ -419,7 +400,6 @@ static struct snd_soc_dai_link magician_dai[] = {
         .codec_dai_name = "uda1380-hifi-playback",
         .platform_name = "pxa-pcm-audio",
         .codec_name = "uda1380-codec.0-0018",
-        .init = magician_uda1380_init,
         .ops = &magician_playback_ops,
 },
 {
@@ -446,6 +426,7 @@ static struct snd_soc_card snd_soc_card_magician = {
         .num_dapm_widgets = ARRAY_SIZE(uda1380_dapm_widgets),
         .dapm_routes = audio_map,
         .num_dapm_routes = ARRAY_SIZE(audio_map),
+        .fully_routed = true,
 };
 
 static struct platform_device *magician_snd_device;
diff --git a/sound/soc/pxa/mioa701_wm9713.c b/sound/soc/pxa/mioa701_wm9713.c
index 396dbd51a64f..a9615a574546 100644
--- a/sound/soc/pxa/mioa701_wm9713.c
+++ b/sound/soc/pxa/mioa701_wm9713.c
@@ -81,7 +81,7 @@ static int rear_amp_power(struct snd_soc_codec *codec, int power)
 static int rear_amp_event(struct snd_soc_dapm_widget *widget,
                           struct snd_kcontrol *kctl, int event)
 {
-        struct snd_soc_codec *codec = widget->codec;
+        struct snd_soc_codec *codec = widget->dapm->card->rtd[0].codec;
 
         return rear_amp_power(codec, SND_SOC_DAPM_EVENT_ON(event));
 }
diff --git a/sound/soc/pxa/palm27x.c b/sound/soc/pxa/palm27x.c
index 1eebca2f0a97..910336c5ebeb 100644
--- a/sound/soc/pxa/palm27x.c
+++ b/sound/soc/pxa/palm27x.c
@@ -68,7 +68,7 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"Ext. Speaker", NULL, "ROUT2"},
 
         /* mic connected to MIC1 */
-        {"Ext. Microphone", NULL, "MIC1"},
+        {"MIC1", NULL, "Ext. Microphone"},
 };
 
 static struct snd_soc_card palm27x_asoc;
@@ -76,18 +76,8 @@ static struct snd_soc_card palm27x_asoc;
 static int palm27x_ac97_init(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
         int err;
 
-        /* not connected pins */
-        snd_soc_dapm_nc_pin(dapm, "OUT3");
-        snd_soc_dapm_nc_pin(dapm, "MONOOUT");
-        snd_soc_dapm_nc_pin(dapm, "LINEINL");
-        snd_soc_dapm_nc_pin(dapm, "LINEINR");
-        snd_soc_dapm_nc_pin(dapm, "PCBEEP");
-        snd_soc_dapm_nc_pin(dapm, "PHONE");
-        snd_soc_dapm_nc_pin(dapm, "MIC2");
-
         /* Jack detection API stuff */
         err = snd_soc_jack_new(codec, "Headphone Jack",
                                 SND_JACK_HEADPHONE, &hs_jack);
@@ -133,7 +123,8 @@ static struct snd_soc_card palm27x_asoc = {
         .dapm_widgets = palm27x_dapm_widgets,
         .num_dapm_widgets = ARRAY_SIZE(palm27x_dapm_widgets),
         .dapm_routes = audio_map,
-        .num_dapm_routes = ARRAY_SIZE(audio_map)
+        .num_dapm_routes = ARRAY_SIZE(audio_map),
+        .fully_routed = true,
 };
 
 static int palm27x_asoc_probe(struct platform_device *pdev)
diff --git a/sound/soc/pxa/raumfeld.c b/sound/soc/pxa/raumfeld.c
index 083706595495..552b763005ed 100644
--- a/sound/soc/pxa/raumfeld.c
+++ b/sound/soc/pxa/raumfeld.c
@@ -88,7 +88,7 @@ static int raumfeld_cs4270_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *codec_dai = rtd->codec_dai;
         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-        unsigned int fmt, clk = 0;
+        unsigned int clk = 0;
         int ret = 0;
 
         switch (params_rate(params)) {
@@ -112,15 +112,6 @@ static int raumfeld_cs4270_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        fmt = SND_SOC_DAIFMT_I2S |
-              SND_SOC_DAIFMT_NB_NF |
-              SND_SOC_DAIFMT_CBS_CFS;
-
-        /* setup the CODEC DAI */
-        ret = snd_soc_dai_set_fmt(codec_dai, fmt);
-        if (ret < 0)
-                return ret;
-
         ret = snd_soc_dai_set_sysclk(codec_dai, 0, clk, 0);
         if (ret < 0)
                 return ret;
@@ -130,10 +121,6 @@ static int raumfeld_cs4270_hw_params(struct snd_pcm_substream *substream,
         if (ret < 0)
                 return ret;
 
-        ret = snd_soc_dai_set_fmt(cpu_dai, fmt);
-        if (ret < 0)
-                return ret;
-
         ret = snd_soc_dai_set_clkdiv(cpu_dai, PXA_SSP_DIV_SCR, 4);
         if (ret < 0)
                 return ret;
@@ -169,9 +156,8 @@ static int raumfeld_ak4104_hw_params(struct snd_pcm_substream *substream,
                                      struct snd_pcm_hw_params *params)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *codec_dai = rtd->codec_dai;
         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-        int fmt, ret = 0, clk = 0;
+        int ret = 0, clk = 0;
 
         switch (params_rate(params)) {
         case 44100:
@@ -194,22 +180,11 @@ static int raumfeld_ak4104_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF;
-
-        /* setup the CODEC DAI */
-        ret = snd_soc_dai_set_fmt(codec_dai, fmt | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         /* setup the CPU DAI */
         ret = snd_soc_dai_set_pll(cpu_dai, 0, 0, 0, clk);
         if (ret < 0)
                 return ret;
 
-        ret = snd_soc_dai_set_fmt(cpu_dai, fmt | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         ret = snd_soc_dai_set_clkdiv(cpu_dai, PXA_SSP_DIV_SCR, 4);
         if (ret < 0)
                 return ret;
@@ -233,6 +208,9 @@ static struct snd_soc_ops raumfeld_ak4104_ops = {
         .platform_name  = "pxa-pcm-audio",              \
         .codec_dai_name = "cs4270-hifi",                \
         .codec_name     = "cs4270.0-0048",      \
+        .dai_fmt        = SND_SOC_DAIFMT_I2S |          \
+                          SND_SOC_DAIFMT_NB_NF |        \
+                          SND_SOC_DAIFMT_CBS_CFS,       \
         .ops            = &raumfeld_cs4270_ops,         \
 }
 
@@ -243,6 +221,9 @@ static struct snd_soc_ops raumfeld_ak4104_ops = {
         .cpu_dai_name   = "pxa-ssp-dai.1",              \
         .codec_dai_name = "ak4104-hifi",                \
         .platform_name  = "pxa-pcm-audio",              \
+        .dai_fmt        = SND_SOC_DAIFMT_I2S |          \
+                          SND_SOC_DAIFMT_NB_NF |        \
+                          SND_SOC_DAIFMT_CBS_CFS,       \
         .ops            = &raumfeld_ak4104_ops,         \
         .codec_name     = "spi0.0",                     \
 }
diff --git a/sound/soc/pxa/spitz.c b/sound/soc/pxa/spitz.c
index d7d5fb20ea6f..461123ad5ff2 100644
--- a/sound/soc/pxa/spitz.c
+++ b/sound/soc/pxa/spitz.c
@@ -256,26 +256,6 @@ static const struct snd_kcontrol_new wm8750_spitz_controls[] = {
                 spitz_set_spk),
 };
 
-/*
- * Logic for a wm8750 as connected on a Sharp SL-Cxx00 Device
- */
-static int spitz_wm8750_init(struct snd_soc_pcm_runtime *rtd)
-{
-        struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-
-        /* NC codec pins */
-        snd_soc_dapm_nc_pin(dapm, "RINPUT1");
-        snd_soc_dapm_nc_pin(dapm, "LINPUT2");
-        snd_soc_dapm_nc_pin(dapm, "RINPUT2");
-        snd_soc_dapm_nc_pin(dapm, "LINPUT3");
-        snd_soc_dapm_nc_pin(dapm, "RINPUT3");
-        snd_soc_dapm_nc_pin(dapm, "OUT3");
-        snd_soc_dapm_nc_pin(dapm, "MONO1");
-
-        return 0;
-}
-
 /* spitz digital audio interface glue - connects codec <--> CPU */
 static struct snd_soc_dai_link spitz_dai = {
         .name = "wm8750",
@@ -284,7 +264,6 @@ static struct snd_soc_dai_link spitz_dai = {
         .codec_dai_name = "wm8750-hifi",
         .platform_name = "pxa-pcm-audio",
         .codec_name = "wm8750.0-001b",
-        .init = spitz_wm8750_init,
         .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
                    SND_SOC_DAIFMT_CBS_CFS,
         .ops = &spitz_ops,
@@ -303,6 +282,7 @@ static struct snd_soc_card snd_soc_spitz = {
         .num_dapm_widgets = ARRAY_SIZE(wm8750_dapm_widgets),
         .dapm_routes = spitz_audio_map,
         .num_dapm_routes = ARRAY_SIZE(spitz_audio_map),
+        .fully_routed = true,
 };
 
 static int spitz_probe(struct platform_device *pdev)
@@ -352,7 +332,6 @@ static int spitz_remove(struct platform_device *pdev)
 static struct platform_driver spitz_driver = {
         .driver         = {
                 .name   = "spitz-audio",
-                .owner  = THIS_MODULE,
                 .pm     = &snd_soc_pm_ops,
         },
         .probe          = spitz_probe,
diff --git a/sound/soc/pxa/ttc-dkb.c b/sound/soc/pxa/ttc-dkb.c
index e3d7257ad09c..5001dbb9b257 100644
--- a/sound/soc/pxa/ttc-dkb.c
+++ b/sound/soc/pxa/ttc-dkb.c
@@ -76,10 +76,6 @@ static const struct snd_soc_dapm_route ttc_audio_map[] = {
 static int ttc_pm860x_init(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-
-        snd_soc_dapm_disable_pin(dapm, "Headset Mic 2");
-        snd_soc_dapm_disable_pin(dapm, "Headset Stereophone");
 
         /* Headset jack detection */
         snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE
diff --git a/sound/soc/pxa/zylonite.c b/sound/soc/pxa/zylonite.c
index 23bf991e95d5..8f301c72ee5e 100644
--- a/sound/soc/pxa/zylonite.c
+++ b/sound/soc/pxa/zylonite.c
@@ -130,16 +130,6 @@ static int zylonite_voice_hw_params(struct snd_pcm_substream *substream,
         if (ret < 0)
                 return ret;
 
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
-                SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
-                SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         return 0;
 }
 
@@ -172,6 +162,8 @@ static struct snd_soc_dai_link zylonite_dai[] = {
         .platform_name = "pxa-pcm-audio",
         .cpu_dai_name = "pxa-ssp-dai.2",
         .codec_dai_name = "wm9713-voice",
+        .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                   SND_SOC_DAIFMT_CBS_CFS,
         .ops = &zylonite_voice_ops,
 },
 };
diff --git a/sound/soc/rockchip/rockchip_i2s.c b/sound/soc/rockchip/rockchip_i2s.c
index dcc26eda0539..acb5be53bfb4 100644
--- a/sound/soc/rockchip/rockchip_i2s.c
+++ b/sound/soc/rockchip/rockchip_i2s.c
@@ -247,6 +247,10 @@ static int rockchip_i2s_hw_params(struct snd_pcm_substream *substream,
 
         regmap_update_bits(i2s->regmap, I2S_TXCR, I2S_TXCR_VDW_MASK, val);
         regmap_update_bits(i2s->regmap, I2S_RXCR, I2S_RXCR_VDW_MASK, val);
+        regmap_update_bits(i2s->regmap, I2S_DMACR, I2S_DMACR_TDL_MASK,
+                           I2S_DMACR_TDL(16));
+        regmap_update_bits(i2s->regmap, I2S_DMACR, I2S_DMACR_RDL_MASK,
+                           I2S_DMACR_RDL(16));
 
         return 0;
 }
diff --git a/sound/soc/samsung/Kconfig b/sound/soc/samsung/Kconfig
index e0c4a4ec4280..0632a36852c8 100644
--- a/sound/soc/samsung/Kconfig
+++ b/sound/soc/samsung/Kconfig
@@ -54,7 +54,7 @@ config SND_SOC_SAMSUNG_JIVE_WM8750
 config SND_SOC_SAMSUNG_SMDK_WM8580
         tristate "SoC I2S Audio support for WM8580 on SMDK"
         depends on SND_SOC_SAMSUNG && (MACH_SMDK6410 || MACH_SMDKC100 || MACH_SMDKV210 || MACH_SMDKC110)
-        depends on REGMAP_I2C
+        depends on I2C
         select SND_SOC_WM8580
         select SND_SAMSUNG_I2S
         help
@@ -146,17 +146,6 @@ config SND_SOC_SMARTQ
         select SND_SAMSUNG_I2S
         select SND_SOC_WM8750
 
-config SND_SOC_GONI_AQUILA_WM8994
-        tristate "SoC I2S Audio support for AQUILA/GONI - WM8994"
-        depends on SND_SOC_SAMSUNG && (MACH_GONI || MACH_AQUILA)
-        depends on I2C=y
-        select SND_SAMSUNG_I2S
-        select MFD_WM8994
-        select SND_SOC_WM8994
-        help
-          Say Y if you want to add support for SoC audio on goni or aquila
-          with the WM8994.
-
 config SND_SOC_SAMSUNG_SMDK_SPDIF
         tristate "SoC S/PDIF Audio support for SMDK"
         depends on SND_SOC_SAMSUNG
@@ -167,7 +156,7 @@ config SND_SOC_SAMSUNG_SMDK_SPDIF
 config SND_SOC_SMDK_WM8580_PCM
         tristate "SoC PCM Audio support for WM8580 on SMDK"
         depends on SND_SOC_SAMSUNG && (MACH_SMDKV210 || MACH_SMDKC110)
-        depends on REGMAP_I2C
+        depends on I2C
         select SND_SOC_WM8580
         select SND_SAMSUNG_PCM
         help
diff --git a/sound/soc/samsung/Makefile b/sound/soc/samsung/Makefile
index 31e3dba7e3b5..052fe71be518 100644
--- a/sound/soc/samsung/Makefile
+++ b/sound/soc/samsung/Makefile
@@ -35,7 +35,6 @@ snd-soc-smdk-wm8994-objs := smdk_wm8994.o
 snd-soc-snow-objs := snow.o
 snd-soc-smdk-wm9713-objs := smdk_wm9713.o
 snd-soc-s3c64xx-smartq-wm8987-objs := smartq_wm8987.o
-snd-soc-goni-wm8994-objs := goni_wm8994.o
 snd-soc-smdk-spdif-objs := smdk_spdif.o
 snd-soc-smdk-wm8580pcm-objs := smdk_wm8580pcm.o
 snd-soc-smdk-wm8994pcm-objs := smdk_wm8994pcm.o
@@ -63,7 +62,6 @@ obj-$(CONFIG_SND_SOC_SNOW) += snd-soc-snow.o
 obj-$(CONFIG_SND_SOC_SAMSUNG_SMDK_WM9713) += snd-soc-smdk-wm9713.o
 obj-$(CONFIG_SND_SOC_SMARTQ) += snd-soc-s3c64xx-smartq-wm8987.o
 obj-$(CONFIG_SND_SOC_SAMSUNG_SMDK_SPDIF) += snd-soc-smdk-spdif.o
-obj-$(CONFIG_SND_SOC_GONI_AQUILA_WM8994) += snd-soc-goni-wm8994.o
 obj-$(CONFIG_SND_SOC_SMDK_WM8580_PCM) += snd-soc-smdk-wm8580pcm.o
 obj-$(CONFIG_SND_SOC_SMDK_WM8994_PCM) += snd-soc-smdk-wm8994pcm.o
 obj-$(CONFIG_SND_SOC_SPEYSIDE) += snd-soc-speyside.o
diff --git a/sound/soc/samsung/arndale_rt5631.c b/sound/soc/samsung/arndale_rt5631.c
index 1e2b61ca8db2..8bf2e2c4bafb 100644
--- a/sound/soc/samsung/arndale_rt5631.c
+++ b/sound/soc/samsung/arndale_rt5631.c
@@ -135,7 +135,6 @@ MODULE_DEVICE_TABLE(of, samsung_arndale_rt5631_of_match);
 static struct platform_driver arndale_audio_driver = {
         .driver = {
                 .name   = "arndale-audio",
-                .owner  = THIS_MODULE,
                 .pm = &snd_soc_pm_ops,
                 .of_match_table = of_match_ptr(samsung_arndale_rt5631_of_match),
         },
diff --git a/sound/soc/samsung/goni_wm8994.c b/sound/soc/samsung/goni_wm8994.c
deleted file mode 100644
index 3b527dcfc0aa..000000000000
--- a/sound/soc/samsung/goni_wm8994.c
+++ /dev/null
@@ -1,304 +0,0 @@
-/*
- * goni_wm8994.c
- *
- * Copyright (C) 2010 Samsung Electronics Co.Ltd
- * Author: Chanwoo Choi <cw00.choi@samsung.com>
- *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
- */
-
-#include <linux/module.h>
-#include <sound/soc.h>
-#include <sound/jack.h>
-
-#include <asm/mach-types.h>
-#include <mach/gpio-samsung.h>
-
-#include "../codecs/wm8994.h"
-
-#define MACHINE_NAME    0
-#define CPU_VOICE_DAI   1
-
-static const char *aquila_str[] = {
-        [MACHINE_NAME] = "aquila",
-        [CPU_VOICE_DAI] = "aquila-voice-dai",
-};
-
-static struct snd_soc_card goni;
-static struct platform_device *goni_snd_device;
-
-/* 3.5 pie jack */
-static struct snd_soc_jack jack;
-
-/* 3.5 pie jack detection DAPM pins */
-static struct snd_soc_jack_pin jack_pins[] = {
-        {
-                .pin = "Headset Mic",
-                .mask = SND_JACK_MICROPHONE,
-        }, {
-                .pin = "Headset Stereophone",
-                .mask = SND_JACK_HEADPHONE | SND_JACK_MECHANICAL |
-                        SND_JACK_AVOUT,
-        },
-};
-
-/* 3.5 pie jack detection gpios */
-static struct snd_soc_jack_gpio jack_gpios[] = {
-        {
-                .gpio = S5PV210_GPH0(6),
-                .name = "DET_3.5",
-                .report = SND_JACK_HEADSET | SND_JACK_MECHANICAL |
-                        SND_JACK_AVOUT,
-                .debounce_time = 200,
-        },
-};
-
-static const struct snd_soc_dapm_widget goni_dapm_widgets[] = {
-        SND_SOC_DAPM_SPK("Ext Left Spk", NULL),
-        SND_SOC_DAPM_SPK("Ext Right Spk", NULL),
-        SND_SOC_DAPM_SPK("Ext Rcv", NULL),
-        SND_SOC_DAPM_HP("Headset Stereophone", NULL),
-        SND_SOC_DAPM_MIC("Headset Mic", NULL),
-        SND_SOC_DAPM_MIC("Main Mic", NULL),
-        SND_SOC_DAPM_MIC("2nd Mic", NULL),
-        SND_SOC_DAPM_LINE("Radio In", NULL),
-};
-
-static const struct snd_soc_dapm_route goni_dapm_routes[] = {
-        {"Ext Left Spk", NULL, "SPKOUTLP"},
-        {"Ext Left Spk", NULL, "SPKOUTLN"},
-
-        {"Ext Right Spk", NULL, "SPKOUTRP"},
-        {"Ext Right Spk", NULL, "SPKOUTRN"},
-
-        {"Ext Rcv", NULL, "HPOUT2N"},
-        {"Ext Rcv", NULL, "HPOUT2P"},
-
-        {"Headset Stereophone", NULL, "HPOUT1L"},
-        {"Headset Stereophone", NULL, "HPOUT1R"},
-
-        {"IN1RN", NULL, "Headset Mic"},
-        {"IN1RP", NULL, "Headset Mic"},
-
-        {"IN1RN", NULL, "2nd Mic"},
-        {"IN1RP", NULL, "2nd Mic"},
-
-        {"IN1LN", NULL, "Main Mic"},
-        {"IN1LP", NULL, "Main Mic"},
-
-        {"IN2LN", NULL, "Radio In"},
-        {"IN2RN", NULL, "Radio In"},
-};
-
-static int goni_wm8994_init(struct snd_soc_pcm_runtime *rtd)
-{
-        struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-        int ret;
-
-        /* set endpoints to not connected */
-        snd_soc_dapm_nc_pin(dapm, "IN2LP:VXRN");
-        snd_soc_dapm_nc_pin(dapm, "IN2RP:VXRP");
-        snd_soc_dapm_nc_pin(dapm, "LINEOUT1N");
-        snd_soc_dapm_nc_pin(dapm, "LINEOUT1P");
-        snd_soc_dapm_nc_pin(dapm, "LINEOUT2N");
-        snd_soc_dapm_nc_pin(dapm, "LINEOUT2P");
-
-        if (machine_is_aquila()) {
-                snd_soc_dapm_nc_pin(dapm, "SPKOUTRN");
-                snd_soc_dapm_nc_pin(dapm, "SPKOUTRP");
-        }
-
-        /* Headset jack detection */
-        ret = snd_soc_jack_new(codec, "Headset Jack",
-                        SND_JACK_HEADSET | SND_JACK_MECHANICAL | SND_JACK_AVOUT,
-                        &jack);
-        if (ret)
-                return ret;
-
-        ret = snd_soc_jack_add_pins(&jack, ARRAY_SIZE(jack_pins), jack_pins);
-        if (ret)
-                return ret;
-
-        ret = snd_soc_jack_add_gpios(&jack, ARRAY_SIZE(jack_gpios), jack_gpios);
-        if (ret)
-                return ret;
-
-        return 0;
-}
-
-static int goni_hifi_hw_params(struct snd_pcm_substream *substream,
-                struct snd_pcm_hw_params *params)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *codec_dai = rtd->codec_dai;
-        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-        unsigned int pll_out = 24000000;
-        int ret = 0;
-
-        /* set the cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
-                        SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                return ret;
-
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
-                        SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                return ret;
-
-        /* set the codec FLL */
-        ret = snd_soc_dai_set_pll(codec_dai, WM8994_FLL1, 0, pll_out,
-                        params_rate(params) * 256);
-        if (ret < 0)
-                return ret;
-
-        /* set the codec system clock */
-        ret = snd_soc_dai_set_sysclk(codec_dai, WM8994_SYSCLK_FLL1,
-                        params_rate(params) * 256, SND_SOC_CLOCK_IN);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-static struct snd_soc_ops goni_hifi_ops = {
-        .hw_params = goni_hifi_hw_params,
-};
-
-static int goni_voice_hw_params(struct snd_pcm_substream *substream,
-                struct snd_pcm_hw_params *params)
-{
-        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *codec_dai = rtd->codec_dai;
-        unsigned int pll_out = 24000000;
-        int ret = 0;
-
-        if (params_rate(params) != 8000)
-                return -EINVAL;
-
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_LEFT_J |
-                        SND_SOC_DAIFMT_IB_IF | SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                return ret;
-
-        /* set the codec FLL */
-        ret = snd_soc_dai_set_pll(codec_dai, WM8994_FLL2, 0, pll_out,
-                        params_rate(params) * 256);
-        if (ret < 0)
-                return ret;
-
-        /* set the codec system clock */
-        ret = snd_soc_dai_set_sysclk(codec_dai, WM8994_SYSCLK_FLL2,
-                        params_rate(params) * 256, SND_SOC_CLOCK_IN);
-        if (ret < 0)
-                return ret;
-
-        return 0;
-}
-
-static struct snd_soc_dai_driver voice_dai = {
-        .name = "goni-voice-dai",
-        .id = 0,
-        .playback = {
-                .channels_min = 1,
-                .channels_max = 2,
-                .rates = SNDRV_PCM_RATE_8000,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
-        .capture = {
-                .channels_min = 1,
-                .channels_max = 2,
-                .rates = SNDRV_PCM_RATE_8000,
-                .formats = SNDRV_PCM_FMTBIT_S16_LE,},
-};
-
-static const struct snd_soc_component_driver voice_component = {
-        .name           = "goni-voice",
-};
-
-static struct snd_soc_ops goni_voice_ops = {
-        .hw_params = goni_voice_hw_params,
-};
-
-static struct snd_soc_dai_link goni_dai[] = {
-{
-        .name = "WM8994",
-        .stream_name = "WM8994 HiFi",
-        .cpu_dai_name = "samsung-i2s.0",
-        .codec_dai_name = "wm8994-aif1",
-        .platform_name = "samsung-i2s.0",
-        .codec_name = "wm8994-codec.0-001a",
-        .init = goni_wm8994_init,
-        .ops = &goni_hifi_ops,
-}, {
-        .name = "WM8994 Voice",
-        .stream_name = "Voice",
-        .cpu_dai_name = "goni-voice-dai",
-        .codec_dai_name = "wm8994-aif2",
-        .codec_name = "wm8994-codec.0-001a",
-        .ops = &goni_voice_ops,
-},
-};
-
-static struct snd_soc_card goni = {
-        .name = "goni",
-        .owner = THIS_MODULE,
-        .dai_link = goni_dai,
-        .num_links = ARRAY_SIZE(goni_dai),
-
-        .dapm_widgets = goni_dapm_widgets,
-        .num_dapm_widgets = ARRAY_SIZE(goni_dapm_widgets),
-        .dapm_routes = goni_dapm_routes,
-        .num_dapm_routes = ARRAY_SIZE(goni_dapm_routes),
-};
-
-static int __init goni_init(void)
-{
-        int ret;
-
-        if (machine_is_aquila()) {
-                voice_dai.name = aquila_str[CPU_VOICE_DAI];
-                goni_dai[1].cpu_dai_name = aquila_str[CPU_VOICE_DAI];
-                goni.name = aquila_str[MACHINE_NAME];
-        } else if (!machine_is_goni())
-                return -ENODEV;
-
-        goni_snd_device = platform_device_alloc("soc-audio", -1);
-        if (!goni_snd_device)
-                return -ENOMEM;
-
-        /* register voice DAI here */
-        ret = devm_snd_soc_register_component(&goni_snd_device->dev,
-                        &voice_component, &voice_dai, 1);
-        if (ret) {
-                platform_device_put(goni_snd_device);
-                return ret;
-        }
-
-        platform_set_drvdata(goni_snd_device, &goni);
-        ret = platform_device_add(goni_snd_device);
-
-        if (ret)
-                platform_device_put(goni_snd_device);
-
-        return ret;
-}
-
-static void __exit goni_exit(void)
-{
-        platform_device_unregister(goni_snd_device);
-}
-
-module_init(goni_init);
-module_exit(goni_exit);
-
-/* Module information */
-MODULE_DESCRIPTION("ALSA SoC WM8994 GONI(S5PV210)");
-MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>");
-MODULE_LICENSE("GPL");
diff --git a/sound/soc/samsung/h1940_uda1380.c b/sound/soc/samsung/h1940_uda1380.c
index f2d7980d7ddc..59b044255b78 100644
--- a/sound/soc/samsung/h1940_uda1380.c
+++ b/sound/soc/samsung/h1940_uda1380.c
@@ -76,7 +76,6 @@ static int h1940_hw_params(struct snd_pcm_substream *substream,
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-        struct snd_soc_dai *codec_dai = rtd->codec_dai;
         int div;
         int ret;
         unsigned int rate = params_rate(params);
@@ -95,18 +94,6 @@ static int h1940_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
-                SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
-        /* set cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
-                SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         /* select clock source */
         ret = snd_soc_dai_set_sysclk(cpu_dai, S3C24XX_CLKSRC_PCLK, rate,
                         SND_SOC_CLOCK_OUT);
@@ -207,6 +194,8 @@ static struct snd_soc_dai_link h1940_uda1380_dai[] = {
                 .init           = h1940_uda1380_init,
                 .platform_name  = "s3c24xx-iis",
                 .codec_name     = "uda1380-codec.0-001a",
+                .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                                  SND_SOC_DAIFMT_CBS_CFS,
                 .ops            = &h1940_ops,
         },
 };
diff --git a/sound/soc/samsung/i2s.c b/sound/soc/samsung/i2s.c
index b5a80c528d86..b92ab40d2be6 100644
--- a/sound/soc/samsung/i2s.c
+++ b/sound/soc/samsung/i2s.c
@@ -10,9 +10,11 @@
  * published by the Free Software Foundation.
  */
 
+#include <dt-bindings/sound/samsung-i2s.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/clk.h>
+#include <linux/clk-provider.h>
 #include <linux/io.h>
 #include <linux/module.h>
 #include <linux/of.h>
@@ -59,10 +61,8 @@ struct samsung_i2s_dai_data {
 struct i2s_dai {
         /* Platform device for this DAI */
         struct platform_device *pdev;
-        /* IOREMAP'd SFRs */
+        /* Memory mapped SFR region */
         void __iomem    *addr;
-        /* Physical base address of SFRs */
-        u32     base;
         /* Rate of RCLK source clock */
         unsigned long rclk_srcrate;
         /* Frame Clock */
@@ -83,8 +83,6 @@ struct i2s_dai {
 #define DAI_OPENED      (1 << 0) /* Dai is opened */
 #define DAI_MANAGER     (1 << 1) /* Dai is the manager */
         unsigned mode;
-        /* CDCLK pin direction: 0  - input, 1 - output */
-        unsigned int cdclk_out:1;
         /* Driver for this DAI */
         struct snd_soc_dai_driver i2s_dai_drv;
         /* DMA parameters */
@@ -95,8 +93,15 @@ struct i2s_dai {
         u32     suspend_i2smod;
         u32     suspend_i2scon;
         u32     suspend_i2spsr;
-        unsigned long gpios[7]; /* i2s gpio line numbers */
         const struct samsung_i2s_variant_regs *variant_regs;
+
+        /* Spinlock protecting access to the device's registers */
+        spinlock_t spinlock;
+        spinlock_t *lock;
+
+        /* Below fields are only valid if this is the primary FIFO */
+        struct clk *clk_table[3];
+        struct clk_onecell_data clk_data;
 };
 
 /* Lock for cross i/f checks */
@@ -133,10 +138,16 @@ static inline bool tx_active(struct i2s_dai *i2s)
         return active ? true : false;
 }
 
+/* Return pointer to the other DAI */
+static inline struct i2s_dai *get_other_dai(struct i2s_dai *i2s)
+{
+        return i2s->pri_dai ? : i2s->sec_dai;
+}
+
 /* If the other interface of the controller is transmitting data */
 static inline bool other_tx_active(struct i2s_dai *i2s)
 {
-        struct i2s_dai *other = i2s->pri_dai ? : i2s->sec_dai;
+        struct i2s_dai *other = get_other_dai(i2s);
 
         return tx_active(other);
 }
@@ -163,7 +174,7 @@ static inline bool rx_active(struct i2s_dai *i2s)
 /* If the other interface of the controller is receiving data */
 static inline bool other_rx_active(struct i2s_dai *i2s)
 {
-        struct i2s_dai *other = i2s->pri_dai ? : i2s->sec_dai;
+        struct i2s_dai *other = get_other_dai(i2s);
 
         return rx_active(other);
 }
@@ -464,18 +475,23 @@ static int i2s_set_sysclk(struct snd_soc_dai *dai,
           int clk_id, unsigned int rfs, int dir)
 {
         struct i2s_dai *i2s = to_info(dai);
-        struct i2s_dai *other = i2s->pri_dai ? : i2s->sec_dai;
-        u32 mod = readl(i2s->addr + I2SMOD);
+        struct i2s_dai *other = get_other_dai(i2s);
         const struct samsung_i2s_variant_regs *i2s_regs = i2s->variant_regs;
         unsigned int cdcon_mask = 1 << i2s_regs->cdclkcon_off;
         unsigned int rsrc_mask = 1 << i2s_regs->rclksrc_off;
+        u32 mod, mask, val = 0;
+
+        spin_lock(i2s->lock);
+        mod = readl(i2s->addr + I2SMOD);
+        spin_unlock(i2s->lock);
 
         switch (clk_id) {
         case SAMSUNG_I2S_OPCLK:
-                mod &= ~MOD_OPCLK_MASK;
-                mod |= dir;
+                mask = MOD_OPCLK_MASK;
+                val = dir;
                 break;
         case SAMSUNG_I2S_CDCLK:
+                mask = 1 << i2s_regs->cdclkcon_off;
                 /* Shouldn't matter in GATING(CLOCK_IN) mode */
                 if (dir == SND_SOC_CLOCK_IN)
                         rfs = 0;
@@ -492,15 +508,15 @@ static int i2s_set_sysclk(struct snd_soc_dai *dai,
                 }
 
                 if (dir == SND_SOC_CLOCK_IN)
-                        mod |= 1 << i2s_regs->cdclkcon_off;
-                else
-                        mod &= ~(1 << i2s_regs->cdclkcon_off);
+                        val = 1 << i2s_regs->cdclkcon_off;
 
                 i2s->rfs = rfs;
                 break;
 
         case SAMSUNG_I2S_RCLKSRC_0: /* clock corrsponding to IISMOD[10] := 0 */
         case SAMSUNG_I2S_RCLKSRC_1: /* clock corrsponding to IISMOD[10] := 1 */
+                mask = 1 << i2s_regs->rclksrc_off;
+
                 if ((i2s->quirks & QUIRK_NO_MUXPSR)
                                 || (clk_id == SAMSUNG_I2S_RCLKSRC_0))
                         clk_id = 0;
@@ -550,18 +566,19 @@ static int i2s_set_sysclk(struct snd_soc_dai *dai,
                         return 0;
                 }
 
-                if (clk_id == 0)
-                        mod &= ~(1 << i2s_regs->rclksrc_off);
-                else
-                        mod |= 1 << i2s_regs->rclksrc_off;
-
+                if (clk_id == 1)
+                        val = 1 << i2s_regs->rclksrc_off;
                 break;
         default:
                 dev_err(&i2s->pdev->dev, "We don't serve that!\n");
                 return -EINVAL;
         }
 
+        spin_lock(i2s->lock);
+        mod = readl(i2s->addr + I2SMOD);
+        mod = (mod & ~mask) | val;
         writel(mod, i2s->addr + I2SMOD);
+        spin_unlock(i2s->lock);
 
         return 0;
 }
@@ -570,9 +587,8 @@ static int i2s_set_fmt(struct snd_soc_dai *dai,
         unsigned int fmt)
 {
         struct i2s_dai *i2s = to_info(dai);
-        u32 mod = readl(i2s->addr + I2SMOD);
         int lrp_shift, sdf_shift, sdf_mask, lrp_rlow, mod_slave;
-        u32 tmp = 0;
+        u32 mod, tmp = 0;
 
         lrp_shift = i2s->variant_regs->lrp_off;
         sdf_shift = i2s->variant_regs->sdf_off;
@@ -632,12 +648,15 @@ static int i2s_set_fmt(struct snd_soc_dai *dai,
                 return -EINVAL;
         }
 
+        spin_lock(i2s->lock);
+        mod = readl(i2s->addr + I2SMOD);
         /*
          * Don't change the I2S mode if any controller is active on this
          * channel.
          */
         if (any_active(i2s) &&
                 ((mod & (sdf_mask | lrp_rlow | mod_slave)) != tmp)) {
+                spin_unlock(i2s->lock);
                 dev_err(&i2s->pdev->dev,
                                 "%s:%d Other DAI busy\n", __func__, __LINE__);
                 return -EAGAIN;
@@ -646,6 +665,7 @@ static int i2s_set_fmt(struct snd_soc_dai *dai,
         mod &= ~(sdf_mask | lrp_rlow | mod_slave);
         mod |= tmp;
         writel(mod, i2s->addr + I2SMOD);
+        spin_unlock(i2s->lock);
 
         return 0;
 }
@@ -654,16 +674,16 @@ static int i2s_hw_params(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
 {
         struct i2s_dai *i2s = to_info(dai);
-        u32 mod = readl(i2s->addr + I2SMOD);
+        u32 mod, mask = 0, val = 0;
 
         if (!is_secondary(i2s))
-                mod &= ~(MOD_DC2_EN | MOD_DC1_EN);
+                mask |= (MOD_DC2_EN | MOD_DC1_EN);
 
         switch (params_channels(params)) {
         case 6:
-                mod |= MOD_DC2_EN;
+                val |= MOD_DC2_EN;
         case 4:
-                mod |= MOD_DC1_EN;
+                val |= MOD_DC1_EN;
                 break;
         case 2:
                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
@@ -685,44 +705,49 @@ static int i2s_hw_params(struct snd_pcm_substream *substream,
         }
 
         if (is_secondary(i2s))
-                mod &= ~MOD_BLCS_MASK;
+                mask |= MOD_BLCS_MASK;
         else
-                mod &= ~MOD_BLCP_MASK;
+                mask |= MOD_BLCP_MASK;
 
         if (is_manager(i2s))
-                mod &= ~MOD_BLC_MASK;
+                mask |= MOD_BLC_MASK;
 
         switch (params_width(params)) {
         case 8:
                 if (is_secondary(i2s))
-                        mod |= MOD_BLCS_8BIT;
+                        val |= MOD_BLCS_8BIT;
                 else
-                        mod |= MOD_BLCP_8BIT;
+                        val |= MOD_BLCP_8BIT;
                 if (is_manager(i2s))
-                        mod |= MOD_BLC_8BIT;
+                        val |= MOD_BLC_8BIT;
                 break;
         case 16:
                 if (is_secondary(i2s))
-                        mod |= MOD_BLCS_16BIT;
+                        val |= MOD_BLCS_16BIT;
                 else
-                        mod |= MOD_BLCP_16BIT;
+                        val |= MOD_BLCP_16BIT;
                 if (is_manager(i2s))
-                        mod |= MOD_BLC_16BIT;
+                        val |= MOD_BLC_16BIT;
                 break;
         case 24:
                 if (is_secondary(i2s))
-                        mod |= MOD_BLCS_24BIT;
+                        val |= MOD_BLCS_24BIT;
                 else
-                        mod |= MOD_BLCP_24BIT;
+                        val |= MOD_BLCP_24BIT;
                 if (is_manager(i2s))
-                        mod |= MOD_BLC_24BIT;
+                        val |= MOD_BLC_24BIT;
                 break;
         default:
                 dev_err(&i2s->pdev->dev, "Format(%d) not supported\n",
                                 params_format(params));
                 return -EINVAL;
         }
+
+        spin_lock(i2s->lock);
+        mod = readl(i2s->addr + I2SMOD);
+        mod = (mod & ~mask) | val;
         writel(mod, i2s->addr + I2SMOD);
+        spin_unlock(i2s->lock);
 
         samsung_asoc_init_dma_data(dai, &i2s->dma_playback, &i2s->dma_capture);
 
@@ -736,7 +761,7 @@ static int i2s_startup(struct snd_pcm_substream *substream,
           struct snd_soc_dai *dai)
 {
         struct i2s_dai *i2s = to_info(dai);
-        struct i2s_dai *other = i2s->pri_dai ? : i2s->sec_dai;
+        struct i2s_dai *other = get_other_dai(i2s);
         unsigned long flags;
 
         spin_lock_irqsave(&lock, flags);
@@ -753,9 +778,6 @@ static int i2s_startup(struct snd_pcm_substream *substream,
 
         spin_unlock_irqrestore(&lock, flags);
 
-        if (!is_opened(other) && i2s->cdclk_out)
-                i2s_set_sysclk(dai, SAMSUNG_I2S_CDCLK,
-                                0, SND_SOC_CLOCK_OUT);
         return 0;
 }
 
@@ -763,38 +785,27 @@ static void i2s_shutdown(struct snd_pcm_substream *substream,
         struct snd_soc_dai *dai)
 {
         struct i2s_dai *i2s = to_info(dai);
-        struct i2s_dai *other = i2s->pri_dai ? : i2s->sec_dai;
+        struct i2s_dai *other = get_other_dai(i2s);
         unsigned long flags;
-        const struct samsung_i2s_variant_regs *i2s_regs = i2s->variant_regs;
 
         spin_lock_irqsave(&lock, flags);
 
         i2s->mode &= ~DAI_OPENED;
         i2s->mode &= ~DAI_MANAGER;
 
-        if (is_opened(other)) {
+        if (is_opened(other))
                 other->mode |= DAI_MANAGER;
-        } else {
-                u32 mod = readl(i2s->addr + I2SMOD);
-                i2s->cdclk_out = !(mod & (1 << i2s_regs->cdclkcon_off));
-                if (other)
-                        other->cdclk_out = i2s->cdclk_out;
-        }
+
         /* Reset any constraint on RFS and BFS */
         i2s->rfs = 0;
         i2s->bfs = 0;
 
         spin_unlock_irqrestore(&lock, flags);
-
-        /* Gate CDCLK by default */
-        if (!is_opened(other))
-                i2s_set_sysclk(dai, SAMSUNG_I2S_CDCLK,
-                                0, SND_SOC_CLOCK_IN);
 }
 
 static int config_setup(struct i2s_dai *i2s)
 {
-        struct i2s_dai *other = i2s->pri_dai ? : i2s->sec_dai;
+        struct i2s_dai *other = get_other_dai(i2s);
         unsigned rfs, bfs, blc;
         u32 psr;
 
@@ -864,10 +875,10 @@ static int i2s_trigger(struct snd_pcm_substream *substream,
         case SNDRV_PCM_TRIGGER_START:
         case SNDRV_PCM_TRIGGER_RESUME:
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                local_irq_save(flags);
+                spin_lock_irqsave(i2s->lock, flags);
 
                 if (config_setup(i2s)) {
-                        local_irq_restore(flags);
+                        spin_unlock_irqrestore(i2s->lock, flags);
                         return -EINVAL;
                 }
 
@@ -876,12 +887,12 @@ static int i2s_trigger(struct snd_pcm_substream *substream,
                 else
                         i2s_txctrl(i2s, 1);
 
-                local_irq_restore(flags);
+                spin_unlock_irqrestore(i2s->lock, flags);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
         case SNDRV_PCM_TRIGGER_SUSPEND:
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                local_irq_save(flags);
+                spin_lock_irqsave(i2s->lock, flags);
 
                 if (capture) {
                         i2s_rxctrl(i2s, 0);
@@ -891,7 +902,7 @@ static int i2s_trigger(struct snd_pcm_substream *substream,
                         i2s_fifo(i2s, FIC_TXFLUSH);
                 }
 
-                local_irq_restore(flags);
+                spin_unlock_irqrestore(i2s->lock, flags);
                 break;
         }
 
@@ -902,7 +913,7 @@ static int i2s_set_clkdiv(struct snd_soc_dai *dai,
         int div_id, int div)
 {
         struct i2s_dai *i2s = to_info(dai);
-        struct i2s_dai *other = i2s->pri_dai ? : i2s->sec_dai;
+        struct i2s_dai *other = get_other_dai(i2s);
 
         switch (div_id) {
         case SAMSUNG_I2S_DIV_BCLK:
@@ -971,58 +982,36 @@ static int i2s_resume(struct snd_soc_dai *dai)
 static int samsung_i2s_dai_probe(struct snd_soc_dai *dai)
 {
         struct i2s_dai *i2s = to_info(dai);
-        struct i2s_dai *other = i2s->pri_dai ? : i2s->sec_dai;
-        int ret;
+        struct i2s_dai *other = get_other_dai(i2s);
+        unsigned long flags;
 
-        if (other && other->clk) { /* If this is probe on secondary */
+        if (is_secondary(i2s)) { /* If this is probe on the secondary DAI */
                 samsung_asoc_init_dma_data(dai, &other->sec_dai->dma_playback,
                                            NULL);
-                goto probe_exit;
-        }
-
-        i2s->addr = ioremap(i2s->base, 0x100);
-        if (i2s->addr == NULL) {
-                dev_err(&i2s->pdev->dev, "cannot ioremap registers\n");
-                return -ENXIO;
-        }
-
-        i2s->clk = clk_get(&i2s->pdev->dev, "iis");
-        if (IS_ERR(i2s->clk)) {
-                dev_err(&i2s->pdev->dev, "failed to get i2s_clock\n");
-                iounmap(i2s->addr);
-                return PTR_ERR(i2s->clk);
-        }
-
-        ret = clk_prepare_enable(i2s->clk);
-        if (ret != 0) {
-                dev_err(&i2s->pdev->dev, "failed to enable clock: %d\n", ret);
-                return ret;
-        }
-
-        samsung_asoc_init_dma_data(dai, &i2s->dma_playback, &i2s->dma_capture);
-
-        if (other) {
-                other->addr = i2s->addr;
-                other->clk = i2s->clk;
-        }
+        } else {
+                samsung_asoc_init_dma_data(dai, &i2s->dma_playback,
+                                           &i2s->dma_capture);
 
-        if (i2s->quirks & QUIRK_NEED_RSTCLR)
-                writel(CON_RSTCLR, i2s->addr + I2SCON);
+                if (i2s->quirks & QUIRK_NEED_RSTCLR)
+                        writel(CON_RSTCLR, i2s->addr + I2SCON);
 
-        if (i2s->quirks & QUIRK_SUPPORTS_IDMA)
-                idma_reg_addr_init(i2s->addr,
+                if (i2s->quirks & QUIRK_SUPPORTS_IDMA)
+                        idma_reg_addr_init(i2s->addr,
                                         i2s->sec_dai->idma_playback.dma_addr);
+        }
 
-probe_exit:
         /* Reset any constraint on RFS and BFS */
         i2s->rfs = 0;
         i2s->bfs = 0;
         i2s->rclk_srcrate = 0;
+
+        spin_lock_irqsave(i2s->lock, flags);
         i2s_txctrl(i2s, 0);
         i2s_rxctrl(i2s, 0);
         i2s_fifo(i2s, FIC_TXFLUSH);
         i2s_fifo(other, FIC_TXFLUSH);
         i2s_fifo(i2s, FIC_RXFLUSH);
+        spin_unlock_irqrestore(i2s->lock, flags);
 
         /* Gate CDCLK by default */
         if (!is_opened(other))
@@ -1035,21 +1024,15 @@ probe_exit:
 static int samsung_i2s_dai_remove(struct snd_soc_dai *dai)
 {
         struct i2s_dai *i2s = snd_soc_dai_get_drvdata(dai);
-        struct i2s_dai *other = i2s->pri_dai ? : i2s->sec_dai;
-
-        if (!other || !other->clk) {
 
-                if (i2s->quirks & QUIRK_NEED_RSTCLR)
+        if (!is_secondary(i2s)) {
+                if (i2s->quirks & QUIRK_NEED_RSTCLR) {
+                        spin_lock(i2s->lock);
                         writel(0, i2s->addr + I2SCON);
-
-                clk_disable_unprepare(i2s->clk);
-                clk_put(i2s->clk);
-
-                iounmap(i2s->addr);
+                        spin_unlock(i2s->lock);
+                }
         }
 
-        i2s->clk = NULL;
-
         return 0;
 }
 
@@ -1124,15 +1107,14 @@ static const struct of_device_id exynos_i2s_match[];
 static inline const struct samsung_i2s_dai_data *samsung_i2s_get_driver_data(
                                                 struct platform_device *pdev)
 {
-#ifdef CONFIG_OF
-        if (pdev->dev.of_node) {
+        if (IS_ENABLED(CONFIG_OF) && pdev->dev.of_node) {
                 const struct of_device_id *match;
                 match = of_match_node(exynos_i2s_match, pdev->dev.of_node);
-                return match->data;
-        } else
-#endif
+                return match ? match->data : NULL;
+        } else {
                 return (struct samsung_i2s_dai_data *)
                                 platform_get_device_id(pdev)->driver_data;
+        }
 }
 
 #ifdef CONFIG_PM
@@ -1155,6 +1137,87 @@ static int i2s_runtime_resume(struct device *dev)
 }
 #endif /* CONFIG_PM */
 
+static void i2s_unregister_clocks(struct i2s_dai *i2s)
+{
+        int i;
+
+        for (i = 0; i < i2s->clk_data.clk_num; i++) {
+                if (!IS_ERR(i2s->clk_table[i]))
+                        clk_unregister(i2s->clk_table[i]);
+        }
+}
+
+static void i2s_unregister_clock_provider(struct platform_device *pdev)
+{
+        struct i2s_dai *i2s = dev_get_drvdata(&pdev->dev);
+
+        of_clk_del_provider(pdev->dev.of_node);
+        i2s_unregister_clocks(i2s);
+}
+
+static int i2s_register_clock_provider(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct i2s_dai *i2s = dev_get_drvdata(dev);
+        const char *clk_name[2] = { "i2s_opclk0", "i2s_opclk1" };
+        const char *p_names[2] = { NULL };
+        const struct samsung_i2s_variant_regs *reg_info = i2s->variant_regs;
+        struct clk *rclksrc;
+        int ret, i;
+
+        /* Register the clock provider only if it's expected in the DTB */
+        if (!of_find_property(dev->of_node, "#clock-cells", NULL))
+                return 0;
+
+        /* Get the RCLKSRC mux clock parent clock names */
+        for (i = 0; i < ARRAY_SIZE(p_names); i++) {
+                rclksrc = clk_get(dev, clk_name[i]);
+                if (IS_ERR(rclksrc))
+                        continue;
+                p_names[i] = __clk_get_name(rclksrc);
+                clk_put(rclksrc);
+        }
+
+        if (!(i2s->quirks & QUIRK_NO_MUXPSR)) {
+                /* Activate the prescaler */
+                u32 val = readl(i2s->addr + I2SPSR);
+                writel(val | PSR_PSREN, i2s->addr + I2SPSR);
+
+                i2s->clk_table[CLK_I2S_RCLK_SRC] = clk_register_mux(NULL,
+                                "i2s_rclksrc", p_names, ARRAY_SIZE(p_names),
+                                CLK_SET_RATE_NO_REPARENT | CLK_SET_RATE_PARENT,
+                                i2s->addr + I2SMOD, reg_info->rclksrc_off,
+                                1, 0, i2s->lock);
+
+                i2s->clk_table[CLK_I2S_RCLK_PSR] = clk_register_divider(NULL,
+                                "i2s_presc", "i2s_rclksrc",
+                                CLK_SET_RATE_PARENT,
+                                i2s->addr + I2SPSR, 8, 6, 0, i2s->lock);
+
+                p_names[0] = "i2s_presc";
+                i2s->clk_data.clk_num = 2;
+        }
+        of_property_read_string_index(dev->of_node,
+                                "clock-output-names", 0, &clk_name[0]);
+
+        i2s->clk_table[CLK_I2S_CDCLK] = clk_register_gate(NULL, clk_name[0],
+                                p_names[0], CLK_SET_RATE_PARENT,
+                                i2s->addr + I2SMOD, reg_info->cdclkcon_off,
+                                CLK_GATE_SET_TO_DISABLE, i2s->lock);
+
+        i2s->clk_data.clk_num += 1;
+        i2s->clk_data.clks = i2s->clk_table;
+
+        ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get,
+                                  &i2s->clk_data);
+        if (ret < 0) {
+                dev_err(dev, "failed to add clock provider: %d\n", ret);
+                i2s_unregister_clocks(i2s);
+        }
+
+        return ret;
+}
+
 static int samsung_i2s_probe(struct platform_device *pdev)
 {
         struct i2s_dai *pri_dai, *sec_dai = NULL;
@@ -1164,7 +1227,7 @@ static int samsung_i2s_probe(struct platform_device *pdev)
         u32 regs_base, quirks = 0, idma_addr = 0;
         struct device_node *np = pdev->dev.of_node;
         const struct samsung_i2s_dai_data *i2s_dai_data;
-        int ret = 0;
+        int ret;
 
         /* Call during Seconday interface registration */
         i2s_dai_data = samsung_i2s_get_driver_data(pdev);
@@ -1175,11 +1238,13 @@ static int samsung_i2s_probe(struct platform_device *pdev)
                         dev_err(&pdev->dev, "Unable to get drvdata\n");
                         return -EFAULT;
                 }
-                devm_snd_soc_register_component(&sec_dai->pdev->dev,
+                ret = devm_snd_soc_register_component(&sec_dai->pdev->dev,
                                                 &samsung_i2s_component,
                                                 &sec_dai->i2s_dai_drv, 1);
-                samsung_asoc_dma_platform_register(&pdev->dev);
-                return 0;
+                if (ret != 0)
+                        return ret;
+
+                return samsung_asoc_dma_platform_register(&pdev->dev);
         }
 
         pri_dai = i2s_alloc_dai(pdev, false);
@@ -1188,6 +1253,9 @@ static int samsung_i2s_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
+        spin_lock_init(&pri_dai->spinlock);
+        pri_dai->lock = &pri_dai->spinlock;
+
         if (!np) {
                 res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
                 if (!res) {
@@ -1229,25 +1297,29 @@ static int samsung_i2s_probe(struct platform_device *pdev)
         }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(&pdev->dev, "Unable to get I2S SFR address\n");
-                return -ENXIO;
-        }
+        pri_dai->addr = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(pri_dai->addr))
+                return PTR_ERR(pri_dai->addr);
 
-        if (!request_mem_region(res->start, resource_size(res),
-                                                        "samsung-i2s")) {
-                dev_err(&pdev->dev, "Unable to request SFR region\n");
-                return -EBUSY;
-        }
         regs_base = res->start;
 
+        pri_dai->clk = devm_clk_get(&pdev->dev, "iis");
+        if (IS_ERR(pri_dai->clk)) {
+                dev_err(&pdev->dev, "Failed to get iis clock\n");
+                return PTR_ERR(pri_dai->clk);
+        }
+
+        ret = clk_prepare_enable(pri_dai->clk);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "failed to enable clock: %d\n", ret);
+                return ret;
+        }
         pri_dai->dma_playback.dma_addr = regs_base + I2STXD;
         pri_dai->dma_capture.dma_addr = regs_base + I2SRXD;
         pri_dai->dma_playback.ch_name = "tx";
         pri_dai->dma_capture.ch_name = "rx";
         pri_dai->dma_playback.dma_size = 4;
         pri_dai->dma_capture.dma_size = 4;
-        pri_dai->base = regs_base;
         pri_dai->quirks = quirks;
         pri_dai->variant_regs = i2s_dai_data->i2s_variant_regs;
 
@@ -1258,10 +1330,10 @@ static int samsung_i2s_probe(struct platform_device *pdev)
                 sec_dai = i2s_alloc_dai(pdev, true);
                 if (!sec_dai) {
                         dev_err(&pdev->dev, "Unable to alloc I2S_sec\n");
-                        ret = -ENOMEM;
-                        goto err;
+                        return -ENOMEM;
                 }
 
+                sec_dai->lock = &pri_dai->spinlock;
                 sec_dai->variant_regs = pri_dai->variant_regs;
                 sec_dai->dma_playback.dma_addr = regs_base + I2STXDS;
                 sec_dai->dma_playback.ch_name = "tx-sec";
@@ -1273,7 +1345,8 @@ static int samsung_i2s_probe(struct platform_device *pdev)
                 }
 
                 sec_dai->dma_playback.dma_size = 4;
-                sec_dai->base = regs_base;
+                sec_dai->addr = pri_dai->addr;
+                sec_dai->clk = pri_dai->clk;
                 sec_dai->quirks = quirks;
                 sec_dai->idma_playback.dma_addr = idma_addr;
                 sec_dai->pri_dai = pri_dai;
@@ -1282,8 +1355,7 @@ static int samsung_i2s_probe(struct platform_device *pdev)
 
         if (i2s_pdata && i2s_pdata->cfg_gpio && i2s_pdata->cfg_gpio(pdev)) {
                 dev_err(&pdev->dev, "Unable to configure gpio\n");
-                ret = -EINVAL;
-                goto err;
+                return -EINVAL;
         }
 
         devm_snd_soc_register_component(&pri_dai->pdev->dev,
@@ -1292,32 +1364,30 @@ static int samsung_i2s_probe(struct platform_device *pdev)
 
         pm_runtime_enable(&pdev->dev);
 
-        samsung_asoc_dma_platform_register(&pdev->dev);
-
-        return 0;
-err:
-        if (res)
-                release_mem_region(regs_base, resource_size(res));
+        ret = samsung_asoc_dma_platform_register(&pdev->dev);
+        if (ret != 0)
+                return ret;
 
-        return ret;
+        return i2s_register_clock_provider(pdev);
 }
 
 static int samsung_i2s_remove(struct platform_device *pdev)
 {
         struct i2s_dai *i2s, *other;
-        struct resource *res;
 
         i2s = dev_get_drvdata(&pdev->dev);
-        other = i2s->pri_dai ? : i2s->sec_dai;
+        other = get_other_dai(i2s);
 
         if (other) {
                 other->pri_dai = NULL;
                 other->sec_dai = NULL;
         } else {
                 pm_runtime_disable(&pdev->dev);
-                res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-                if (res)
-                        release_mem_region(res->start, resource_size(res));
+        }
+
+        if (!is_secondary(i2s)) {
+                i2s_unregister_clock_provider(pdev);
+                clk_disable_unprepare(i2s->clk);
         }
 
         i2s->pri_dai = NULL;
diff --git a/sound/soc/samsung/jive_wm8750.c b/sound/soc/samsung/jive_wm8750.c
index b5f6abd9d221..7fcb51faa2a0 100644
--- a/sound/soc/samsung/jive_wm8750.c
+++ b/sound/soc/samsung/jive_wm8750.c
@@ -61,20 +61,6 @@ static int jive_hw_params(struct snd_pcm_substream *substream,
         s3c_i2sv2_iis_calc_rate(&div, NULL, params_rate(params),
                                 s3c_i2sv2_get_clock(cpu_dai));
 
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
-                                  SND_SOC_DAIFMT_NB_NF |
-                                  SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
-        /* set cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
-                                  SND_SOC_DAIFMT_NB_NF |
-                                  SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         /* set the codec system clock for DAC and ADC */
         ret = snd_soc_dai_set_sysclk(codec_dai, WM8750_SYSCLK, clk,
                                      SND_SOC_CLOCK_IN);
@@ -97,22 +83,6 @@ static struct snd_soc_ops jive_ops = {
         .hw_params      = jive_hw_params,
 };
 
-static int jive_wm8750_init(struct snd_soc_pcm_runtime *rtd)
-{
-        struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-
-        /* These endpoints are not being used. */
-        snd_soc_dapm_nc_pin(dapm, "LINPUT2");
-        snd_soc_dapm_nc_pin(dapm, "RINPUT2");
-        snd_soc_dapm_nc_pin(dapm, "LINPUT3");
-        snd_soc_dapm_nc_pin(dapm, "RINPUT3");
-        snd_soc_dapm_nc_pin(dapm, "OUT3");
-        snd_soc_dapm_nc_pin(dapm, "MONO");
-
-        return 0;
-}
-
 static struct snd_soc_dai_link jive_dai = {
         .name           = "wm8750",
         .stream_name    = "WM8750",
@@ -120,7 +90,8 @@ static struct snd_soc_dai_link jive_dai = {
         .codec_dai_name = "wm8750-hifi",
         .platform_name  = "s3c2412-i2s",
         .codec_name     = "wm8750.0-001a",
-        .init           = jive_wm8750_init,
+        .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                          SND_SOC_DAIFMT_CBS_CFS,
         .ops            = &jive_ops,
 };
 
@@ -135,6 +106,7 @@ static struct snd_soc_card snd_soc_machine_jive = {
         .num_dapm_widgets = ARRAY_SIZE(wm8750_dapm_widgets),
         .dapm_routes    = audio_map,
         .num_dapm_routes = ARRAY_SIZE(audio_map),
+        .fully_routed   = true,
 };
 
 static struct platform_device *jive_snd_device;
diff --git a/sound/soc/samsung/neo1973_wm8753.c b/sound/soc/samsung/neo1973_wm8753.c
index 9b4a09f14b6c..65602b935377 100644
--- a/sound/soc/samsung/neo1973_wm8753.c
+++ b/sound/soc/samsung/neo1973_wm8753.c
@@ -70,20 +70,6 @@ static int neo1973_hifi_hw_params(struct snd_pcm_substream *substream,
                 break;
         }
 
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai,
-                SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
-                SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                return ret;
-
-        /* set cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai,
-                SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
-                SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                return ret;
-
         /* set the codec system clock for DAC and ADC */
         ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_MCLK, pll_out,
                 SND_SOC_CLOCK_IN);
@@ -151,13 +137,6 @@ static int neo1973_voice_hw_params(struct snd_pcm_substream *substream,
 
         pcmdiv = WM8753_PCM_DIV_6; /* 2.048 MHz */
 
-        /* todo: gg check mode (DSP_B) against CSR datasheet */
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_DSP_B |
-                SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         /* set the codec system clock for DAC and ADC */
         ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_PCMCLK, 12288000,
                 SND_SOC_CLOCK_IN);
@@ -300,6 +279,8 @@ static struct snd_soc_dai_link neo1973_dai[] = {
         .cpu_dai_name = "s3c24xx-iis",
         .codec_dai_name = "wm8753-hifi",
         .codec_name = "wm8753.0-001a",
+        .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                   SND_SOC_DAIFMT_CBM_CFM,
         .init = neo1973_wm8753_init,
         .ops = &neo1973_hifi_ops,
 },
@@ -309,6 +290,8 @@ static struct snd_soc_dai_link neo1973_dai[] = {
         .cpu_dai_name = "bt-sco-pcm",
         .codec_dai_name = "wm8753-voice",
         .codec_name = "wm8753.0-001a",
+        .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_NB_NF |
+                   SND_SOC_DAIFMT_CBS_CFS,
         .ops = &neo1973_voice_ops,
 },
 };
diff --git a/sound/soc/samsung/odroidx2_max98090.c b/sound/soc/samsung/odroidx2_max98090.c
index fa4f1d2f69bf..596f1180a369 100644
--- a/sound/soc/samsung/odroidx2_max98090.c
+++ b/sound/soc/samsung/odroidx2_max98090.c
@@ -21,6 +21,8 @@ struct odroidx2_drv_data {
 /* The I2S CDCLK output clock frequency for the MAX98090 codec */
 #define MAX98090_MCLK 19200000
 
+static struct snd_soc_dai_link odroidx2_dai[];
+
 static int odroidx2_late_probe(struct snd_soc_card *card)
 {
         struct snd_soc_dai *codec_dai = card->rtd[0].codec_dai;
@@ -29,7 +31,9 @@ static int odroidx2_late_probe(struct snd_soc_card *card)
 
         ret = snd_soc_dai_set_sysclk(codec_dai, 0, MAX98090_MCLK,
                                                 SND_SOC_CLOCK_IN);
-        if (ret < 0)
+
+        if (ret < 0 || of_find_property(odroidx2_dai[0].codec_of_node,
+                                        "clocks", NULL))
                 return ret;
 
         /* Set the cpu DAI configuration in order to use CDCLK */
diff --git a/sound/soc/samsung/rx1950_uda1380.c b/sound/soc/samsung/rx1950_uda1380.c
index 37688ebbb2b4..873f2cb4bebe 100644
--- a/sound/soc/samsung/rx1950_uda1380.c
+++ b/sound/soc/samsung/rx1950_uda1380.c
@@ -89,6 +89,8 @@ static struct snd_soc_dai_link rx1950_uda1380_dai[] = {
                 .init           = rx1950_uda1380_init,
                 .platform_name  = "s3c24xx-iis",
                 .codec_name     = "uda1380-codec.0-001a",
+                .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                                  SND_SOC_DAIFMT_CBS_CFS,
                 .ops            = &rx1950_ops,
         },
 };
@@ -154,7 +156,6 @@ static int rx1950_hw_params(struct snd_pcm_substream *substream,
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-        struct snd_soc_dai *codec_dai = rtd->codec_dai;
         int div;
         int ret;
         unsigned int rate = params_rate(params);
@@ -181,18 +182,6 @@ static int rx1950_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
-                SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
-        /* set cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
-                SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         /* select clock source */
         ret = snd_soc_dai_set_sysclk(cpu_dai, clk_source, rate,
                         SND_SOC_CLOCK_OUT);
diff --git a/sound/soc/samsung/s3c24xx_simtec.c b/sound/soc/samsung/s3c24xx_simtec.c
index 2c015f62ead6..dcc008d1e1ab 100644
--- a/sound/soc/samsung/s3c24xx_simtec.c
+++ b/sound/soc/samsung/s3c24xx_simtec.c
@@ -169,24 +169,6 @@ static int simtec_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
         int ret;
 
-        /* Set the CODEC as the bus clock master, I2S */
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
-                                  SND_SOC_DAIFMT_NB_NF |
-                                  SND_SOC_DAIFMT_CBM_CFM);
-        if (ret) {
-                pr_err("%s: failed set cpu dai format\n", __func__);
-                return ret;
-        }
-
-        /* Set the CODEC as the bus clock master */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
-                                  SND_SOC_DAIFMT_NB_NF |
-                                  SND_SOC_DAIFMT_CBM_CFM);
-        if (ret) {
-                pr_err("%s: failed set codec dai format\n", __func__);
-                return ret;
-        }
-
         ret = snd_soc_dai_set_sysclk(codec_dai, 0,
                                      CODEC_CLOCK, SND_SOC_CLOCK_IN);
         if (ret) {
@@ -320,6 +302,8 @@ int simtec_audio_core_probe(struct platform_device *pdev,
         int ret;
 
         card->dai_link->ops = &simtec_snd_ops;
+        card->dai_link->dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                                  SND_SOC_DAIFMT_CBM_CFM;
 
         pdata = pdev->dev.platform_data;
         if (!pdata) {
diff --git a/sound/soc/samsung/s3c24xx_uda134x.c b/sound/soc/samsung/s3c24xx_uda134x.c
index 9c6f7db56f60..50849e137fc0 100644
--- a/sound/soc/samsung/s3c24xx_uda134x.c
+++ b/sound/soc/samsung/s3c24xx_uda134x.c
@@ -173,16 +173,6 @@ static int s3c24xx_uda134x_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
-                        SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
-                        SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         ret = snd_soc_dai_set_sysclk(cpu_dai, clk_source , clk,
                         SND_SOC_CLOCK_IN);
         if (ret < 0)
@@ -223,6 +213,8 @@ static struct snd_soc_dai_link s3c24xx_uda134x_dai_link = {
         .codec_name = "uda134x-codec",
         .codec_dai_name = "uda134x-hifi",
         .cpu_dai_name = "s3c24xx-iis",
+        .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                   SND_SOC_DAIFMT_CBS_CFS,
         .ops = &s3c24xx_uda134x_ops,
         .platform_name  = "s3c24xx-iis",
 };
diff --git a/sound/soc/samsung/smartq_wm8987.c b/sound/soc/samsung/smartq_wm8987.c
index 9b0ffacab790..8291d2a5f152 100644
--- a/sound/soc/samsung/smartq_wm8987.c
+++ b/sound/soc/samsung/smartq_wm8987.c
@@ -56,20 +56,6 @@ static int smartq_hifi_hw_params(struct snd_pcm_substream *substream,
                 break;
         }
 
-        /* set codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
-                                             SND_SOC_DAIFMT_NB_NF |
-                                             SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
-        /* set cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
-                                           SND_SOC_DAIFMT_NB_NF |
-                                           SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         /* Use PCLK for I2S signal generation */
         ret = snd_soc_dai_set_sysclk(cpu_dai, SAMSUNG_I2S_RCLKSRC_0,
                                         0, SND_SOC_CLOCK_IN);
@@ -199,6 +185,8 @@ static struct snd_soc_dai_link smartq_dai[] = {
                 .platform_name  = "samsung-i2s.0",
                 .codec_name     = "wm8750.0-0x1a",
                 .init           = smartq_wm8987_init,
+                .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                                  SND_SOC_DAIFMT_CBS_CFS,
                 .ops            = &smartq_hifi_ops,
         },
 };
diff --git a/sound/soc/samsung/smdk_wm8580.c b/sound/soc/samsung/smdk_wm8580.c
index b1a519f83b29..548bfd993788 100644
--- a/sound/soc/samsung/smdk_wm8580.c
+++ b/sound/soc/samsung/smdk_wm8580.c
@@ -32,7 +32,6 @@ static int smdk_hw_params(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
         struct snd_soc_dai *codec_dai = rtd->codec_dai;
         unsigned int pll_out;
         int bfs, rfs, ret;
@@ -77,20 +76,6 @@ static int smdk_hw_params(struct snd_pcm_substream *substream,
         }
         pll_out = params_rate(params) * rfs;
 
-        /* Set the Codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S
-                                         | SND_SOC_DAIFMT_NB_NF
-                                         | SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                return ret;
-
-        /* Set the AP DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S
-                                         | SND_SOC_DAIFMT_NB_NF
-                                         | SND_SOC_DAIFMT_CBM_CFM);
-        if (ret < 0)
-                return ret;
-
         /* Set WM8580 to drive MCLK from its PLLA */
         ret = snd_soc_dai_set_clkdiv(codec_dai, WM8580_MCLK,
                                         WM8580_CLKSRC_PLLA);
@@ -151,13 +136,10 @@ static const struct snd_soc_dapm_route smdk_wm8580_audio_map[] = {
 
 static int smdk_wm8580_init_paiftx(struct snd_soc_pcm_runtime *rtd)
 {
-        struct snd_soc_codec *codec = rtd->codec;
-        struct snd_soc_dapm_context *dapm = &codec->dapm;
-
         /* Enabling the microphone requires the fitting of a 0R
          * resistor to connect the line from the microphone jack.
          */
-        snd_soc_dapm_disable_pin(dapm, "MicIn");
+        snd_soc_dapm_disable_pin(&rtd->card->dapm, "MicIn");
 
         return 0;
 }
@@ -168,6 +150,9 @@ enum {
         SEC_PLAYBACK,
 };
 
+#define SMDK_DAI_FMT (SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | \
+        SND_SOC_DAIFMT_CBM_CFM)
+
 static struct snd_soc_dai_link smdk_dai[] = {
         [PRI_PLAYBACK] = { /* Primary Playback i/f */
                 .name = "WM8580 PAIF RX",
@@ -176,6 +161,7 @@ static struct snd_soc_dai_link smdk_dai[] = {
                 .codec_dai_name = "wm8580-hifi-playback",
                 .platform_name = "samsung-i2s.0",
                 .codec_name = "wm8580.0-001b",
+                .dai_fmt = SMDK_DAI_FMT,
                 .ops = &smdk_ops,
         },
         [PRI_CAPTURE] = { /* Primary Capture i/f */
@@ -185,6 +171,7 @@ static struct snd_soc_dai_link smdk_dai[] = {
                 .codec_dai_name = "wm8580-hifi-capture",
                 .platform_name = "samsung-i2s.0",
                 .codec_name = "wm8580.0-001b",
+                .dai_fmt = SMDK_DAI_FMT,
                 .init = smdk_wm8580_init_paiftx,
                 .ops = &smdk_ops,
         },
@@ -195,6 +182,7 @@ static struct snd_soc_dai_link smdk_dai[] = {
                 .codec_dai_name = "wm8580-hifi-playback",
                 .platform_name = "samsung-i2s-sec",
                 .codec_name = "wm8580.0-001b",
+                .dai_fmt = SMDK_DAI_FMT,
                 .ops = &smdk_ops,
         },
 };
diff --git a/sound/soc/samsung/smdk_wm8580pcm.c b/sound/soc/samsung/smdk_wm8580pcm.c
index 05c609c62de9..6deec5234c92 100644
--- a/sound/soc/samsung/smdk_wm8580pcm.c
+++ b/sound/soc/samsung/smdk_wm8580pcm.c
@@ -62,20 +62,6 @@ static int smdk_wm8580_pcm_hw_params(struct snd_pcm_substream *substream,
 
         rfs = mclk_freq / params_rate(params) / 2;
 
-        /* Set the codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_DSP_B
-                                | SND_SOC_DAIFMT_IB_NF
-                                | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
-        /* Set the cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_DSP_B
-                                | SND_SOC_DAIFMT_IB_NF
-                                | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         if (mclk_freq == xtal_freq) {
                 ret = snd_soc_dai_set_sysclk(codec_dai, WM8580_CLKSRC_MCLK,
                                                 mclk_freq, SND_SOC_CLOCK_IN);
@@ -121,6 +107,9 @@ static struct snd_soc_ops smdk_wm8580_pcm_ops = {
         .hw_params = smdk_wm8580_pcm_hw_params,
 };
 
+#define SMDK_DAI_FMT (SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_IB_NF | \
+        SND_SOC_DAIFMT_CBS_CFS)
+
 static struct snd_soc_dai_link smdk_dai[] = {
         {
                 .name = "WM8580 PAIF PCM RX",
@@ -129,6 +118,7 @@ static struct snd_soc_dai_link smdk_dai[] = {
                 .codec_dai_name = "wm8580-hifi-playback",
                 .platform_name = "samsung-audio",
                 .codec_name = "wm8580.0-001b",
+                .dai_fmt = SMDK_DAI_FMT,
                 .ops = &smdk_wm8580_pcm_ops,
         }, {
                 .name = "WM8580 PAIF PCM TX",
@@ -137,6 +127,7 @@ static struct snd_soc_dai_link smdk_dai[] = {
                 .codec_dai_name = "wm8580-hifi-capture",
                 .platform_name = "samsung-pcm.0",
                 .codec_name = "wm8580.0-001b",
+                .dai_fmt = SMDK_DAI_FMT,
                 .ops = &smdk_wm8580_pcm_ops,
         },
 };
diff --git a/sound/soc/samsung/smdk_wm8994pcm.c b/sound/soc/samsung/smdk_wm8994pcm.c
index c470e8eed6e1..b1c89ec2d999 100644
--- a/sound/soc/samsung/smdk_wm8994pcm.c
+++ b/sound/soc/samsung/smdk_wm8994pcm.c
@@ -68,20 +68,6 @@ static int smdk_wm8994_pcm_hw_params(struct snd_pcm_substream *substream,
 
         mclk_freq = params_rate(params) * rfs;
 
-        /* Set the codec DAI configuration */
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_DSP_B
-                                | SND_SOC_DAIFMT_IB_NF
-                                | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
-        /* Set the cpu DAI configuration */
-        ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_DSP_B
-                                | SND_SOC_DAIFMT_IB_NF
-                                | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         ret = snd_soc_dai_set_sysclk(codec_dai, WM8994_SYSCLK_FLL1,
                                         mclk_freq, SND_SOC_CLOCK_IN);
         if (ret < 0)
@@ -118,6 +104,8 @@ static struct snd_soc_dai_link smdk_dai[] = {
                 .codec_dai_name = "wm8994-aif1",
                 .platform_name = "samsung-pcm.0",
                 .codec_name = "wm8994-codec",
+                .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_IB_NF |
+                           SND_SOC_DAIFMT_CBS_CFS,
                 .ops = &smdk_wm8994_pcm_ops,
         },
 };
diff --git a/sound/soc/sh/dma-sh7760.c b/sound/soc/sh/dma-sh7760.c
index a5b2c4ea90d9..fd11404a3bc7 100644
--- a/sound/soc/sh/dma-sh7760.c
+++ b/sound/soc/sh/dma-sh7760.c
@@ -305,11 +305,6 @@ static struct snd_pcm_ops camelot_pcm_ops = {
         .pointer        = camelot_pos,
 };
 
-static void camelot_pcm_free(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 static int camelot_pcm_new(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_pcm *pcm = rtd->pcm;
@@ -328,7 +323,6 @@ static int camelot_pcm_new(struct snd_soc_pcm_runtime *rtd)
 static struct snd_soc_platform_driver sh7760_soc_platform = {
         .ops            = &camelot_pcm_ops,
         .pcm_new        = camelot_pcm_new,
-        .pcm_free       = camelot_pcm_free,
 };
 
 static int sh7760_soc_platform_probe(struct platform_device *pdev)
diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c
index 8869971d7884..b87b22e88e43 100644
--- a/sound/soc/sh/fsi.c
+++ b/sound/soc/sh/fsi.c
@@ -820,12 +820,9 @@ static int fsi_clk_enable(struct device *dev,
                         return ret;
                 }
 
-                if (clock->xck)
-                        clk_enable(clock->xck);
-                if (clock->ick)
-                        clk_enable(clock->ick);
-                if (clock->div)
-                        clk_enable(clock->div);
+                clk_enable(clock->xck);
+                clk_enable(clock->ick);
+                clk_enable(clock->div);
 
                 clock->count++;
         }
@@ -1765,11 +1762,6 @@ static struct snd_pcm_ops fsi_pcm_ops = {
 #define PREALLOC_BUFFER         (32 * 1024)
 #define PREALLOC_BUFFER_MAX     (32 * 1024)
 
-static void fsi_pcm_free(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 static int fsi_pcm_new(struct snd_soc_pcm_runtime *rtd)
 {
         return snd_pcm_lib_preallocate_pages_for_all(
@@ -1821,7 +1813,6 @@ static struct snd_soc_dai_driver fsi_soc_dai[] = {
 static struct snd_soc_platform_driver fsi_soc_platform = {
         .ops            = &fsi_pcm_ops,
         .pcm_new        = fsi_pcm_new,
-        .pcm_free       = fsi_pcm_free,
 };
 
 static const struct snd_soc_component_driver fsi_soc_component = {
diff --git a/sound/soc/sh/migor.c b/sound/soc/sh/migor.c
index c58c2529f103..82f582344fe7 100644
--- a/sound/soc/sh/migor.c
+++ b/sound/soc/sh/migor.c
@@ -63,16 +63,6 @@ static int migor_hw_params(struct snd_pcm_substream *substream,
         if (ret < 0)
                 return ret;
 
-        ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_NB_IF |
-                                  SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
-        ret = snd_soc_dai_set_fmt(rtd->cpu_dai, SND_SOC_DAIFMT_NB_IF |
-                                  SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS);
-        if (ret < 0)
-                return ret;
-
         codec_freq = rate * 512;
         /*
          * This propagates the parent frequency change to children and
@@ -144,6 +134,8 @@ static struct snd_soc_dai_link migor_dai = {
         .codec_dai_name = "wm8978-hifi",
         .platform_name = "siu-pcm-audio",
         .codec_name = "wm8978.0-001a",
+        .dai_fmt = SND_SOC_DAIFMT_NB_IF | SND_SOC_DAIFMT_I2S |
+                   SND_SOC_DAIFMT_CBS_CFS,
         .ops = &migor_dai_ops,
 };
 
diff --git a/sound/soc/sh/rcar/adg.c b/sound/soc/sh/rcar/adg.c
index 14d1a7193469..7ac35c9d1cb8 100644
--- a/sound/soc/sh/rcar/adg.c
+++ b/sound/soc/sh/rcar/adg.c
@@ -57,8 +57,7 @@ static u32 rsnd_adg_ssi_ws_timing_gen2(struct rsnd_dai_stream *io)
         return (0x6 + ws) << 8;
 }
 
-int rsnd_adg_set_cmd_timsel_gen2(struct rsnd_dai *rdai,
-                                 struct rsnd_mod *mod,
+int rsnd_adg_set_cmd_timsel_gen2(struct rsnd_mod *mod,
                                  struct rsnd_dai_stream *io)
 {
         int id = rsnd_mod_id(mod);
@@ -75,12 +74,11 @@ int rsnd_adg_set_cmd_timsel_gen2(struct rsnd_dai *rdai,
         return 0;
 }
 
-static int rsnd_adg_set_src_timsel_gen2(struct rsnd_dai *rdai,
-                                        struct rsnd_mod *mod,
+static int rsnd_adg_set_src_timsel_gen2(struct rsnd_mod *mod,
                                         struct rsnd_dai_stream *io,
                                         u32 timsel)
 {
-        int is_play = rsnd_dai_is_play(rdai, io);
+        int is_play = rsnd_io_is_play(io);
         int id = rsnd_mod_id(mod);
         int shift = (id % 2) ? 16 : 0;
         u32 mask, ws;
@@ -122,7 +120,6 @@ static int rsnd_adg_set_src_timsel_gen2(struct rsnd_dai *rdai,
 }
 
 int rsnd_adg_set_convert_clk_gen2(struct rsnd_mod *mod,
-                                  struct rsnd_dai *rdai,
                                   struct rsnd_dai_stream *io,
                                   unsigned int src_rate,
                                   unsigned int dst_rate)
@@ -178,7 +175,7 @@ int rsnd_adg_set_convert_clk_gen2(struct rsnd_mod *mod,
                 return -EIO;
         }
 
-        ret = rsnd_adg_set_src_timsel_gen2(rdai, mod, io, val);
+        ret = rsnd_adg_set_src_timsel_gen2(mod, io, val);
         if (ret < 0) {
                 dev_err(dev, "timsel error\n");
                 return ret;
@@ -190,12 +187,11 @@ int rsnd_adg_set_convert_clk_gen2(struct rsnd_mod *mod,
 }
 
 int rsnd_adg_set_convert_timing_gen2(struct rsnd_mod *mod,
-                                     struct rsnd_dai *rdai,
                                      struct rsnd_dai_stream *io)
 {
         u32 val = rsnd_adg_ssi_ws_timing_gen2(io);
 
-        return rsnd_adg_set_src_timsel_gen2(rdai, mod, io, val);
+        return rsnd_adg_set_src_timsel_gen2(mod, io, val);
 }
 
 int rsnd_adg_set_convert_clk_gen1(struct rsnd_priv *priv,
diff --git a/sound/soc/sh/rcar/core.c b/sound/soc/sh/rcar/core.c
index 75308bbc2ce8..110577c52317 100644
--- a/sound/soc/sh/rcar/core.c
+++ b/sound/soc/sh/rcar/core.c
@@ -149,16 +149,16 @@ char *rsnd_mod_dma_name(struct rsnd_mod *mod)
         return mod->ops->dma_name(mod);
 }
 
-void rsnd_mod_init(struct rsnd_priv *priv,
-                   struct rsnd_mod *mod,
+void rsnd_mod_init(struct rsnd_mod *mod,
                    struct rsnd_mod_ops *ops,
+                   struct clk *clk,
                    enum rsnd_mod_type type,
                    int id)
 {
-        mod->priv       = priv;
         mod->id         = id;
         mod->ops        = ops;
         mod->type       = type;
+        mod->clk        = clk;
 }
 
 /*
@@ -412,7 +412,7 @@ u32 rsnd_get_adinr(struct rsnd_mod *mod)
 /*
  *      rsnd_dai functions
  */
-#define __rsnd_mod_call(mod, func, rdai...)                     \
+#define __rsnd_mod_call(mod, func, param...)                    \
 ({                                                              \
         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);         \
         struct device *dev = rsnd_priv_to_dev(priv);            \
@@ -422,18 +422,18 @@ u32 rsnd_get_adinr(struct rsnd_mod *mod)
         if ((mod->status & mask) == call) {                             \
                 dev_dbg(dev, "%s[%d] %s\n",                             \
                         rsnd_mod_name(mod), rsnd_mod_id(mod), #func);   \
-                ret = (mod)->ops->func(mod, rdai);                      \
+                ret = (mod)->ops->func(mod, param);                     \
                 mod->status = (mod->status & ~mask) | (~call & mask);   \
         }                                                               \
         ret;                                                            \
 })
 
-#define rsnd_mod_call(mod, func, rdai...)       \
+#define rsnd_mod_call(mod, func, param...)      \
         (!(mod) ? -ENODEV :                     \
          !((mod)->ops->func) ? 0 :              \
-         __rsnd_mod_call(mod, func, rdai))
+         __rsnd_mod_call(mod, func, param))
 
-#define rsnd_dai_call(fn, io, rdai...)                          \
+#define rsnd_dai_call(fn, io, param...)                         \
 ({                                                              \
         struct rsnd_mod *mod;                                   \
         int ret = 0, i;                                         \
@@ -441,7 +441,7 @@ u32 rsnd_get_adinr(struct rsnd_mod *mod)
                 mod = (io)->mod[i];                             \
                 if (!mod)                                       \
                         continue;                               \
-                ret = rsnd_mod_call(mod, fn, rdai);             \
+                ret = rsnd_mod_call(mod, fn, param);            \
                 if (ret < 0)                                    \
                         break;                                  \
         }                                                       \
@@ -477,17 +477,7 @@ static void rsnd_dai_disconnect(struct rsnd_mod *mod,
         io->mod[mod->type] = NULL;
 }
 
-int rsnd_dai_id(struct rsnd_priv *priv, struct rsnd_dai *rdai)
-{
-        int id = rdai - priv->rdai;
-
-        if ((id < 0) || (id >= rsnd_rdai_nr(priv)))
-                return -EINVAL;
-
-        return id;
-}
-
-struct rsnd_dai *rsnd_dai_get(struct rsnd_priv *priv, int id)
+struct rsnd_dai *rsnd_rdai_get(struct rsnd_priv *priv, int id)
 {
         if ((id < 0) || (id >= rsnd_rdai_nr(priv)))
                 return NULL;
@@ -499,12 +489,7 @@ static struct rsnd_dai *rsnd_dai_to_rdai(struct snd_soc_dai *dai)
 {
         struct rsnd_priv *priv = snd_soc_dai_get_drvdata(dai);
 
-        return rsnd_dai_get(priv, dai->id);
-}
-
-int rsnd_dai_is_play(struct rsnd_dai *rdai, struct rsnd_dai_stream *io)
-{
-        return &rdai->playback == io;
+        return rsnd_rdai_get(priv, dai->id);
 }
 
 /*
@@ -598,20 +583,20 @@ static int rsnd_soc_dai_trigger(struct snd_pcm_substream *substream, int cmd,
                 if (ret < 0)
                         goto dai_trigger_end;
 
-                ret = rsnd_dai_call(init, io, rdai);
+                ret = rsnd_dai_call(init, io, priv);
                 if (ret < 0)
                         goto dai_trigger_end;
 
-                ret = rsnd_dai_call(start, io, rdai);
+                ret = rsnd_dai_call(start, io, priv);
                 if (ret < 0)
                         goto dai_trigger_end;
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
-                ret = rsnd_dai_call(stop, io, rdai);
+                ret = rsnd_dai_call(stop, io, priv);
                 if (ret < 0)
                         goto dai_trigger_end;
 
-                ret = rsnd_dai_call(quit, io, rdai);
+                ret = rsnd_dai_call(quit, io, priv);
                 if (ret < 0)
                         goto dai_trigger_end;
 
@@ -873,15 +858,15 @@ static int rsnd_dai_probe(struct platform_device *pdev,
         priv->rdai      = rdai;
 
         for (i = 0; i < dai_nr; i++) {
-                rdai[i].info = &info->dai_info[i];
 
-                pmod = rdai[i].info->playback.ssi;
-                cmod = rdai[i].info->capture.ssi;
+                pmod = info->dai_info[i].playback.ssi;
+                cmod = info->dai_info[i].capture.ssi;
 
                 /*
                  *      init rsnd_dai
                  */
                 snprintf(rdai[i].name, RSND_DAI_NAME_SIZE, "rsnd-dai.%d", i);
+                rdai[i].priv = priv;
 
                 /*
                  *      init snd_soc_dai_driver
@@ -895,6 +880,7 @@ static int rsnd_dai_probe(struct platform_device *pdev,
                         drv[i].playback.channels_max    = 2;
 
                         rdai[i].playback.info = &info->dai_info[i].playback;
+                        rdai[i].playback.rdai = rdai + i;
                         rsnd_path_init(priv, &rdai[i], &rdai[i].playback);
                 }
                 if (cmod) {
@@ -904,6 +890,7 @@ static int rsnd_dai_probe(struct platform_device *pdev,
                         drv[i].capture.channels_max     = 2;
 
                         rdai[i].capture.info = &info->dai_info[i].capture;
+                        rdai[i].capture.rdai = rdai + i;
                         rsnd_path_init(priv, &rdai[i], &rdai[i].capture);
                 }
 
@@ -1037,7 +1024,6 @@ static int rsnd_kctrl_put(struct snd_kcontrol *kctrl,
 }
 
 static int __rsnd_kctrl_new(struct rsnd_mod *mod,
-                            struct rsnd_dai *rdai,
                             struct snd_soc_pcm_runtime *rtd,
                             const unsigned char *name,
                             struct rsnd_kctrl_cfg *cfg,
@@ -1060,16 +1046,24 @@ static int __rsnd_kctrl_new(struct rsnd_mod *mod,
                 return -ENOMEM;
 
         ret = snd_ctl_add(card, kctrl);
-        if (ret < 0)
+        if (ret < 0) {
+                snd_ctl_free_one(kctrl);
                 return ret;
+        }
 
         cfg->update = update;
+        cfg->card = card;
+        cfg->kctrl = kctrl;
 
         return 0;
 }
 
+void _rsnd_kctrl_remove(struct rsnd_kctrl_cfg *cfg)
+{
+        snd_ctl_remove(cfg->card, cfg->kctrl);
+}
+
 int rsnd_kctrl_new_m(struct rsnd_mod *mod,
-                     struct rsnd_dai *rdai,
                      struct snd_soc_pcm_runtime *rtd,
                      const unsigned char *name,
                      void (*update)(struct rsnd_mod *mod),
@@ -1079,11 +1073,10 @@ int rsnd_kctrl_new_m(struct rsnd_mod *mod,
         _cfg->cfg.max   = max;
         _cfg->cfg.size  = RSND_DVC_CHANNELS;
         _cfg->cfg.val   = _cfg->val;
-        return __rsnd_kctrl_new(mod, rdai, rtd, name, &_cfg->cfg, update);
+        return __rsnd_kctrl_new(mod, rtd, name, &_cfg->cfg, update);
 }
 
 int rsnd_kctrl_new_s(struct rsnd_mod *mod,
-                     struct rsnd_dai *rdai,
                      struct snd_soc_pcm_runtime *rtd,
                      const unsigned char *name,
                      void (*update)(struct rsnd_mod *mod),
@@ -1093,11 +1086,10 @@ int rsnd_kctrl_new_s(struct rsnd_mod *mod,
         _cfg->cfg.max   = max;
         _cfg->cfg.size  = 1;
         _cfg->cfg.val   = &_cfg->val;
-        return __rsnd_kctrl_new(mod, rdai, rtd, name, &_cfg->cfg, update);
+        return __rsnd_kctrl_new(mod, rtd, name, &_cfg->cfg, update);
 }
 
 int rsnd_kctrl_new_e(struct rsnd_mod *mod,
-                     struct rsnd_dai *rdai,
                      struct snd_soc_pcm_runtime *rtd,
                      const unsigned char *name,
                      struct rsnd_kctrl_cfg_s *_cfg,
@@ -1109,7 +1101,7 @@ int rsnd_kctrl_new_e(struct rsnd_mod *mod,
         _cfg->cfg.size  = 1;
         _cfg->cfg.val   = &_cfg->val;
         _cfg->cfg.texts = texts;
-        return __rsnd_kctrl_new(mod, rdai, rtd, name, &_cfg->cfg, update);
+        return __rsnd_kctrl_new(mod, rtd, name, &_cfg->cfg, update);
 }
 
 /*
@@ -1125,11 +1117,11 @@ static int rsnd_pcm_new(struct snd_soc_pcm_runtime *rtd)
         struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);
         int ret;
 
-        ret = rsnd_dai_call(pcm_new, &rdai->playback, rdai, rtd);
+        ret = rsnd_dai_call(pcm_new, &rdai->playback, rtd);
         if (ret)
                 return ret;
 
-        ret = rsnd_dai_call(pcm_new, &rdai->capture, rdai, rtd);
+        ret = rsnd_dai_call(pcm_new, &rdai->capture, rtd);
         if (ret)
                 return ret;
 
@@ -1140,15 +1132,9 @@ static int rsnd_pcm_new(struct snd_soc_pcm_runtime *rtd)
                 PREALLOC_BUFFER, PREALLOC_BUFFER_MAX);
 }
 
-static void rsnd_pcm_free(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 static struct snd_soc_platform_driver rsnd_soc_platform = {
         .ops            = &rsnd_pcm_ops,
         .pcm_new        = rsnd_pcm_new,
-        .pcm_free       = rsnd_pcm_free,
 };
 
 static const struct snd_soc_component_driver rsnd_soc_component = {
@@ -1156,13 +1142,11 @@ static const struct snd_soc_component_driver rsnd_soc_component = {
 };
 
 static int rsnd_rdai_continuance_probe(struct rsnd_priv *priv,
-                                       struct rsnd_dai *rdai,
-                                       int is_play)
+                                       struct rsnd_dai_stream *io)
 {
-        struct rsnd_dai_stream *io = is_play ? &rdai->playback : &rdai->capture;
         int ret;
 
-        ret = rsnd_dai_call(probe, io, rdai);
+        ret = rsnd_dai_call(probe, io, priv);
         if (ret == -EAGAIN) {
                 /*
                  * Fallback to PIO mode
@@ -1175,7 +1159,7 @@ static int rsnd_rdai_continuance_probe(struct rsnd_priv *priv,
                  *      rsnd_dma_init()
                  *      rsnd_ssi_fallback()
                  */
-                rsnd_dai_call(remove, io, rdai);
+                rsnd_dai_call(remove, io, priv);
 
                 /*
                  * remove SRC/DVC from DAI,
@@ -1186,13 +1170,13 @@ static int rsnd_rdai_continuance_probe(struct rsnd_priv *priv,
                 /*
                  * fallback
                  */
-                rsnd_dai_call(fallback, io, rdai);
+                rsnd_dai_call(fallback, io, priv);
 
                 /*
                  * retry to "probe".
                  * DAI has SSI which is PIO mode only now.
                  */
-                ret = rsnd_dai_call(probe, io, rdai);
+                ret = rsnd_dai_call(probe, io, priv);
         }
 
         return ret;
@@ -1259,15 +1243,17 @@ static int rsnd_probe(struct platform_device *pdev)
         }
 
         for_each_rsnd_dai(rdai, priv, i) {
-                ret = rsnd_rdai_continuance_probe(priv, rdai, 1);
+                ret = rsnd_rdai_continuance_probe(priv, &rdai->playback);
                 if (ret)
                         goto exit_snd_probe;
 
-                ret = rsnd_rdai_continuance_probe(priv, rdai, 0);
+                ret = rsnd_rdai_continuance_probe(priv, &rdai->capture);
                 if (ret)
                         goto exit_snd_probe;
         }
 
+        dev_set_drvdata(dev, priv);
+
         /*
          *      asoc register
          */
@@ -1284,8 +1270,6 @@ static int rsnd_probe(struct platform_device *pdev)
                 goto exit_snd_soc;
         }
 
-        dev_set_drvdata(dev, priv);
-
         pm_runtime_enable(dev);
 
         dev_info(dev, "probed\n");
@@ -1295,8 +1279,8 @@ exit_snd_soc:
         snd_soc_unregister_platform(dev);
 exit_snd_probe:
         for_each_rsnd_dai(rdai, priv, i) {
-                rsnd_dai_call(remove, &rdai->playback, rdai);
-                rsnd_dai_call(remove, &rdai->capture, rdai);
+                rsnd_dai_call(remove, &rdai->playback, priv);
+                rsnd_dai_call(remove, &rdai->capture, priv);
         }
 
         return ret;
@@ -1311,10 +1295,13 @@ static int rsnd_remove(struct platform_device *pdev)
         pm_runtime_disable(&pdev->dev);
 
         for_each_rsnd_dai(rdai, priv, i) {
-                ret |= rsnd_dai_call(remove, &rdai->playback, rdai);
-                ret |= rsnd_dai_call(remove, &rdai->capture, rdai);
+                ret |= rsnd_dai_call(remove, &rdai->playback, priv);
+                ret |= rsnd_dai_call(remove, &rdai->capture, priv);
         }
 
+        snd_soc_unregister_component(&pdev->dev);
+        snd_soc_unregister_platform(&pdev->dev);
+
         return ret;
 }
 
diff --git a/sound/soc/sh/rcar/dvc.c b/sound/soc/sh/rcar/dvc.c
index 5380a4827ba7..d7f9ed959c4e 100644
--- a/sound/soc/sh/rcar/dvc.c
+++ b/sound/soc/sh/rcar/dvc.c
@@ -17,7 +17,6 @@
 struct rsnd_dvc {
         struct rsnd_dvc_platform_info *info; /* rcar_snd.h */
         struct rsnd_mod mod;
-        struct clk *clk;
         struct rsnd_kctrl_cfg_m volume;
         struct rsnd_kctrl_cfg_m mute;
         struct rsnd_kctrl_cfg_s ren;    /* Ramp Enable */
@@ -118,9 +117,8 @@ static void rsnd_dvc_volume_update(struct rsnd_mod *mod)
 }
 
 static int rsnd_dvc_probe_gen2(struct rsnd_mod *mod,
-                               struct rsnd_dai *rdai)
+                               struct rsnd_priv *priv)
 {
-        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
         struct device *dev = rsnd_priv_to_dev(priv);
 
         dev_dbg(dev, "%s[%d] (Gen2) is probed\n",
@@ -129,12 +127,24 @@ static int rsnd_dvc_probe_gen2(struct rsnd_mod *mod,
         return 0;
 }
 
+static int rsnd_dvc_remove_gen2(struct rsnd_mod *mod,
+                                struct rsnd_priv *priv)
+{
+        struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
+
+        rsnd_kctrl_remove(dvc->volume);
+        rsnd_kctrl_remove(dvc->mute);
+        rsnd_kctrl_remove(dvc->ren);
+        rsnd_kctrl_remove(dvc->rup);
+        rsnd_kctrl_remove(dvc->rdown);
+
+        return 0;
+}
+
 static int rsnd_dvc_init(struct rsnd_mod *dvc_mod,
-                         struct rsnd_dai *rdai)
+                         struct rsnd_priv *priv)
 {
-        struct rsnd_dvc *dvc = rsnd_mod_to_dvc(dvc_mod);
         struct rsnd_dai_stream *io = rsnd_mod_to_io(dvc_mod);
-        struct rsnd_priv *priv = rsnd_mod_to_priv(dvc_mod);
         struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io);
         struct device *dev = rsnd_priv_to_dev(priv);
         int dvc_id = rsnd_mod_id(dvc_mod);
@@ -153,7 +163,7 @@ static int rsnd_dvc_init(struct rsnd_mod *dvc_mod,
                 return -EINVAL;
         }
 
-        clk_prepare_enable(dvc->clk);
+        rsnd_mod_hw_start(dvc_mod);
 
         /*
          * fixme
@@ -173,23 +183,21 @@ static int rsnd_dvc_init(struct rsnd_mod *dvc_mod,
 
         rsnd_mod_write(dvc_mod, DVC_DVUIR, 0);
 
-        rsnd_adg_set_cmd_timsel_gen2(rdai, dvc_mod, io);
+        rsnd_adg_set_cmd_timsel_gen2(dvc_mod, io);
 
         return 0;
 }
 
 static int rsnd_dvc_quit(struct rsnd_mod *mod,
-                         struct rsnd_dai *rdai)
+                         struct rsnd_priv *priv)
 {
-        struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
-
-        clk_disable_unprepare(dvc->clk);
+        rsnd_mod_hw_stop(mod);
 
         return 0;
 }
 
 static int rsnd_dvc_start(struct rsnd_mod *mod,
-                          struct rsnd_dai *rdai)
+                          struct rsnd_priv *priv)
 {
         rsnd_mod_write(mod, CMD_CTRL, 0x10);
 
@@ -197,7 +205,7 @@ static int rsnd_dvc_start(struct rsnd_mod *mod,
 }
 
 static int rsnd_dvc_stop(struct rsnd_mod *mod,
-                         struct rsnd_dai *rdai)
+                         struct rsnd_priv *priv)
 {
         rsnd_mod_write(mod, CMD_CTRL, 0);
 
@@ -205,16 +213,16 @@ static int rsnd_dvc_stop(struct rsnd_mod *mod,
 }
 
 static int rsnd_dvc_pcm_new(struct rsnd_mod *mod,
-                            struct rsnd_dai *rdai,
                             struct snd_soc_pcm_runtime *rtd)
 {
         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
         struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
+        int is_play = rsnd_io_is_play(io);
         int ret;
 
         /* Volume */
-        ret = rsnd_kctrl_new_m(mod, rdai, rtd,
-                        rsnd_dai_is_play(rdai, io) ?
+        ret = rsnd_kctrl_new_m(mod, rtd,
+                        is_play ?
                         "DVC Out Playback Volume" : "DVC In Capture Volume",
                         rsnd_dvc_volume_update,
                         &dvc->volume, 0x00800000 - 1);
@@ -222,8 +230,8 @@ static int rsnd_dvc_pcm_new(struct rsnd_mod *mod,
                 return ret;
 
         /* Mute */
-        ret = rsnd_kctrl_new_m(mod, rdai, rtd,
-                        rsnd_dai_is_play(rdai, io) ?
+        ret = rsnd_kctrl_new_m(mod, rtd,
+                        is_play ?
                         "DVC Out Mute Switch" : "DVC In Mute Switch",
                         rsnd_dvc_volume_update,
                         &dvc->mute, 1);
@@ -231,16 +239,16 @@ static int rsnd_dvc_pcm_new(struct rsnd_mod *mod,
                 return ret;
 
         /* Ramp */
-        ret = rsnd_kctrl_new_s(mod, rdai, rtd,
-                        rsnd_dai_is_play(rdai, io) ?
+        ret = rsnd_kctrl_new_s(mod, rtd,
+                        is_play ?
                         "DVC Out Ramp Switch" : "DVC In Ramp Switch",
                         rsnd_dvc_volume_update,
                         &dvc->ren, 1);
         if (ret < 0)
                 return ret;
 
-        ret = rsnd_kctrl_new_e(mod, rdai, rtd,
-                        rsnd_dai_is_play(rdai, io) ?
+        ret = rsnd_kctrl_new_e(mod, rtd,
+                        is_play ?
                         "DVC Out Ramp Up Rate" : "DVC In Ramp Up Rate",
                         &dvc->rup,
                         rsnd_dvc_volume_update,
@@ -248,8 +256,8 @@ static int rsnd_dvc_pcm_new(struct rsnd_mod *mod,
         if (ret < 0)
                 return ret;
 
-        ret = rsnd_kctrl_new_e(mod, rdai, rtd,
-                        rsnd_dai_is_play(rdai, io) ?
+        ret = rsnd_kctrl_new_e(mod, rtd,
+                        is_play ?
                         "DVC Out Ramp Down Rate" : "DVC In Ramp Down Rate",
                         &dvc->rdown,
                         rsnd_dvc_volume_update,
@@ -264,6 +272,7 @@ static int rsnd_dvc_pcm_new(struct rsnd_mod *mod,
 static struct rsnd_mod_ops rsnd_dvc_ops = {
         .name           = DVC_NAME,
         .probe          = rsnd_dvc_probe_gen2,
+        .remove         = rsnd_dvc_remove_gen2,
         .init           = rsnd_dvc_init,
         .quit           = rsnd_dvc_quit,
         .start          = rsnd_dvc_start,
@@ -356,9 +365,9 @@ int rsnd_dvc_probe(struct platform_device *pdev,
                         return PTR_ERR(clk);
 
                 dvc->info = &info->dvc_info[i];
-                dvc->clk  = clk;
 
-                rsnd_mod_init(priv, &dvc->mod, &rsnd_dvc_ops, RSND_MOD_DVC, i);
+                rsnd_mod_init(&dvc->mod, &rsnd_dvc_ops,
+                              clk, RSND_MOD_DVC, i);
 
                 dev_dbg(dev, "CMD%d probed\n", i);
         }
diff --git a/sound/soc/sh/rcar/gen.c b/sound/soc/sh/rcar/gen.c
index 87a6f2d62775..de0685f2abae 100644
--- a/sound/soc/sh/rcar/gen.c
+++ b/sound/soc/sh/rcar/gen.c
@@ -309,8 +309,13 @@ static int rsnd_gen2_probe(struct platform_device *pdev,
                 RSND_GEN_M_REG(SRC_BUSIF_MODE,  0x0,    0x20),
                 RSND_GEN_M_REG(SRC_ROUTE_MODE0, 0xc,    0x20),
                 RSND_GEN_M_REG(SRC_CTRL,        0x10,   0x20),
+                RSND_GEN_M_REG(SRC_INT_ENABLE0, 0x18,   0x20),
                 RSND_GEN_M_REG(CMD_ROUTE_SLCT,  0x18c,  0x20),
                 RSND_GEN_M_REG(CMD_CTRL,        0x190,  0x20),
+                RSND_GEN_S_REG(SCU_SYS_STATUS0, 0x1c8),
+                RSND_GEN_S_REG(SCU_SYS_INT_EN0, 0x1cc),
+                RSND_GEN_S_REG(SCU_SYS_STATUS1, 0x1d0),
+                RSND_GEN_S_REG(SCU_SYS_INT_EN1, 0x1c4),
                 RSND_GEN_M_REG(SRC_SWRSR,       0x200,  0x40),
                 RSND_GEN_M_REG(SRC_SRCIR,       0x204,  0x40),
                 RSND_GEN_M_REG(SRC_ADINR,       0x214,  0x40),
@@ -403,6 +408,16 @@ static int rsnd_gen1_probe(struct platform_device *pdev,
                 RSND_GEN_M_REG(SRC_IFSVR,       0x220,  0x40),
                 RSND_GEN_M_REG(SRC_SRCCR,       0x224,  0x40),
                 RSND_GEN_M_REG(SRC_MNFSR,       0x228,  0x40),
+                /*
+                 * ADD US
+                 *
+                 * SRC_STATUS
+                 * SRC_INT_EN
+                 * SCU_SYS_STATUS0
+                 * SCU_SYS_STATUS1
+                 * SCU_SYS_INT_EN0
+                 * SCU_SYS_INT_EN1
+                 */
         };
         struct rsnd_regmap_field_conf conf_adg[] = {
                 RSND_GEN_S_REG(BRRA,            0x00),
diff --git a/sound/soc/sh/rcar/rsnd.h b/sound/soc/sh/rcar/rsnd.h
index 5826c8abf794..e7914bd610e2 100644
--- a/sound/soc/sh/rcar/rsnd.h
+++ b/sound/soc/sh/rcar/rsnd.h
@@ -44,6 +44,8 @@ enum rsnd_reg {
         RSND_REG_SRC_IFSCR,
         RSND_REG_SRC_IFSVR,
         RSND_REG_SRC_SRCCR,
+        RSND_REG_SCU_SYS_STATUS0,
+        RSND_REG_SCU_SYS_INT_EN0,
         RSND_REG_CMD_ROUTE_SLCT,
         RSND_REG_DVC_SWRSR,
         RSND_REG_DVC_DVUIR,
@@ -94,6 +96,9 @@ enum rsnd_reg {
         RSND_REG_SHARE23,
         RSND_REG_SHARE24,
         RSND_REG_SHARE25,
+        RSND_REG_SHARE26,
+        RSND_REG_SHARE27,
+        RSND_REG_SHARE28,
 
         RSND_REG_MAX,
 };
@@ -135,6 +140,9 @@ enum rsnd_reg {
 #define RSND_REG_DVC_VRCTR              RSND_REG_SHARE23
 #define RSND_REG_DVC_VRPDR              RSND_REG_SHARE24
 #define RSND_REG_DVC_VRDBR              RSND_REG_SHARE25
+#define RSND_REG_SCU_SYS_STATUS1        RSND_REG_SHARE26
+#define RSND_REG_SCU_SYS_INT_EN1        RSND_REG_SHARE27
+#define RSND_REG_SRC_INT_ENABLE0        RSND_REG_SHARE28
 
 struct rsnd_of_data;
 struct rsnd_priv;
@@ -182,9 +190,9 @@ void  rsnd_dma_quit(struct rsnd_priv *priv,
  *      R-Car sound mod
  */
 enum rsnd_mod_type {
-        RSND_MOD_SRC = 0,
+        RSND_MOD_DVC = 0,
+        RSND_MOD_SRC,
         RSND_MOD_SSI,
-        RSND_MOD_DVC,
         RSND_MOD_MAX,
 };
 
@@ -192,32 +200,31 @@ struct rsnd_mod_ops {
         char *name;
         char* (*dma_name)(struct rsnd_mod *mod);
         int (*probe)(struct rsnd_mod *mod,
-                     struct rsnd_dai *rdai);
+                     struct rsnd_priv *priv);
         int (*remove)(struct rsnd_mod *mod,
-                      struct rsnd_dai *rdai);
+                      struct rsnd_priv *priv);
         int (*init)(struct rsnd_mod *mod,
-                    struct rsnd_dai *rdai);
+                    struct rsnd_priv *priv);
         int (*quit)(struct rsnd_mod *mod,
-                    struct rsnd_dai *rdai);
+                    struct rsnd_priv *priv);
         int (*start)(struct rsnd_mod *mod,
-                     struct rsnd_dai *rdai);
+                     struct rsnd_priv *priv);
         int (*stop)(struct rsnd_mod *mod,
-                    struct rsnd_dai *rdai);
+                    struct rsnd_priv *priv);
         int (*pcm_new)(struct rsnd_mod *mod,
-                       struct rsnd_dai *rdai,
                        struct snd_soc_pcm_runtime *rtd);
         int (*fallback)(struct rsnd_mod *mod,
-                        struct rsnd_dai *rdai);
+                        struct rsnd_priv *priv);
 };
 
 struct rsnd_dai_stream;
 struct rsnd_mod {
         int id;
         enum rsnd_mod_type type;
-        struct rsnd_priv *priv;
         struct rsnd_mod_ops *ops;
         struct rsnd_dma dma;
         struct rsnd_dai_stream *io;
+        struct clk *clk;
         u32 status;
 };
 /*
@@ -248,15 +255,17 @@ struct rsnd_mod {
 #define __rsnd_mod_call_pcm_new         0
 #define __rsnd_mod_call_fallback        0
 
-#define rsnd_mod_to_priv(mod) ((mod)->priv)
+#define rsnd_mod_to_priv(mod) (rsnd_io_to_priv(rsnd_mod_to_io(mod)))
 #define rsnd_mod_to_dma(mod) (&(mod)->dma)
 #define rsnd_dma_to_mod(_dma) container_of((_dma), struct rsnd_mod, dma)
 #define rsnd_mod_to_io(mod) ((mod)->io)
 #define rsnd_mod_id(mod) ((mod)->id)
+#define rsnd_mod_hw_start(mod)  clk_prepare_enable((mod)->clk)
+#define rsnd_mod_hw_stop(mod)   clk_disable_unprepare((mod)->clk)
 
-void rsnd_mod_init(struct rsnd_priv *priv,
-                   struct rsnd_mod *mod,
+void rsnd_mod_init(struct rsnd_mod *mod,
                    struct rsnd_mod_ops *ops,
+                   struct clk *clk,
                    enum rsnd_mod_type type,
                    int id);
 char *rsnd_mod_name(struct rsnd_mod *mod);
@@ -270,6 +279,7 @@ struct rsnd_dai_stream {
         struct snd_pcm_substream *substream;
         struct rsnd_mod *mod[RSND_MOD_MAX];
         struct rsnd_dai_path_info *info; /* rcar_snd.h */
+        struct rsnd_dai *rdai;
         int byte_pos;
         int period_pos;
         int byte_per_period;
@@ -278,12 +288,18 @@ struct rsnd_dai_stream {
 #define rsnd_io_to_mod_ssi(io)  ((io)->mod[RSND_MOD_SSI])
 #define rsnd_io_to_mod_src(io)  ((io)->mod[RSND_MOD_SRC])
 #define rsnd_io_to_mod_dvc(io)  ((io)->mod[RSND_MOD_DVC])
+#define rsnd_io_to_rdai(io)     ((io)->rdai)
+#define rsnd_io_to_priv(io)     (rsnd_rdai_to_priv(rsnd_io_to_rdai(io)))
+#define rsnd_io_is_play(io)     (&rsnd_io_to_rdai(io)->playback == io)
+#define rsnd_io_to_runtime(io) ((io)->substream ? \
+                                (io)->substream->runtime : NULL)
+
 
 struct rsnd_dai {
         char name[RSND_DAI_NAME_SIZE];
-        struct rsnd_dai_platform_info *info; /* rcar_snd.h */
         struct rsnd_dai_stream playback;
         struct rsnd_dai_stream capture;
+        struct rsnd_priv *priv;
 
         unsigned int clk_master:1;
         unsigned int bit_clk_inv:1;
@@ -293,22 +309,18 @@ struct rsnd_dai {
 };
 
 #define rsnd_rdai_nr(priv) ((priv)->rdai_nr)
+#define rsnd_rdai_is_clk_master(rdai) ((rdai)->clk_master)
+#define rsnd_rdai_to_priv(rdai) ((rdai)->priv)
 #define for_each_rsnd_dai(rdai, priv, i)                \
         for (i = 0;                                     \
              (i < rsnd_rdai_nr(priv)) &&                \
-             ((rdai) = rsnd_dai_get(priv, i));          \
+             ((rdai) = rsnd_rdai_get(priv, i));         \
              i++)
 
-struct rsnd_dai *rsnd_dai_get(struct rsnd_priv *priv, int id);
-int rsnd_dai_is_play(struct rsnd_dai *rdai, struct rsnd_dai_stream *io);
-int rsnd_dai_id(struct rsnd_priv *priv, struct rsnd_dai *rdai);
-#define rsnd_dai_get_platform_info(rdai) ((rdai)->info)
-#define rsnd_io_to_runtime(io) ((io)->substream ? \
-                                (io)->substream->runtime : NULL)
+struct rsnd_dai *rsnd_rdai_get(struct rsnd_priv *priv, int id);
 
 void rsnd_dai_pointer_update(struct rsnd_dai_stream *io, int cnt);
 int rsnd_dai_pointer_offset(struct rsnd_dai_stream *io, int additional);
-#define rsnd_dai_is_clk_master(rdai) ((rdai)->clk_master)
 
 /*
  *      R-Car Gen1/Gen2
@@ -339,15 +351,12 @@ int rsnd_adg_set_convert_clk_gen1(struct rsnd_priv *priv,
                                   unsigned int src_rate,
                                   unsigned int dst_rate);
 int rsnd_adg_set_convert_clk_gen2(struct rsnd_mod *mod,
-                                  struct rsnd_dai *rdai,
                                   struct rsnd_dai_stream *io,
                                   unsigned int src_rate,
                                   unsigned int dst_rate);
 int rsnd_adg_set_convert_timing_gen2(struct rsnd_mod *mod,
-                                     struct rsnd_dai *rdai,
                                      struct rsnd_dai_stream *io);
-int rsnd_adg_set_cmd_timsel_gen2(struct rsnd_dai *rdai,
-                                 struct rsnd_mod *mod,
+int rsnd_adg_set_cmd_timsel_gen2(struct rsnd_mod *mod,
                                  struct rsnd_dai_stream *io);
 
 /*
@@ -427,6 +436,8 @@ struct rsnd_kctrl_cfg {
         u32 *val;
         const char * const *texts;
         void (*update)(struct rsnd_mod *mod);
+        struct snd_card *card;
+        struct snd_kcontrol *kctrl;
 };
 
 #define RSND_DVC_CHANNELS       2
@@ -440,22 +451,22 @@ struct rsnd_kctrl_cfg_s {
         u32 val;
 };
 
+void _rsnd_kctrl_remove(struct rsnd_kctrl_cfg *cfg);
+#define rsnd_kctrl_remove(_cfg) _rsnd_kctrl_remove(&((_cfg).cfg))
+
 int rsnd_kctrl_new_m(struct rsnd_mod *mod,
-                     struct rsnd_dai *rdai,
                      struct snd_soc_pcm_runtime *rtd,
                      const unsigned char *name,
                      void (*update)(struct rsnd_mod *mod),
                      struct rsnd_kctrl_cfg_m *_cfg,
                      u32 max);
 int rsnd_kctrl_new_s(struct rsnd_mod *mod,
-                     struct rsnd_dai *rdai,
                      struct snd_soc_pcm_runtime *rtd,
                      const unsigned char *name,
                      void (*update)(struct rsnd_mod *mod),
                      struct rsnd_kctrl_cfg_s *_cfg,
                      u32 max);
 int rsnd_kctrl_new_e(struct rsnd_mod *mod,
-                     struct rsnd_dai *rdai,
                      struct snd_soc_pcm_runtime *rtd,
                      const unsigned char *name,
                      struct rsnd_kctrl_cfg_s *_cfg,
@@ -474,14 +485,10 @@ unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv,
                                    struct rsnd_dai_stream *io,
                                    struct snd_pcm_runtime *runtime);
 int rsnd_src_ssiu_start(struct rsnd_mod *ssi_mod,
-                        struct rsnd_dai *rdai,
                         int use_busif);
-int rsnd_src_ssiu_stop(struct rsnd_mod *ssi_mod,
-                       struct rsnd_dai *rdai);
-int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod,
-                            struct rsnd_dai *rdai);
-int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod,
-                             struct rsnd_dai *rdai);
+int rsnd_src_ssiu_stop(struct rsnd_mod *ssi_mod);
+int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod);
+int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod);
 
 #define rsnd_src_nr(priv) ((priv)->src_nr)
 
diff --git a/sound/soc/sh/rcar/src.c b/sound/soc/sh/rcar/src.c
index eede3ac6eed2..81c182b4bad5 100644
--- a/sound/soc/sh/rcar/src.c
+++ b/sound/soc/sh/rcar/src.c
@@ -12,10 +12,17 @@
 
 #define SRC_NAME "src"
 
+/* SRCx_STATUS */
+#define OUF_SRCO        ((1 << 12) | (1 << 13))
+#define OUF_SRCI        ((1 <<  9) | (1 <<  8))
+
+/* SCU_SYSTEM_STATUS0/1 */
+#define OUF_SRC(id)     ((1 << (id + 16)) | (1 << id))
+
 struct rsnd_src {
         struct rsnd_src_platform_info *info; /* rcar_snd.h */
         struct rsnd_mod mod;
-        struct clk *clk;
+        int err;
 };
 
 #define RSND_SRC_NAME_SIZE 16
@@ -107,10 +114,10 @@ struct rsnd_src {
  *              Gen1/Gen2 common functions
  */
 int rsnd_src_ssiu_start(struct rsnd_mod *ssi_mod,
-                        struct rsnd_dai *rdai,
                         int use_busif)
 {
         struct rsnd_dai_stream *io = rsnd_mod_to_io(ssi_mod);
+        struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
         int ssi_id = rsnd_mod_id(ssi_mod);
 
@@ -140,7 +147,7 @@ int rsnd_src_ssiu_start(struct rsnd_mod *ssi_mod,
                 if (shift >= 0)
                         rsnd_mod_bset(ssi_mod, SSI_MODE1,
                                       0x3 << shift,
-                                      rsnd_dai_is_clk_master(rdai) ?
+                                      rsnd_rdai_is_clk_master(rdai) ?
                                       0x2 << shift : 0x1 << shift);
         }
 
@@ -174,8 +181,7 @@ int rsnd_src_ssiu_start(struct rsnd_mod *ssi_mod,
         return 0;
 }
 
-int rsnd_src_ssiu_stop(struct rsnd_mod *ssi_mod,
-                       struct rsnd_dai *rdai)
+int rsnd_src_ssiu_stop(struct rsnd_mod *ssi_mod)
 {
         /*
          * DMA settings for SSIU
@@ -185,8 +191,7 @@ int rsnd_src_ssiu_stop(struct rsnd_mod *ssi_mod,
         return 0;
 }
 
-int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod,
-                            struct rsnd_dai *rdai)
+int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod)
 {
         struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);
 
@@ -202,8 +207,7 @@ int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod,
         return 0;
 }
 
-int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod,
-                            struct rsnd_dai *rdai)
+int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod)
 {
         struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);
 
@@ -240,8 +244,7 @@ unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv,
         return rate;
 }
 
-static int rsnd_src_set_convert_rate(struct rsnd_mod *mod,
-                                     struct rsnd_dai *rdai)
+static int rsnd_src_set_convert_rate(struct rsnd_mod *mod)
 {
         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
@@ -273,12 +276,13 @@ static int rsnd_src_set_convert_rate(struct rsnd_mod *mod,
         return 0;
 }
 
-static int rsnd_src_init(struct rsnd_mod *mod,
-                         struct rsnd_dai *rdai)
+static int rsnd_src_init(struct rsnd_mod *mod)
 {
         struct rsnd_src *src = rsnd_mod_to_src(mod);
 
-        clk_prepare_enable(src->clk);
+        rsnd_mod_hw_start(mod);
+
+        src->err = 0;
 
         /*
          * Initialize the operation of the SRC internal circuits
@@ -290,11 +294,16 @@ static int rsnd_src_init(struct rsnd_mod *mod,
 }
 
 static int rsnd_src_quit(struct rsnd_mod *mod,
-                         struct rsnd_dai *rdai)
+                         struct rsnd_priv *priv)
 {
         struct rsnd_src *src = rsnd_mod_to_src(mod);
+        struct device *dev = rsnd_priv_to_dev(priv);
+
+        rsnd_mod_hw_stop(mod);
 
-        clk_disable_unprepare(src->clk);
+        if (src->err)
+                dev_warn(dev, "%s[%d] under/over flow err = %d\n",
+                         rsnd_mod_name(mod), rsnd_mod_id(mod), src->err);
 
         return 0;
 }
@@ -319,8 +328,7 @@ static int rsnd_src_stop(struct rsnd_mod *mod)
 /*
  *              Gen1 functions
  */
-static int rsnd_src_set_route_gen1(struct rsnd_mod *mod,
-                                   struct rsnd_dai *rdai)
+static int rsnd_src_set_route_gen1(struct rsnd_mod *mod)
 {
         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
         struct src_route_config {
@@ -348,7 +356,7 @@ static int rsnd_src_set_route_gen1(struct rsnd_mod *mod,
         /*
          * SRC_ROUTE_SELECT
          */
-        val = rsnd_dai_is_play(rdai, io) ? 0x1 : 0x2;
+        val = rsnd_io_is_play(io) ? 0x1 : 0x2;
         val = val               << routes[id].shift;
         mask = routes[id].mask  << routes[id].shift;
 
@@ -357,8 +365,7 @@ static int rsnd_src_set_route_gen1(struct rsnd_mod *mod,
         return 0;
 }
 
-static int rsnd_src_set_convert_timing_gen1(struct rsnd_mod *mod,
-                                            struct rsnd_dai *rdai)
+static int rsnd_src_set_convert_timing_gen1(struct rsnd_mod *mod)
 {
         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
@@ -416,13 +423,12 @@ static int rsnd_src_set_convert_timing_gen1(struct rsnd_mod *mod,
         return 0;
 }
 
-static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod,
-                                          struct rsnd_dai *rdai)
+static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod)
 {
         struct rsnd_src *src = rsnd_mod_to_src(mod);
         int ret;
 
-        ret = rsnd_src_set_convert_rate(mod, rdai);
+        ret = rsnd_src_set_convert_rate(mod);
         if (ret < 0)
                 return ret;
 
@@ -443,9 +449,8 @@ static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod,
 }
 
 static int rsnd_src_probe_gen1(struct rsnd_mod *mod,
-                              struct rsnd_dai *rdai)
+                               struct rsnd_priv *priv)
 {
-        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
         struct device *dev = rsnd_priv_to_dev(priv);
 
         dev_dbg(dev, "%s[%d] (Gen1) is probed\n",
@@ -455,23 +460,23 @@ static int rsnd_src_probe_gen1(struct rsnd_mod *mod,
 }
 
 static int rsnd_src_init_gen1(struct rsnd_mod *mod,
-                              struct rsnd_dai *rdai)
+                              struct rsnd_priv *priv)
 {
         int ret;
 
-        ret = rsnd_src_init(mod, rdai);
+        ret = rsnd_src_init(mod);
         if (ret < 0)
                 return ret;
 
-        ret = rsnd_src_set_route_gen1(mod, rdai);
+        ret = rsnd_src_set_route_gen1(mod);
         if (ret < 0)
                 return ret;
 
-        ret = rsnd_src_set_convert_rate_gen1(mod, rdai);
+        ret = rsnd_src_set_convert_rate_gen1(mod);
         if (ret < 0)
                 return ret;
 
-        ret = rsnd_src_set_convert_timing_gen1(mod, rdai);
+        ret = rsnd_src_set_convert_timing_gen1(mod);
         if (ret < 0)
                 return ret;
 
@@ -479,7 +484,7 @@ static int rsnd_src_init_gen1(struct rsnd_mod *mod,
 }
 
 static int rsnd_src_start_gen1(struct rsnd_mod *mod,
-                               struct rsnd_dai *rdai)
+                               struct rsnd_priv *priv)
 {
         int id = rsnd_mod_id(mod);
 
@@ -489,7 +494,7 @@ static int rsnd_src_start_gen1(struct rsnd_mod *mod,
 }
 
 static int rsnd_src_stop_gen1(struct rsnd_mod *mod,
-                              struct rsnd_dai *rdai)
+                              struct rsnd_priv *priv)
 {
         int id = rsnd_mod_id(mod);
 
@@ -510,8 +515,111 @@ static struct rsnd_mod_ops rsnd_src_gen1_ops = {
 /*
  *              Gen2 functions
  */
-static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod,
-                                          struct rsnd_dai *rdai)
+#define rsnd_src_irq_enable_gen2(mod)  rsnd_src_irq_ctrol_gen2(mod, 1)
+#define rsnd_src_irq_disable_gen2(mod) rsnd_src_irq_ctrol_gen2(mod, 0)
+static void rsnd_src_irq_ctrol_gen2(struct rsnd_mod *mod, int enable)
+{
+        struct rsnd_src *src = rsnd_mod_to_src(mod);
+        u32 sys_int_val, int_val, sys_int_mask;
+        int irq = src->info->irq;
+        int id = rsnd_mod_id(mod);
+
+        sys_int_val =
+        sys_int_mask = OUF_SRC(id);
+        int_val = 0x3300;
+
+        /*
+         * IRQ is not supported on non-DT
+         * see
+         *      rsnd_src_probe_gen2()
+         */
+        if ((irq <= 0) || !enable) {
+                sys_int_val = 0;
+                int_val = 0;
+        }
+
+        rsnd_mod_write(mod, SRC_INT_ENABLE0, int_val);
+        rsnd_mod_bset(mod, SCU_SYS_INT_EN0, sys_int_mask, sys_int_val);
+        rsnd_mod_bset(mod, SCU_SYS_INT_EN1, sys_int_mask, sys_int_val);
+}
+
+static void rsnd_src_error_clear_gen2(struct rsnd_mod *mod)
+{
+        u32 val = OUF_SRC(rsnd_mod_id(mod));
+
+        rsnd_mod_bset(mod, SCU_SYS_STATUS0, val, val);
+        rsnd_mod_bset(mod, SCU_SYS_STATUS1, val, val);
+}
+
+static bool rsnd_src_error_record_gen2(struct rsnd_mod *mod)
+{
+        u32 val = OUF_SRC(rsnd_mod_id(mod));
+        bool ret = false;
+
+        if ((rsnd_mod_read(mod, SCU_SYS_STATUS0) & val) ||
+            (rsnd_mod_read(mod, SCU_SYS_STATUS1) & val)) {
+                struct rsnd_src *src = rsnd_mod_to_src(mod);
+
+                src->err++;
+                ret = true;
+        }
+
+        /* clear error static */
+        rsnd_src_error_clear_gen2(mod);
+
+        return ret;
+}
+
+static int _rsnd_src_start_gen2(struct rsnd_mod *mod)
+{
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        u32 val = rsnd_io_to_mod_dvc(io) ? 0x01 : 0x11;
+
+        rsnd_mod_write(mod, SRC_CTRL, val);
+
+        rsnd_src_error_clear_gen2(mod);
+
+        rsnd_src_start(mod);
+
+        rsnd_src_irq_enable_gen2(mod);
+
+        return 0;
+}
+
+static int _rsnd_src_stop_gen2(struct rsnd_mod *mod)
+{
+        rsnd_src_irq_disable_gen2(mod);
+
+        rsnd_mod_write(mod, SRC_CTRL, 0);
+
+        rsnd_src_error_record_gen2(mod);
+
+        return rsnd_src_stop(mod);
+}
+
+static irqreturn_t rsnd_src_interrupt_gen2(int irq, void *data)
+{
+        struct rsnd_mod *mod = data;
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+
+        if (!io)
+                return IRQ_NONE;
+
+        if (rsnd_src_error_record_gen2(mod)) {
+                struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
+                struct device *dev = rsnd_priv_to_dev(priv);
+
+                _rsnd_src_stop_gen2(mod);
+                _rsnd_src_start_gen2(mod);
+
+                dev_dbg(dev, "%s[%d] restart\n",
+                        rsnd_mod_name(mod), rsnd_mod_id(mod));
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod)
 {
         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
         struct device *dev = rsnd_priv_to_dev(priv);
@@ -535,7 +643,7 @@ static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod,
                 return -EINVAL;
         }
 
-        ret = rsnd_src_set_convert_rate(mod, rdai);
+        ret = rsnd_src_set_convert_rate(mod);
         if (ret < 0)
                 return ret;
 
@@ -563,8 +671,7 @@ static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod,
         return 0;
 }
 
-static int rsnd_src_set_convert_timing_gen2(struct rsnd_mod *mod,
-                                            struct rsnd_dai *rdai)
+static int rsnd_src_set_convert_timing_gen2(struct rsnd_mod *mod)
 {
         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
@@ -573,59 +680,78 @@ static int rsnd_src_set_convert_timing_gen2(struct rsnd_mod *mod,
         int ret;
 
         if (convert_rate)
-                ret = rsnd_adg_set_convert_clk_gen2(mod, rdai, io,
+                ret = rsnd_adg_set_convert_clk_gen2(mod, io,
                                                     runtime->rate,
                                                     convert_rate);
         else
-                ret = rsnd_adg_set_convert_timing_gen2(mod, rdai, io);
+                ret = rsnd_adg_set_convert_timing_gen2(mod, io);
 
         return ret;
 }
 
 static int rsnd_src_probe_gen2(struct rsnd_mod *mod,
-                               struct rsnd_dai *rdai)
+                               struct rsnd_priv *priv)
 {
-        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
         struct rsnd_src *src = rsnd_mod_to_src(mod);
         struct device *dev = rsnd_priv_to_dev(priv);
+        int irq = src->info->irq;
         int ret;
 
+        if (irq > 0) {
+                /*
+                 * IRQ is not supported on non-DT
+                 * see
+                 *      rsnd_src_irq_enable_gen2()
+                 */
+                ret = devm_request_irq(dev, irq,
+                                       rsnd_src_interrupt_gen2,
+                                       IRQF_SHARED,
+                                       dev_name(dev), mod);
+                if (ret)
+                        goto rsnd_src_probe_gen2_fail;
+        }
+
         ret = rsnd_dma_init(priv,
                             rsnd_mod_to_dma(mod),
                             rsnd_info_is_playback(priv, src),
                             src->info->dma_id);
-        if (ret < 0)
-                dev_err(dev, "%s[%d] (Gen2) failed\n",
-                        rsnd_mod_name(mod), rsnd_mod_id(mod));
-        else
-                dev_dbg(dev, "%s[%d] (Gen2) is probed\n",
-                        rsnd_mod_name(mod), rsnd_mod_id(mod));
+        if (ret)
+                goto rsnd_src_probe_gen2_fail;
+
+        dev_dbg(dev, "%s[%d] (Gen2) is probed\n",
+                rsnd_mod_name(mod), rsnd_mod_id(mod));
+
+        return ret;
+
+rsnd_src_probe_gen2_fail:
+        dev_err(dev, "%s[%d] (Gen2) failed\n",
+                rsnd_mod_name(mod), rsnd_mod_id(mod));
 
         return ret;
 }
 
 static int rsnd_src_remove_gen2(struct rsnd_mod *mod,
-                                struct rsnd_dai *rdai)
+                                struct rsnd_priv *priv)
 {
-        rsnd_dma_quit(rsnd_mod_to_priv(mod), rsnd_mod_to_dma(mod));
+        rsnd_dma_quit(priv, rsnd_mod_to_dma(mod));
 
         return 0;
 }
 
 static int rsnd_src_init_gen2(struct rsnd_mod *mod,
-                              struct rsnd_dai *rdai)
+                              struct rsnd_priv *priv)
 {
         int ret;
 
-        ret = rsnd_src_init(mod, rdai);
+        ret = rsnd_src_init(mod);
         if (ret < 0)
                 return ret;
 
-        ret = rsnd_src_set_convert_rate_gen2(mod, rdai);
+        ret = rsnd_src_set_convert_rate_gen2(mod);
         if (ret < 0)
                 return ret;
 
-        ret = rsnd_src_set_convert_timing_gen2(mod, rdai);
+        ret = rsnd_src_set_convert_timing_gen2(mod);
         if (ret < 0)
                 return ret;
 
@@ -633,29 +759,23 @@ static int rsnd_src_init_gen2(struct rsnd_mod *mod,
 }
 
 static int rsnd_src_start_gen2(struct rsnd_mod *mod,
-                               struct rsnd_dai *rdai)
+                               struct rsnd_priv *priv)
 {
-        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
-        struct rsnd_src *src = rsnd_mod_to_src(mod);
-        u32 val = rsnd_io_to_mod_dvc(io) ? 0x01 : 0x11;
-
-        rsnd_dma_start(rsnd_mod_to_dma(&src->mod));
+        rsnd_dma_start(rsnd_mod_to_dma(mod));
 
-        rsnd_mod_write(mod, SRC_CTRL, val);
-
-        return rsnd_src_start(mod);
+        return _rsnd_src_start_gen2(mod);
 }
 
 static int rsnd_src_stop_gen2(struct rsnd_mod *mod,
-                              struct rsnd_dai *rdai)
+                              struct rsnd_priv *priv)
 {
-        struct rsnd_src *src = rsnd_mod_to_src(mod);
+        int ret;
 
-        rsnd_mod_write(mod, SRC_CTRL, 0);
+        ret = _rsnd_src_stop_gen2(mod);
 
-        rsnd_dma_stop(rsnd_mod_to_dma(&src->mod));
+        rsnd_dma_stop(rsnd_mod_to_dma(mod));
 
-        return rsnd_src_stop(mod);
+        return ret;
 }
 
 static struct rsnd_mod_ops rsnd_src_gen2_ops = {
@@ -681,10 +801,11 @@ static void rsnd_of_parse_src(struct platform_device *pdev,
                               struct rsnd_priv *priv)
 {
         struct device_node *src_node;
+        struct device_node *np;
         struct rcar_snd_info *info = rsnd_priv_to_info(priv);
         struct rsnd_src_platform_info *src_info;
         struct device *dev = &pdev->dev;
-        int nr;
+        int nr, i;
 
         if (!of_data)
                 return;
@@ -708,6 +829,13 @@ static void rsnd_of_parse_src(struct platform_device *pdev,
         info->src_info          = src_info;
         info->src_info_nr       = nr;
 
+        i = 0;
+        for_each_child_of_node(src_node, np) {
+                src_info[i].irq = irq_of_parse_and_map(np, 0);
+
+                i++;
+        }
+
 rsnd_of_parse_src_end:
         of_node_put(src_node);
 }
@@ -761,9 +889,8 @@ int rsnd_src_probe(struct platform_device *pdev,
                         return PTR_ERR(clk);
 
                 src->info = &info->src_info[i];
-                src->clk = clk;
 
-                rsnd_mod_init(priv, &src->mod, ops, RSND_MOD_SRC, i);
+                rsnd_mod_init(&src->mod, ops, clk, RSND_MOD_SRC, i);
 
                 dev_dbg(dev, "SRC%d probed\n", i);
         }
diff --git a/sound/soc/sh/rcar/ssi.c b/sound/soc/sh/rcar/ssi.c
index 3844fbef4664..9e7b627c08e2 100644
--- a/sound/soc/sh/rcar/ssi.c
+++ b/sound/soc/sh/rcar/ssi.c
@@ -60,17 +60,14 @@
 #define SSI_NAME "ssi"
 
 struct rsnd_ssi {
-        struct clk *clk;
         struct rsnd_ssi_platform_info *info; /* rcar_snd.h */
         struct rsnd_ssi *parent;
         struct rsnd_mod mod;
 
-        struct rsnd_dai *rdai;
         u32 cr_own;
         u32 cr_clk;
         int err;
         unsigned int usrcnt;
-        unsigned int rate;
 };
 
 #define for_each_rsnd_ssi(pos, priv, i)                                 \
@@ -128,7 +125,7 @@ static void rsnd_ssi_status_check(struct rsnd_mod *mod,
 static int rsnd_ssi_master_clk_start(struct rsnd_ssi *ssi,
                                      struct rsnd_dai_stream *io)
 {
-        struct rsnd_priv *priv = rsnd_mod_to_priv(&ssi->mod);
+        struct rsnd_priv *priv = rsnd_io_to_priv(io);
         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
         struct device *dev = rsnd_priv_to_dev(priv);
         int i, j, ret;
@@ -157,7 +154,6 @@ static int rsnd_ssi_master_clk_start(struct rsnd_ssi *ssi,
 
                         ret = rsnd_adg_ssi_clk_try_start(&ssi->mod, main_rate);
                         if (0 == ret) {
-                                ssi->rate       = rate;
                                 ssi->cr_clk     = FORCE | SWL_32 |
                                                   SCKD | SWSD | CKDV(j);
 
@@ -176,26 +172,25 @@ static int rsnd_ssi_master_clk_start(struct rsnd_ssi *ssi,
 
 static void rsnd_ssi_master_clk_stop(struct rsnd_ssi *ssi)
 {
-        ssi->rate = 0;
         ssi->cr_clk = 0;
         rsnd_adg_ssi_clk_stop(&ssi->mod);
 }
 
 static void rsnd_ssi_hw_start(struct rsnd_ssi *ssi,
-                              struct rsnd_dai *rdai,
                               struct rsnd_dai_stream *io)
 {
-        struct rsnd_priv *priv = rsnd_mod_to_priv(&ssi->mod);
+        struct rsnd_priv *priv = rsnd_io_to_priv(io);
+        struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
         struct device *dev = rsnd_priv_to_dev(priv);
         u32 cr_mode;
         u32 cr;
 
         if (0 == ssi->usrcnt) {
-                clk_prepare_enable(ssi->clk);
+                rsnd_mod_hw_start(&ssi->mod);
 
-                if (rsnd_dai_is_clk_master(rdai)) {
+                if (rsnd_rdai_is_clk_master(rdai)) {
                         if (rsnd_ssi_clk_from_parent(ssi))
-                                rsnd_ssi_hw_start(ssi->parent, rdai, io);
+                                rsnd_ssi_hw_start(ssi->parent, io);
                         else
                                 rsnd_ssi_master_clk_start(ssi, io);
                 }
@@ -214,7 +209,7 @@ static void rsnd_ssi_hw_start(struct rsnd_ssi *ssi,
         rsnd_mod_write(&ssi->mod, SSICR, cr);
 
         /* enable WS continue */
-        if (rsnd_dai_is_clk_master(rdai))
+        if (rsnd_rdai_is_clk_master(rdai))
                 rsnd_mod_write(&ssi->mod, SSIWSR, CONT);
 
         /* clear error status */
@@ -226,10 +221,11 @@ static void rsnd_ssi_hw_start(struct rsnd_ssi *ssi,
                 rsnd_mod_name(&ssi->mod), rsnd_mod_id(&ssi->mod));
 }
 
-static void rsnd_ssi_hw_stop(struct rsnd_ssi *ssi,
-                             struct rsnd_dai *rdai)
+static void rsnd_ssi_hw_stop(struct rsnd_ssi *ssi)
 {
         struct rsnd_priv *priv = rsnd_mod_to_priv(&ssi->mod);
+        struct rsnd_dai_stream *io = rsnd_mod_to_io(&ssi->mod);
+        struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
         struct device *dev = rsnd_priv_to_dev(priv);
         u32 cr;
 
@@ -256,14 +252,14 @@ static void rsnd_ssi_hw_stop(struct rsnd_ssi *ssi,
                 rsnd_mod_write(&ssi->mod, SSICR, cr);   /* disabled all */
                 rsnd_ssi_status_check(&ssi->mod, IIRQ);
 
-                if (rsnd_dai_is_clk_master(rdai)) {
+                if (rsnd_rdai_is_clk_master(rdai)) {
                         if (rsnd_ssi_clk_from_parent(ssi))
-                                rsnd_ssi_hw_stop(ssi->parent, rdai);
+                                rsnd_ssi_hw_stop(ssi->parent);
                         else
                                 rsnd_ssi_master_clk_stop(ssi);
                 }
 
-                clk_disable_unprepare(ssi->clk);
+                rsnd_mod_hw_stop(&ssi->mod);
         }
 
         dev_dbg(dev, "%s[%d] hw stopped\n",
@@ -274,10 +270,11 @@ static void rsnd_ssi_hw_stop(struct rsnd_ssi *ssi,
  *      SSI mod common functions
  */
 static int rsnd_ssi_init(struct rsnd_mod *mod,
-                         struct rsnd_dai *rdai)
+                         struct rsnd_priv *priv)
 {
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
         u32 cr;
 
@@ -311,13 +308,12 @@ static int rsnd_ssi_init(struct rsnd_mod *mod,
                 cr |= SDTA;
         if (rdai->sys_delay)
                 cr |= DEL;
-        if (rsnd_dai_is_play(rdai, io))
+        if (rsnd_io_is_play(io))
                 cr |= TRMD;
 
         /*
          * set ssi parameter
          */
-        ssi->rdai       = rdai;
         ssi->cr_own     = cr;
         ssi->err        = -1; /* ignore 1st error */
 
@@ -325,16 +321,15 @@ static int rsnd_ssi_init(struct rsnd_mod *mod,
 }
 
 static int rsnd_ssi_quit(struct rsnd_mod *mod,
-                         struct rsnd_dai *rdai)
+                         struct rsnd_priv *priv)
 {
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
-        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
         struct device *dev = rsnd_priv_to_dev(priv);
 
         if (ssi->err > 0)
-                dev_warn(dev, "ssi under/over flow err = %d\n", ssi->err);
+                dev_warn(dev, "%s[%d] under/over flow err = %d\n",
+                         rsnd_mod_name(mod), rsnd_mod_id(mod), ssi->err);
 
-        ssi->rdai       = NULL;
         ssi->cr_own     = 0;
         ssi->err        = 0;
 
@@ -353,32 +348,32 @@ static void rsnd_ssi_record_error(struct rsnd_ssi *ssi, u32 status)
 }
 
 static int rsnd_ssi_start(struct rsnd_mod *mod,
-                          struct rsnd_dai *rdai)
+                          struct rsnd_priv *priv)
 {
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
 
-        rsnd_src_ssiu_start(mod, rdai, rsnd_ssi_use_busif(mod));
+        rsnd_src_ssiu_start(mod, rsnd_ssi_use_busif(mod));
 
-        rsnd_ssi_hw_start(ssi, rdai, io);
+        rsnd_ssi_hw_start(ssi, io);
 
-        rsnd_src_ssi_irq_enable(mod, rdai);
+        rsnd_src_ssi_irq_enable(mod);
 
         return 0;
 }
 
 static int rsnd_ssi_stop(struct rsnd_mod *mod,
-                         struct rsnd_dai *rdai)
+                         struct rsnd_priv *priv)
 {
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 
-        rsnd_src_ssi_irq_disable(mod, rdai);
+        rsnd_src_ssi_irq_disable(mod);
 
         rsnd_ssi_record_error(ssi, rsnd_mod_read(mod, SSISR));
 
-        rsnd_ssi_hw_stop(ssi, rdai);
+        rsnd_ssi_hw_stop(ssi);
 
-        rsnd_src_ssiu_stop(mod, rdai);
+        rsnd_src_ssiu_stop(mod);
 
         return 0;
 }
@@ -386,16 +381,17 @@ static int rsnd_ssi_stop(struct rsnd_mod *mod,
 static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
 {
         struct rsnd_ssi *ssi = data;
-        struct rsnd_dai *rdai = ssi->rdai;
         struct rsnd_mod *mod = &ssi->mod;
+        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
+        int is_dma = rsnd_ssi_is_dma_mode(mod);
         u32 status = rsnd_mod_read(mod, SSISR);
 
         if (!io)
                 return IRQ_NONE;
 
         /* PIO only */
-        if (status & DIRQ) {
+        if (!is_dma && (status & DIRQ)) {
                 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
                 u32 *buf = (u32 *)(runtime->dma_area +
                                    rsnd_dai_pointer_offset(io, 0));
@@ -405,7 +401,7 @@ static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
                  * directly as 32bit data
                  * see rsnd_ssi_init()
                  */
-                if (rsnd_dai_is_play(rdai, io))
+                if (rsnd_io_is_play(io))
                         rsnd_mod_write(mod, SSITDR, *buf);
                 else
                         *buf = rsnd_mod_read(mod, SSIRDR);
@@ -415,14 +411,13 @@ static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
 
         /* PIO / DMA */
         if (status & (UIRQ | OIRQ)) {
-                struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
                 struct device *dev = rsnd_priv_to_dev(priv);
 
                 /*
                  * restart SSI
                  */
-                rsnd_ssi_stop(mod, rdai);
-                rsnd_ssi_start(mod, rdai);
+                rsnd_ssi_stop(mod, priv);
+                rsnd_ssi_start(mod, priv);
 
                 dev_dbg(dev, "%s[%d] restart\n",
                         rsnd_mod_name(mod), rsnd_mod_id(mod));
@@ -437,9 +432,8 @@ static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
  *              SSI PIO
  */
 static int rsnd_ssi_pio_probe(struct rsnd_mod *mod,
-                              struct rsnd_dai *rdai)
+                              struct rsnd_priv *priv)
 {
-        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
         struct device *dev = rsnd_priv_to_dev(priv);
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
         int ret;
@@ -468,9 +462,8 @@ static struct rsnd_mod_ops rsnd_ssi_pio_ops = {
 };
 
 static int rsnd_ssi_dma_probe(struct rsnd_mod *mod,
-                          struct rsnd_dai *rdai)
+                              struct rsnd_priv *priv)
 {
-        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
         struct device *dev = rsnd_priv_to_dev(priv);
         int dma_id = ssi->info->dma_id;
@@ -503,14 +496,13 @@ rsnd_ssi_dma_probe_fail:
 }
 
 static int rsnd_ssi_dma_remove(struct rsnd_mod *mod,
-                               struct rsnd_dai *rdai)
+                               struct rsnd_priv *priv)
 {
-        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
         struct device *dev = rsnd_priv_to_dev(priv);
         int irq = ssi->info->irq;
 
-        rsnd_dma_quit(rsnd_mod_to_priv(mod), rsnd_mod_to_dma(mod));
+        rsnd_dma_quit(priv, rsnd_mod_to_dma(mod));
 
         /* PIO will request IRQ again */
         devm_free_irq(dev, irq, ssi);
@@ -519,9 +511,8 @@ static int rsnd_ssi_dma_remove(struct rsnd_mod *mod,
 }
 
 static int rsnd_ssi_fallback(struct rsnd_mod *mod,
-                             struct rsnd_dai *rdai)
+                             struct rsnd_priv *priv)
 {
-        struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
         struct device *dev = rsnd_priv_to_dev(priv);
 
         /*
@@ -540,25 +531,25 @@ static int rsnd_ssi_fallback(struct rsnd_mod *mod,
 }
 
 static int rsnd_ssi_dma_start(struct rsnd_mod *mod,
-                              struct rsnd_dai *rdai)
+                              struct rsnd_priv *priv)
 {
         struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
 
-        rsnd_ssi_start(mod, rdai);
-
         rsnd_dma_start(dma);
 
+        rsnd_ssi_start(mod, priv);
+
         return 0;
 }
 
 static int rsnd_ssi_dma_stop(struct rsnd_mod *mod,
-                             struct rsnd_dai *rdai)
+                             struct rsnd_priv *priv)
 {
         struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
 
-        rsnd_dma_stop(dma);
+        rsnd_ssi_stop(mod, priv);
 
-        rsnd_ssi_stop(mod, rdai);
+        rsnd_dma_stop(dma);
 
         return 0;
 }
@@ -734,7 +725,6 @@ int rsnd_ssi_probe(struct platform_device *pdev,
                         return PTR_ERR(clk);
 
                 ssi->info       = pinfo;
-                ssi->clk        = clk;
 
                 ops = &rsnd_ssi_non_ops;
                 if (pinfo->dma_id > 0)
@@ -742,7 +732,7 @@ int rsnd_ssi_probe(struct platform_device *pdev,
                 else if (rsnd_ssi_pio_available(ssi))
                         ops = &rsnd_ssi_pio_ops;
 
-                rsnd_mod_init(priv, &ssi->mod, ops, RSND_MOD_SSI, i);
+                rsnd_mod_init(&ssi->mod, ops, clk, RSND_MOD_SSI, i);
 
                 rsnd_ssi_parent_clk_setup(priv, ssi);
         }
diff --git a/sound/soc/sh/siu_pcm.c b/sound/soc/sh/siu_pcm.c
index 32eb6da2d2bd..82902f56e82f 100644
--- a/sound/soc/sh/siu_pcm.c
+++ b/sound/soc/sh/siu_pcm.c
@@ -589,7 +589,6 @@ static void siu_pcm_free(struct snd_pcm *pcm)
         tasklet_kill(&port_info->playback.tasklet);
 
         siu_free_port(port_info);
-        snd_pcm_lib_preallocate_free_for_all(pcm);
 
         dev_dbg(pcm->card->dev, "%s\n", __func__);
 }
diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index 2c62620abca6..30579ca5bacb 100644
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -191,6 +191,39 @@ static ssize_t pmdown_time_set(struct device *dev,
 
 static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
 
+static struct attribute *soc_dev_attrs[] = {
+        &dev_attr_codec_reg.attr,
+        &dev_attr_pmdown_time.attr,
+        NULL
+};
+
+static umode_t soc_dev_attr_is_visible(struct kobject *kobj,
+                                       struct attribute *attr, int idx)
+{
+        struct device *dev = kobj_to_dev(kobj);
+        struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
+
+        if (attr == &dev_attr_pmdown_time.attr)
+                return attr->mode; /* always visible */
+        return rtd->codec ? attr->mode : 0; /* enabled only with codec */
+}
+
+static const struct attribute_group soc_dapm_dev_group = {
+        .attrs = soc_dapm_dev_attrs,
+        .is_visible = soc_dev_attr_is_visible,
+};
+
+static const struct attribute_group soc_dev_roup = {
+        .attrs = soc_dev_attrs,
+        .is_visible = soc_dev_attr_is_visible,
+};
+
+static const struct attribute_group *soc_dev_attr_groups[] = {
+        &soc_dapm_dev_group,
+        &soc_dev_roup,
+        NULL
+};
+
 #ifdef CONFIG_DEBUG_FS
 static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
                                    size_t count, loff_t *ppos)
@@ -949,8 +982,6 @@ static void soc_remove_link_dais(struct snd_soc_card *card, int num, int order)
 
         /* unregister the rtd device */
         if (rtd->dev_registered) {
-                device_remove_file(rtd->dev, &dev_attr_pmdown_time);
-                device_remove_file(rtd->dev, &dev_attr_codec_reg);
                 device_unregister(rtd->dev);
                 rtd->dev_registered = 0;
         }
@@ -1120,6 +1151,7 @@ static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
         device_initialize(rtd->dev);
         rtd->dev->parent = rtd->card->dev;
         rtd->dev->release = rtd_release;
+        rtd->dev->groups = soc_dev_attr_groups;
         dev_set_name(rtd->dev, "%s", name);
         dev_set_drvdata(rtd->dev, rtd);
         mutex_init(&rtd->pcm_mutex);
@@ -1136,23 +1168,6 @@ static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
                 return ret;
         }
         rtd->dev_registered = 1;
-
-        if (rtd->codec) {
-                /* add DAPM sysfs entries for this codec */
-                ret = snd_soc_dapm_sys_add(rtd->dev);
-                if (ret < 0)
-                        dev_err(rtd->dev,
-                                "ASoC: failed to add codec dapm sysfs entries: %d\n",
-                                ret);
-
-                /* add codec sysfs entries */
-                ret = device_create_file(rtd->dev, &dev_attr_codec_reg);
-                if (ret < 0)
-                        dev_err(rtd->dev,
-                                "ASoC: failed to add codec sysfs files: %d\n",
-                                ret);
-        }
-
         return 0;
 }
 
@@ -1308,11 +1323,6 @@ static int soc_probe_link_dais(struct snd_soc_card *card, int num, int order)
         }
 #endif
 
-        ret = device_create_file(rtd->dev, &dev_attr_pmdown_time);
-        if (ret < 0)
-                dev_warn(rtd->dev, "ASoC: failed to add pmdown_time sysfs: %d\n",
-                        ret);
-
         if (cpu_dai->driver->compress_dai) {
                 /*create compress_device"*/
                 ret = soc_new_compress(rtd, num);
@@ -1427,11 +1437,76 @@ static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)
         return 0;
 }
 
+/**
+ * snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime
+ * @rtd: The runtime for which the DAI link format should be changed
+ * @dai_fmt: The new DAI link format
+ *
+ * This function updates the DAI link format for all DAIs connected to the DAI
+ * link for the specified runtime.
+ *
+ * Note: For setups with a static format set the dai_fmt field in the
+ * corresponding snd_dai_link struct instead of using this function.
+ *
+ * Returns 0 on success, otherwise a negative error code.
+ */
+int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
+        unsigned int dai_fmt)
+{
+        struct snd_soc_dai **codec_dais = rtd->codec_dais;
+        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
+        unsigned int i;
+        int ret;
+
+        for (i = 0; i < rtd->num_codecs; i++) {
+                struct snd_soc_dai *codec_dai = codec_dais[i];
+
+                ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
+                if (ret != 0 && ret != -ENOTSUPP) {
+                        dev_warn(codec_dai->dev,
+                                 "ASoC: Failed to set DAI format: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        /* Flip the polarity for the "CPU" end of a CODEC<->CODEC link */
+        if (cpu_dai->codec) {
+                unsigned int inv_dai_fmt;
+
+                inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_MASTER_MASK;
+                switch (dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+                case SND_SOC_DAIFMT_CBM_CFM:
+                        inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
+                        break;
+                case SND_SOC_DAIFMT_CBM_CFS:
+                        inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
+                        break;
+                case SND_SOC_DAIFMT_CBS_CFM:
+                        inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
+                        break;
+                case SND_SOC_DAIFMT_CBS_CFS:
+                        inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
+                        break;
+                }
+
+                dai_fmt = inv_dai_fmt;
+        }
+
+        ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt);
+        if (ret != 0 && ret != -ENOTSUPP) {
+                dev_warn(cpu_dai->dev,
+                         "ASoC: Failed to set DAI format: %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
+
 static int snd_soc_instantiate_card(struct snd_soc_card *card)
 {
         struct snd_soc_codec *codec;
-        struct snd_soc_dai_link *dai_link;
-        int ret, i, order, dai_fmt;
+        int ret, i, order;
 
         mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
 
@@ -1542,60 +1617,9 @@ static int snd_soc_instantiate_card(struct snd_soc_card *card)
                                         card->num_dapm_routes);
 
         for (i = 0; i < card->num_links; i++) {
-                struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
-                dai_link = &card->dai_link[i];
-                dai_fmt = dai_link->dai_fmt;
-
-                if (dai_fmt) {
-                        struct snd_soc_dai **codec_dais = rtd->codec_dais;
-                        int j;
-
-                        for (j = 0; j < rtd->num_codecs; j++) {
-                                struct snd_soc_dai *codec_dai = codec_dais[j];
-
-                                ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
-                                if (ret != 0 && ret != -ENOTSUPP)
-                                        dev_warn(codec_dai->dev,
-                                                 "ASoC: Failed to set DAI format: %d\n",
-                                                 ret);
-                        }
-                }
-
-                /* If this is a regular CPU link there will be a platform */
-                if (dai_fmt &&
-                    (dai_link->platform_name || dai_link->platform_of_node)) {
-                        ret = snd_soc_dai_set_fmt(card->rtd[i].cpu_dai,
-                                                  dai_fmt);
-                        if (ret != 0 && ret != -ENOTSUPP)
-                                dev_warn(card->rtd[i].cpu_dai->dev,
-                                         "ASoC: Failed to set DAI format: %d\n",
-                                         ret);
-                } else if (dai_fmt) {
-                        /* Flip the polarity for the "CPU" end */
-                        dai_fmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
-                        switch (dai_link->dai_fmt &
-                                SND_SOC_DAIFMT_MASTER_MASK) {
-                        case SND_SOC_DAIFMT_CBM_CFM:
-                                dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
-                                break;
-                        case SND_SOC_DAIFMT_CBM_CFS:
-                                dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
-                                break;
-                        case SND_SOC_DAIFMT_CBS_CFM:
-                                dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
-                                break;
-                        case SND_SOC_DAIFMT_CBS_CFS:
-                                dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
-                                break;
-                        }
-
-                        ret = snd_soc_dai_set_fmt(card->rtd[i].cpu_dai,
-                                                  dai_fmt);
-                        if (ret != 0 && ret != -ENOTSUPP)
-                                dev_warn(card->rtd[i].cpu_dai->dev,
-                                         "ASoC: Failed to set DAI format: %d\n",
-                                         ret);
-                }
+                if (card->dai_link[i].dai_fmt)
+                        snd_soc_runtime_set_dai_fmt(&card->rtd[i],
+                                card->dai_link[i].dai_fmt);
         }
 
         snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
@@ -1626,9 +1650,6 @@ static int snd_soc_instantiate_card(struct snd_soc_card *card)
                 }
         }
 
-        if (card->fully_routed)
-                snd_soc_dapm_auto_nc_pins(card);
-
         snd_soc_dapm_new_widgets(card);
 
         ret = snd_card_register(card->snd_card);
@@ -2119,15 +2140,27 @@ static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
 }
 
 /**
- * snd_soc_dai_set_tdm_slot - configure DAI TDM.
- * @dai: DAI
+ * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
+ * @dai: The DAI to configure
  * @tx_mask: bitmask representing active TX slots.
  * @rx_mask: bitmask representing active RX slots.
  * @slots: Number of slots in use.
  * @slot_width: Width in bits for each slot.
  *
- * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
- * specific.
+ * This function configures the specified DAI for TDM operation. @slot contains
+ * the total number of slots of the TDM stream and @slot_with the width of each
+ * slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
+ * active slots of the TDM stream for the specified DAI, i.e. which slots the
+ * DAI should write to or read from. If a bit is set the corresponding slot is
+ * active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
+ * the first slot, bit 1 to the second slot and so on. The first active slot
+ * maps to the first channel of the DAI, the second active slot to the second
+ * channel and so on.
+ *
+ * TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
+ * @rx_mask and @slot_width will be ignored.
+ *
+ * Returns 0 on success, a negative error code otherwise.
  */
 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
         unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
@@ -2386,8 +2419,8 @@ int snd_soc_unregister_card(struct snd_soc_card *card)
                 card->instantiated = false;
                 snd_soc_dapm_shutdown(card);
                 soc_cleanup_card_resources(card);
+                dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
         }
-        dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
 
         return 0;
 }
diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
index c5136bb1f982..b6f88202b8c9 100644
--- a/sound/soc/soc-dapm.c
+++ b/sound/soc/soc-dapm.c
@@ -517,8 +517,8 @@ static int soc_dapm_update_bits(struct snd_soc_dapm_context *dapm,
 {
         if (!dapm->component)
                 return -EIO;
-        return snd_soc_component_update_bits_async(dapm->component, reg,
-                mask, value);
+        return snd_soc_component_update_bits(dapm->component, reg,
+                                             mask, value);
 }
 
 static int soc_dapm_test_bits(struct snd_soc_dapm_context *dapm,
@@ -2127,15 +2127,10 @@ static ssize_t dapm_widget_show(struct device *dev,
 
 static DEVICE_ATTR(dapm_widget, 0444, dapm_widget_show, NULL);
 
-int snd_soc_dapm_sys_add(struct device *dev)
-{
-        return device_create_file(dev, &dev_attr_dapm_widget);
-}
-
-static void snd_soc_dapm_sys_remove(struct device *dev)
-{
-        device_remove_file(dev, &dev_attr_dapm_widget);
-}
+struct attribute *soc_dapm_dev_attrs[] = {
+        &dev_attr_dapm_widget.attr,
+        NULL
+};
 
 static void dapm_free_path(struct snd_soc_dapm_path *path)
 {
@@ -2279,6 +2274,9 @@ static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
 
         switch (w->id) {
         case snd_soc_dapm_input:
+                /* On a fully routed card a input is never a source */
+                if (w->dapm->card->fully_routed)
+                        break;
                 w->is_source = 1;
                 list_for_each_entry(p, &w->sources, list_sink) {
                         if (p->source->id == snd_soc_dapm_micbias ||
@@ -2291,6 +2289,9 @@ static void dapm_update_widget_flags(struct snd_soc_dapm_widget *w)
                 }
                 break;
         case snd_soc_dapm_output:
+                /* On a fully routed card a output is never a sink */
+                if (w->dapm->card->fully_routed)
+                        break;
                 w->is_sink = 1;
                 list_for_each_entry(p, &w->sinks, list_source) {
                         if (p->sink->id == snd_soc_dapm_spk ||
@@ -3085,16 +3086,24 @@ snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
 
         switch (w->id) {
         case snd_soc_dapm_mic:
-        case snd_soc_dapm_input:
                 w->is_source = 1;
                 w->power_check = dapm_generic_check_power;
                 break;
+        case snd_soc_dapm_input:
+                if (!dapm->card->fully_routed)
+                        w->is_source = 1;
+                w->power_check = dapm_generic_check_power;
+                break;
         case snd_soc_dapm_spk:
         case snd_soc_dapm_hp:
-        case snd_soc_dapm_output:
                 w->is_sink = 1;
                 w->power_check = dapm_generic_check_power;
                 break;
+        case snd_soc_dapm_output:
+                if (!dapm->card->fully_routed)
+                        w->is_sink = 1;
+                w->power_check = dapm_generic_check_power;
+                break;
         case snd_soc_dapm_vmid:
         case snd_soc_dapm_siggen:
                 w->is_source = 1;
@@ -3130,8 +3139,6 @@ snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm,
         }
 
         w->dapm = dapm;
-        if (dapm->component)
-                w->codec = dapm->component->codec;
         INIT_LIST_HEAD(&w->sources);
         INIT_LIST_HEAD(&w->sinks);
         INIT_LIST_HEAD(&w->list);
@@ -3809,93 +3816,6 @@ int snd_soc_dapm_ignore_suspend(struct snd_soc_dapm_context *dapm,
 EXPORT_SYMBOL_GPL(snd_soc_dapm_ignore_suspend);
 
 /**
- * dapm_is_external_path() - Checks if a path is a external path
- * @card: The card the path belongs to
- * @path: The path to check
- *
- * Returns true if the path is either between two different DAPM contexts or
- * between two external pins of the same DAPM context. Otherwise returns
- * false.
- */
-static bool dapm_is_external_path(struct snd_soc_card *card,
-        struct snd_soc_dapm_path *path)
-{
-        dev_dbg(card->dev,
-                "... Path %s(id:%d dapm:%p) - %s(id:%d dapm:%p)\n",
-                path->source->name, path->source->id, path->source->dapm,
-                path->sink->name, path->sink->id, path->sink->dapm);
-
-        /* Connection between two different DAPM contexts */
-        if (path->source->dapm != path->sink->dapm)
-                return true;
-
-        /* Loopback connection from external pin to external pin */
-        if (path->sink->id == snd_soc_dapm_input) {
-                switch (path->source->id) {
-                case snd_soc_dapm_output:
-                case snd_soc_dapm_micbias:
-                        return true;
-                default:
-                        break;
-                }
-        }
-
-        return false;
-}
-
-static bool snd_soc_dapm_widget_in_card_paths(struct snd_soc_card *card,
-                                              struct snd_soc_dapm_widget *w)
-{
-        struct snd_soc_dapm_path *p;
-
-        list_for_each_entry(p, &w->sources, list_sink) {
-                if (dapm_is_external_path(card, p))
-                        return true;
-        }
-
-        list_for_each_entry(p, &w->sinks, list_source) {
-                if (dapm_is_external_path(card, p))
-                        return true;
-        }
-
-        return false;
-}
-
-/**
- * snd_soc_dapm_auto_nc_pins - call snd_soc_dapm_nc_pin for unused pins
- * @card: The card whose pins should be processed
- *
- * Automatically call snd_soc_dapm_nc_pin() for any external pins in the card
- * which are unused. Pins are used if they are connected externally to a
- * component, whether that be to some other device, or a loop-back connection to
- * the component itself.
- */
-void snd_soc_dapm_auto_nc_pins(struct snd_soc_card *card)
-{
-        struct snd_soc_dapm_widget *w;
-
-        dev_dbg(card->dev, "ASoC: Auto NC: DAPMs: card:%p\n", &card->dapm);
-
-        list_for_each_entry(w, &card->widgets, list) {
-                switch (w->id) {
-                case snd_soc_dapm_input:
-                case snd_soc_dapm_output:
-                case snd_soc_dapm_micbias:
-                        dev_dbg(card->dev, "ASoC: Auto NC: Checking widget %s\n",
-                                w->name);
-                        if (!snd_soc_dapm_widget_in_card_paths(card, w)) {
-                                dev_dbg(card->dev,
-                                        "... Not in map; disabling\n");
-                                snd_soc_dapm_nc_pin(w->dapm, w->name);
-                        }
-                        break;
-                default:
-                        break;
-                }
-        }
-}
-
-/**
  * snd_soc_dapm_free - free dapm resources
  * @dapm: DAPM context
  *
@@ -3903,7 +3823,6 @@ void snd_soc_dapm_auto_nc_pins(struct snd_soc_card *card)
  */
 void snd_soc_dapm_free(struct snd_soc_dapm_context *dapm)
 {
-        snd_soc_dapm_sys_remove(dapm->dev);
         dapm_debugfs_cleanup(dapm);
         dapm_free_widgets(dapm);
         list_del(&dapm->list);
diff --git a/sound/soc/soc-devres.c b/sound/soc/soc-devres.c
index 057e5ef7dcce..a57921eeee81 100644
--- a/sound/soc/soc-devres.c
+++ b/sound/soc/soc-devres.c
@@ -60,7 +60,7 @@ static void devm_platform_release(struct device *dev, void *res)
 /**
  * devm_snd_soc_register_platform - resource managed platform registration
  * @dev: Device used to manage platform
- * @platform: platform to register
+ * @platform_drv: platform to register
  *
  * Register a platform driver with automatic unregistration when the device is
  * unregistered.
diff --git a/sound/soc/soc-generic-dmaengine-pcm.c b/sound/soc/soc-generic-dmaengine-pcm.c
index b329b84bc5af..c9917ca5de1a 100644
--- a/sound/soc/soc-generic-dmaengine-pcm.c
+++ b/sound/soc/soc-generic-dmaengine-pcm.c
@@ -151,7 +151,7 @@ static int dmaengine_pcm_set_runtime_hwparams(struct snd_pcm_substream *substrea
                         hw.info |= SNDRV_PCM_INFO_BATCH;
 
                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                        addr_widths = dma_caps.dstn_addr_widths;
+                        addr_widths = dma_caps.dst_addr_widths;
                 else
                         addr_widths = dma_caps.src_addr_widths;
         }
@@ -200,11 +200,6 @@ static int dmaengine_pcm_open(struct snd_pcm_substream *substream)
         return snd_dmaengine_pcm_open(substream, chan);
 }
 
-static void dmaengine_pcm_free(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 static struct dma_chan *dmaengine_pcm_compat_request_channel(
         struct snd_soc_pcm_runtime *rtd,
         struct snd_pcm_substream *substream)
@@ -283,8 +278,7 @@ static int dmaengine_pcm_new(struct snd_soc_pcm_runtime *rtd)
                 if (!pcm->chan[i]) {
                         dev_err(rtd->platform->dev,
                                 "Missing dma channel for stream: %d\n", i);
-                        ret = -EINVAL;
-                        goto err_free;
+                        return -EINVAL;
                 }
 
                 ret = snd_pcm_lib_preallocate_pages(substream,
@@ -293,7 +287,7 @@ static int dmaengine_pcm_new(struct snd_soc_pcm_runtime *rtd)
                                 prealloc_buffer_size,
                                 max_buffer_size);
                 if (ret)
-                        goto err_free;
+                        return ret;
 
                 /*
                  * This will only return false if we know for sure that at least
@@ -307,10 +301,6 @@ static int dmaengine_pcm_new(struct snd_soc_pcm_runtime *rtd)
         }
 
         return 0;
-
-err_free:
-        dmaengine_pcm_free(rtd->pcm);
-        return ret;
 }
 
 static snd_pcm_uframes_t dmaengine_pcm_pointer(
@@ -341,7 +331,6 @@ static const struct snd_soc_platform_driver dmaengine_pcm_platform = {
         },
         .ops            = &dmaengine_pcm_ops,
         .pcm_new        = dmaengine_pcm_new,
-        .pcm_free       = dmaengine_pcm_free,
 };
 
 static const char * const dmaengine_pcm_dma_channel_names[] = {
diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c
index eb87d96e2cf0..6b0136e7cb88 100644
--- a/sound/soc/soc-pcm.c
+++ b/sound/soc/soc-pcm.c
@@ -301,34 +301,18 @@ static bool soc_pcm_has_symmetry(struct snd_pcm_substream *substream)
         return symmetry;
 }
 
-/*
- * List of sample sizes that might go over the bus for parameter
- * application.  There ought to be a wildcard sample size for things
- * like the DAC/ADC resolution to use but there isn't right now.
- */
-static int sample_sizes[] = {
-        24, 32,
-};
-
 static void soc_pcm_set_msb(struct snd_pcm_substream *substream, int bits)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
-        int ret, i;
+        int ret;
 
         if (!bits)
                 return;
 
-        for (i = 0; i < ARRAY_SIZE(sample_sizes); i++) {
-                if (bits >= sample_sizes[i])
-                        continue;
-
-                ret = snd_pcm_hw_constraint_msbits(substream->runtime, 0,
-                                                   sample_sizes[i], bits);
-                if (ret != 0)
-                        dev_warn(rtd->dev,
-                                 "ASoC: Failed to set MSB %d/%d: %d\n",
-                                 bits, sample_sizes[i], ret);
-        }
+        ret = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 0, bits);
+        if (ret != 0)
+                dev_warn(rtd->dev, "ASoC: Failed to set MSB %d: %d\n",
+                                 bits, ret);
 }
 
 static void soc_pcm_apply_msb(struct snd_pcm_substream *substream)
@@ -746,7 +730,8 @@ static int soc_pcm_prepare(struct snd_pcm_substream *substream)
                                                               codec_dai);
                         if (ret < 0) {
                                 dev_err(codec_dai->dev,
-                                        "ASoC: DAI prepare error: %d\n", ret);
+                                        "ASoC: codec DAI prepare error: %d\n",
+                                        ret);
                                 goto out;
                         }
                 }
@@ -755,8 +740,8 @@ static int soc_pcm_prepare(struct snd_pcm_substream *substream)
         if (cpu_dai->driver->ops && cpu_dai->driver->ops->prepare) {
                 ret = cpu_dai->driver->ops->prepare(substream, cpu_dai);
                 if (ret < 0) {
-                        dev_err(cpu_dai->dev, "ASoC: DAI prepare error: %d\n",
-                                ret);
+                        dev_err(cpu_dai->dev,
+                                "ASoC: cpu DAI prepare error: %d\n", ret);
                         goto out;
                 }
         }
diff --git a/sound/soc/tegra/Kconfig b/sound/soc/tegra/Kconfig
index 31198cf7f88d..a6768f832c6f 100644
--- a/sound/soc/tegra/Kconfig
+++ b/sound/soc/tegra/Kconfig
@@ -128,3 +128,13 @@ config SND_SOC_TEGRA_MAX98090
         help
           Say Y or M here if you want to add support for SoC audio on Tegra
           boards using the MAX98090 codec, such as Venice2.
+
+config SND_SOC_TEGRA_RT5677
+        tristate "SoC Audio support for Tegra boards using a RT5677 codec"
+        depends on SND_SOC_TEGRA && I2C && GPIOLIB
+        select SND_SOC_TEGRA20_I2S if ARCH_TEGRA_2x_SOC
+        select SND_SOC_TEGRA30_I2S if ARCH_TEGRA_3x_SOC
+        select SND_SOC_RT5677
+        help
+          Say Y or M here if you want to add support for SoC audio on Tegra
+          boards using the RT5677 codec, such as Ryu.
diff --git a/sound/soc/tegra/Makefile b/sound/soc/tegra/Makefile
index 5ae588cd96c4..9171655ad843 100644
--- a/sound/soc/tegra/Makefile
+++ b/sound/soc/tegra/Makefile
@@ -19,6 +19,7 @@ obj-$(CONFIG_SND_SOC_TEGRA30_I2S) += snd-soc-tegra30-i2s.o
 
 # Tegra machine Support
 snd-soc-tegra-rt5640-objs := tegra_rt5640.o
+snd-soc-tegra-rt5677-objs := tegra_rt5677.o
 snd-soc-tegra-wm8753-objs := tegra_wm8753.o
 snd-soc-tegra-wm8903-objs := tegra_wm8903.o
 snd-soc-tegra-wm9712-objs := tegra_wm9712.o
@@ -27,6 +28,7 @@ snd-soc-tegra-alc5632-objs := tegra_alc5632.o
 snd-soc-tegra-max98090-objs := tegra_max98090.o
 
 obj-$(CONFIG_SND_SOC_TEGRA_RT5640) += snd-soc-tegra-rt5640.o
+obj-$(CONFIG_SND_SOC_TEGRA_RT5677) += snd-soc-tegra-rt5677.o
 obj-$(CONFIG_SND_SOC_TEGRA_WM8753) += snd-soc-tegra-wm8753.o
 obj-$(CONFIG_SND_SOC_TEGRA_WM8903) += snd-soc-tegra-wm8903.o
 obj-$(CONFIG_SND_SOC_TEGRA_WM9712) += snd-soc-tegra-wm9712.o
diff --git a/sound/soc/tegra/tegra_rt5677.c b/sound/soc/tegra/tegra_rt5677.c
new file mode 100644
index 000000000000..e4cf978a6e3a
--- /dev/null
+++ b/sound/soc/tegra/tegra_rt5677.c
@@ -0,0 +1,347 @@
+/*
+* tegra_rt5677.c - Tegra machine ASoC driver for boards using RT5677 codec.
+ *
+ * Copyright (c) 2014, The Chromium OS Authors.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Based on code copyright/by:
+ *
+ * Copyright (C) 2010-2012 - NVIDIA, Inc.
+ * Copyright (C) 2011 The AC100 Kernel Team <ac100@lists.lauchpad.net>
+ * (c) 2009, 2010 Nvidia Graphics Pvt. Ltd.
+ * Copyright 2007 Wolfson Microelectronics PLC.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/of_gpio.h>
+
+#include <sound/core.h>
+#include <sound/jack.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+
+#include "../codecs/rt5677.h"
+
+#include "tegra_asoc_utils.h"
+
+#define DRV_NAME "tegra-snd-rt5677"
+
+struct tegra_rt5677 {
+        struct tegra_asoc_utils_data util_data;
+        int gpio_hp_det;
+        int gpio_hp_en;
+        int gpio_mic_present;
+        int gpio_dmic_clk_en;
+};
+
+static int tegra_rt5677_asoc_hw_params(struct snd_pcm_substream *substream,
+                                        struct snd_pcm_hw_params *params)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *codec_dai = rtd->codec_dai;
+        struct snd_soc_card *card = rtd->card;
+        struct tegra_rt5677 *machine = snd_soc_card_get_drvdata(card);
+        int srate, mclk, err;
+
+        srate = params_rate(params);
+        mclk = 256 * srate;
+
+        err = tegra_asoc_utils_set_rate(&machine->util_data, srate, mclk);
+        if (err < 0) {
+                dev_err(card->dev, "Can't configure clocks\n");
+                return err;
+        }
+
+        err = snd_soc_dai_set_sysclk(codec_dai, RT5677_SCLK_S_MCLK, mclk,
+                                        SND_SOC_CLOCK_IN);
+        if (err < 0) {
+                dev_err(card->dev, "codec_dai clock not set\n");
+                return err;
+        }
+
+        return 0;
+}
+
+static int tegra_rt5677_event_hp(struct snd_soc_dapm_widget *w,
+                        struct snd_kcontrol *k, int event)
+{
+        struct snd_soc_dapm_context *dapm = w->dapm;
+        struct snd_soc_card *card = dapm->card;
+        struct tegra_rt5677 *machine = snd_soc_card_get_drvdata(card);
+
+        if (!gpio_is_valid(machine->gpio_hp_en))
+                return 0;
+
+        gpio_set_value_cansleep(machine->gpio_hp_en,
+                SND_SOC_DAPM_EVENT_ON(event));
+
+        return 0;
+}
+
+static struct snd_soc_ops tegra_rt5677_ops = {
+        .hw_params = tegra_rt5677_asoc_hw_params,
+};
+
+static struct snd_soc_jack tegra_rt5677_hp_jack;
+
+static struct snd_soc_jack_pin tegra_rt5677_hp_jack_pins = {
+        .pin = "Headphone",
+        .mask = SND_JACK_HEADPHONE,
+};
+static struct snd_soc_jack_gpio tegra_rt5677_hp_jack_gpio = {
+        .name = "Headphone detection",
+        .report = SND_JACK_HEADPHONE,
+        .debounce_time = 150,
+};
+
+static struct snd_soc_jack tegra_rt5677_mic_jack;
+
+static struct snd_soc_jack_pin tegra_rt5677_mic_jack_pins = {
+        .pin = "Headset Mic",
+        .mask = SND_JACK_MICROPHONE,
+};
+
+static struct snd_soc_jack_gpio tegra_rt5677_mic_jack_gpio = {
+        .name = "Headset Mic detection",
+        .report = SND_JACK_MICROPHONE,
+        .debounce_time = 150,
+        .invert = 1
+};
+
+static const struct snd_soc_dapm_widget tegra_rt5677_dapm_widgets[] = {
+        SND_SOC_DAPM_SPK("Speaker", NULL),
+        SND_SOC_DAPM_HP("Headphone", tegra_rt5677_event_hp),
+        SND_SOC_DAPM_MIC("Headset Mic", NULL),
+        SND_SOC_DAPM_MIC("Internal Mic 1", NULL),
+        SND_SOC_DAPM_MIC("Internal Mic 2", NULL),
+};
+
+static const struct snd_kcontrol_new tegra_rt5677_controls[] = {
+        SOC_DAPM_PIN_SWITCH("Speaker"),
+        SOC_DAPM_PIN_SWITCH("Headphone"),
+        SOC_DAPM_PIN_SWITCH("Headset Mic"),
+        SOC_DAPM_PIN_SWITCH("Internal Mic 1"),
+        SOC_DAPM_PIN_SWITCH("Internal Mic 2"),
+};
+
+static int tegra_rt5677_asoc_init(struct snd_soc_pcm_runtime *rtd)
+{
+        struct snd_soc_dai *codec_dai = rtd->codec_dai;
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct snd_soc_dapm_context *dapm = &codec->dapm;
+        struct tegra_rt5677 *machine = snd_soc_card_get_drvdata(rtd->card);
+
+        snd_soc_jack_new(codec, "Headphone Jack", SND_JACK_HEADPHONE,
+                        &tegra_rt5677_hp_jack);
+        snd_soc_jack_add_pins(&tegra_rt5677_hp_jack, 1,
+                        &tegra_rt5677_hp_jack_pins);
+
+        if (gpio_is_valid(machine->gpio_hp_det)) {
+                tegra_rt5677_hp_jack_gpio.gpio = machine->gpio_hp_det;
+                snd_soc_jack_add_gpios(&tegra_rt5677_hp_jack, 1,
+                                &tegra_rt5677_hp_jack_gpio);
+        }
+
+
+        snd_soc_jack_new(codec, "Mic Jack", SND_JACK_MICROPHONE,
+                        &tegra_rt5677_mic_jack);
+        snd_soc_jack_add_pins(&tegra_rt5677_mic_jack, 1,
+                        &tegra_rt5677_mic_jack_pins);
+
+        if (gpio_is_valid(machine->gpio_mic_present)) {
+                tegra_rt5677_mic_jack_gpio.gpio = machine->gpio_mic_present;
+                snd_soc_jack_add_gpios(&tegra_rt5677_mic_jack, 1,
+                                &tegra_rt5677_mic_jack_gpio);
+        }
+
+        snd_soc_dapm_force_enable_pin(dapm, "MICBIAS1");
+
+        return 0;
+}
+
+static int tegra_rt5677_card_remove(struct snd_soc_card *card)
+{
+        struct tegra_rt5677 *machine = snd_soc_card_get_drvdata(card);
+
+        if (gpio_is_valid(machine->gpio_hp_det)) {
+                snd_soc_jack_free_gpios(&tegra_rt5677_hp_jack, 1,
+                                &tegra_rt5677_hp_jack_gpio);
+        }
+
+        if (gpio_is_valid(machine->gpio_mic_present)) {
+                snd_soc_jack_free_gpios(&tegra_rt5677_mic_jack, 1,
+                                &tegra_rt5677_mic_jack_gpio);
+        }
+
+        return 0;
+}
+
+static struct snd_soc_dai_link tegra_rt5677_dai = {
+        .name = "RT5677",
+        .stream_name = "RT5677 PCM",
+        .codec_dai_name = "rt5677-aif1",
+        .init = tegra_rt5677_asoc_init,
+        .ops = &tegra_rt5677_ops,
+        .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                        SND_SOC_DAIFMT_CBS_CFS,
+};
+
+static struct snd_soc_card snd_soc_tegra_rt5677 = {
+        .name = "tegra-rt5677",
+        .owner = THIS_MODULE,
+        .remove = tegra_rt5677_card_remove,
+        .dai_link = &tegra_rt5677_dai,
+        .num_links = 1,
+        .controls = tegra_rt5677_controls,
+        .num_controls = ARRAY_SIZE(tegra_rt5677_controls),
+        .dapm_widgets = tegra_rt5677_dapm_widgets,
+        .num_dapm_widgets = ARRAY_SIZE(tegra_rt5677_dapm_widgets),
+        .fully_routed = true,
+};
+
+static int tegra_rt5677_probe(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct snd_soc_card *card = &snd_soc_tegra_rt5677;
+        struct tegra_rt5677 *machine;
+        int ret;
+
+        machine = devm_kzalloc(&pdev->dev,
+                        sizeof(struct tegra_rt5677), GFP_KERNEL);
+        if (!machine)
+                return -ENOMEM;
+
+        card->dev = &pdev->dev;
+        platform_set_drvdata(pdev, card);
+        snd_soc_card_set_drvdata(card, machine);
+
+        machine->gpio_hp_det = of_get_named_gpio(np, "nvidia,hp-det-gpios", 0);
+        if (machine->gpio_hp_det == -EPROBE_DEFER)
+                return -EPROBE_DEFER;
+
+        machine->gpio_mic_present = of_get_named_gpio(np,
+                        "nvidia,mic-present-gpios", 0);
+        if (machine->gpio_mic_present == -EPROBE_DEFER)
+                return -EPROBE_DEFER;
+
+        machine->gpio_hp_en = of_get_named_gpio(np, "nvidia,hp-en-gpios", 0);
+        if (machine->gpio_hp_en == -EPROBE_DEFER)
+                return -EPROBE_DEFER;
+        if (gpio_is_valid(machine->gpio_hp_en)) {
+                ret = devm_gpio_request_one(&pdev->dev, machine->gpio_hp_en,
+                                GPIOF_OUT_INIT_LOW, "hp_en");
+                if (ret) {
+                        dev_err(card->dev, "cannot get hp_en gpio\n");
+                        return ret;
+                }
+        }
+
+        machine->gpio_dmic_clk_en = of_get_named_gpio(np,
+                "nvidia,dmic-clk-en-gpios", 0);
+        if (machine->gpio_dmic_clk_en == -EPROBE_DEFER)
+                return -EPROBE_DEFER;
+        if (gpio_is_valid(machine->gpio_dmic_clk_en)) {
+                ret = devm_gpio_request_one(&pdev->dev,
+                                machine->gpio_dmic_clk_en,
+                                GPIOF_OUT_INIT_HIGH, "dmic_clk_en");
+                if (ret) {
+                        dev_err(card->dev, "cannot get dmic_clk_en gpio\n");
+                        return ret;
+                }
+        }
+
+        ret = snd_soc_of_parse_card_name(card, "nvidia,model");
+        if (ret)
+                goto err;
+
+        ret = snd_soc_of_parse_audio_routing(card, "nvidia,audio-routing");
+        if (ret)
+                goto err;
+
+        tegra_rt5677_dai.codec_of_node = of_parse_phandle(np,
+                        "nvidia,audio-codec", 0);
+        if (!tegra_rt5677_dai.codec_of_node) {
+                dev_err(&pdev->dev,
+                        "Property 'nvidia,audio-codec' missing or invalid\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        tegra_rt5677_dai.cpu_of_node = of_parse_phandle(np,
+                        "nvidia,i2s-controller", 0);
+        if (!tegra_rt5677_dai.cpu_of_node) {
+                dev_err(&pdev->dev,
+                        "Property 'nvidia,i2s-controller' missing or invalid\n");
+                ret = -EINVAL;
+                goto err;
+        }
+        tegra_rt5677_dai.platform_of_node = tegra_rt5677_dai.cpu_of_node;
+
+        ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);
+        if (ret)
+                goto err;
+
+        ret = snd_soc_register_card(card);
+        if (ret) {
+                dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
+                        ret);
+                goto err_fini_utils;
+        }
+
+        return 0;
+
+err_fini_utils:
+        tegra_asoc_utils_fini(&machine->util_data);
+err:
+        return ret;
+}
+
+static int tegra_rt5677_remove(struct platform_device *pdev)
+{
+        struct snd_soc_card *card = platform_get_drvdata(pdev);
+        struct tegra_rt5677 *machine = snd_soc_card_get_drvdata(card);
+
+        snd_soc_unregister_card(card);
+
+        tegra_asoc_utils_fini(&machine->util_data);
+
+        return 0;
+}
+
+static const struct of_device_id tegra_rt5677_of_match[] = {
+        { .compatible = "nvidia,tegra-audio-rt5677", },
+        {},
+};
+
+static struct platform_driver tegra_rt5677_driver = {
+        .driver = {
+                .name = DRV_NAME,
+                .owner = THIS_MODULE,
+                .pm = &snd_soc_pm_ops,
+                .of_match_table = tegra_rt5677_of_match,
+        },
+        .probe = tegra_rt5677_probe,
+        .remove = tegra_rt5677_remove,
+};
+module_platform_driver(tegra_rt5677_driver);
+
+MODULE_AUTHOR("Anatol Pomozov <anatol@google.com>");
+MODULE_DESCRIPTION("Tegra+RT5677 machine ASoC driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" DRV_NAME);
+MODULE_DEVICE_TABLE(of, tegra_rt5677_of_match);
diff --git a/sound/soc/txx9/txx9aclc.c b/sound/soc/txx9/txx9aclc.c
index 070e44e251ce..88eacfd83da6 100644
--- a/sound/soc/txx9/txx9aclc.c
+++ b/sound/soc/txx9/txx9aclc.c
@@ -282,11 +282,6 @@ static struct snd_pcm_ops txx9aclc_pcm_ops = {
         .pointer        = txx9aclc_pcm_pointer,
 };
 
-static void txx9aclc_pcm_free_dma_buffers(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 static int txx9aclc_pcm_new(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_card *card = rtd->card->snd_card;
@@ -412,7 +407,6 @@ static struct snd_soc_platform_driver txx9aclc_soc_platform = {
         .remove         = txx9aclc_pcm_remove,
         .ops            = &txx9aclc_pcm_ops,
         .pcm_new        = txx9aclc_pcm_new,
-        .pcm_free       = txx9aclc_pcm_free_dma_buffers,
 };
 
 static int txx9aclc_soc_platform_probe(struct platform_device *pdev)
diff --git a/sound/soc/ux500/mop500_ab8500.c b/sound/soc/ux500/mop500_ab8500.c
index be4f1ac7cd5e..aa65370db82a 100644
--- a/sound/soc/ux500/mop500_ab8500.c
+++ b/sound/soc/ux500/mop500_ab8500.c
@@ -290,21 +290,9 @@ static int mop500_ab8500_hw_params(struct snd_pcm_substream *substream,
                         SND_SOC_DAIFMT_GATED;
         }
 
-        ret = snd_soc_dai_set_fmt(codec_dai, fmt);
-        if (ret < 0) {
-                dev_err(dev,
-                        "%s: ERROR: snd_soc_dai_set_fmt failed for codec_dai (ret = %d)!\n",
-                        __func__, ret);
-                return ret;
-        }
-
-        ret = snd_soc_dai_set_fmt(cpu_dai, fmt);
-        if (ret < 0) {
-                dev_err(dev,
-                        "%s: ERROR: snd_soc_dai_set_fmt failed for cpu_dai (ret = %d)!\n",
-                        __func__, ret);
+        ret = snd_soc_runtime_set_dai_fmt(rtd, fmt);
+        if (ret)
                 return ret;
-        }
 
         /* Setup TDM-slots */
 
diff --git a/sound/soc/xtensa/Kconfig b/sound/soc/xtensa/Kconfig
new file mode 100644
index 000000000000..c201beb36de6
--- /dev/null
+++ b/sound/soc/xtensa/Kconfig
@@ -0,0 +1,7 @@
+config SND_SOC_XTFPGA_I2S
+        tristate "XTFPGA I2S master"
+        select REGMAP_MMIO
+        help
+          Say Y or M if you want to add support for codecs attached to the
+          I2S interface on XTFPGA daughter board. You will also need to select
+          the drivers for the rest of XTFPGA audio subsystem.
diff --git a/sound/soc/xtensa/Makefile b/sound/soc/xtensa/Makefile
new file mode 100644
index 000000000000..15efbf914226
--- /dev/null
+++ b/sound/soc/xtensa/Makefile
@@ -0,0 +1,3 @@
+snd-soc-xtfpga-i2s-objs := xtfpga-i2s.o
+
+obj-$(CONFIG_SND_SOC_XTFPGA_I2S) += snd-soc-xtfpga-i2s.o
diff --git a/sound/soc/xtensa/xtfpga-i2s.c b/sound/soc/xtensa/xtfpga-i2s.c
new file mode 100644
index 000000000000..1cfb19e12949
--- /dev/null
+++ b/sound/soc/xtensa/xtfpga-i2s.c
@@ -0,0 +1,675 @@
+/*
+ * Xtfpga I2S controller driver
+ *
+ * Copyright (c) 2014 Cadence Design Systems Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+
+#define DRV_NAME        "xtfpga-i2s"
+
+#define XTFPGA_I2S_VERSION      0x00
+#define XTFPGA_I2S_CONFIG       0x04
+#define XTFPGA_I2S_INT_MASK     0x08
+#define XTFPGA_I2S_INT_STATUS   0x0c
+#define XTFPGA_I2S_CHAN0_DATA   0x10
+#define XTFPGA_I2S_CHAN1_DATA   0x14
+#define XTFPGA_I2S_CHAN2_DATA   0x18
+#define XTFPGA_I2S_CHAN3_DATA   0x1c
+
+#define XTFPGA_I2S_CONFIG_TX_ENABLE     0x1
+#define XTFPGA_I2S_CONFIG_INT_ENABLE    0x2
+#define XTFPGA_I2S_CONFIG_LEFT          0x4
+#define XTFPGA_I2S_CONFIG_RATIO_BASE    8
+#define XTFPGA_I2S_CONFIG_RATIO_MASK    0x0000ff00
+#define XTFPGA_I2S_CONFIG_RES_BASE      16
+#define XTFPGA_I2S_CONFIG_RES_MASK      0x003f0000
+#define XTFPGA_I2S_CONFIG_LEVEL_BASE    24
+#define XTFPGA_I2S_CONFIG_LEVEL_MASK    0x0f000000
+#define XTFPGA_I2S_CONFIG_CHANNEL_BASE  28
+
+#define XTFPGA_I2S_INT_UNDERRUN         0x1
+#define XTFPGA_I2S_INT_LEVEL            0x2
+#define XTFPGA_I2S_INT_VALID            0x3
+
+#define XTFPGA_I2S_FIFO_SIZE            8192
+
+/*
+ * I2S controller operation:
+ *
+ * Enabling TX: output 1 period of zeros (starting with left channel)
+ * and then queued data.
+ *
+ * Level status and interrupt: whenever FIFO level is below FIFO trigger,
+ * level status is 1 and an IRQ is asserted (if enabled).
+ *
+ * Underrun status and interrupt: whenever FIFO is empty, underrun status
+ * is 1 and an IRQ is asserted (if enabled).
+ */
+struct xtfpga_i2s {
+        struct device *dev;
+        struct clk *clk;
+        struct regmap *regmap;
+        void __iomem *regs;
+
+        /* current playback substream. NULL if not playing.
+         *
+         * Access to that field is synchronized between the interrupt handler
+         * and userspace through RCU.
+         *
+         * Interrupt handler (threaded part) does PIO on substream data in RCU
+         * read-side critical section. Trigger callback sets and clears the
+         * pointer when the playback is started and stopped with
+         * rcu_assign_pointer. When userspace is about to free the playback
+         * stream in the pcm_close callback it synchronizes with the interrupt
+         * handler by means of synchronize_rcu call.
+         */
+        struct snd_pcm_substream *tx_substream;
+        unsigned (*tx_fn)(struct xtfpga_i2s *i2s,
+                          struct snd_pcm_runtime *runtime,
+                          unsigned tx_ptr);
+        unsigned tx_ptr; /* next frame index in the sample buffer */
+
+        /* current fifo level estimate.
+         * Doesn't have to be perfectly accurate, but must be not less than
+         * the actual FIFO level in order to avoid stall on push attempt.
+         */
+        unsigned tx_fifo_level;
+
+        /* FIFO level at which level interrupt occurs */
+        unsigned tx_fifo_low;
+
+        /* maximal FIFO level */
+        unsigned tx_fifo_high;
+};
+
+static bool xtfpga_i2s_wr_reg(struct device *dev, unsigned int reg)
+{
+        return reg >= XTFPGA_I2S_CONFIG;
+}
+
+static bool xtfpga_i2s_rd_reg(struct device *dev, unsigned int reg)
+{
+        return reg < XTFPGA_I2S_CHAN0_DATA;
+}
+
+static bool xtfpga_i2s_volatile_reg(struct device *dev, unsigned int reg)
+{
+        return reg == XTFPGA_I2S_INT_STATUS;
+}
+
+static const struct regmap_config xtfpga_i2s_regmap_config = {
+        .reg_bits = 32,
+        .reg_stride = 4,
+        .val_bits = 32,
+        .max_register = XTFPGA_I2S_CHAN3_DATA,
+        .writeable_reg = xtfpga_i2s_wr_reg,
+        .readable_reg = xtfpga_i2s_rd_reg,
+        .volatile_reg = xtfpga_i2s_volatile_reg,
+        .cache_type = REGCACHE_FLAT,
+};
+
+/* Generate functions that do PIO from TX DMA area to FIFO for all supported
+ * stream formats.
+ * Functions will be called xtfpga_pcm_tx_<channels>x<sample bits>, e.g.
+ * xtfpga_pcm_tx_2x16 for 16-bit stereo.
+ *
+ * FIFO consists of 32-bit words, one word per channel, always 2 channels.
+ * If I2S interface is configured with smaller sample resolution, only
+ * the LSB of each word is used.
+ */
+#define xtfpga_pcm_tx_fn(channels, sample_bits) \
+static unsigned xtfpga_pcm_tx_##channels##x##sample_bits( \
+        struct xtfpga_i2s *i2s, struct snd_pcm_runtime *runtime, \
+        unsigned tx_ptr) \
+{ \
+        const u##sample_bits (*p)[channels] = \
+                (void *)runtime->dma_area; \
+\
+        for (; i2s->tx_fifo_level < i2s->tx_fifo_high; \
+             i2s->tx_fifo_level += 2) { \
+                iowrite32(p[tx_ptr][0], \
+                          i2s->regs + XTFPGA_I2S_CHAN0_DATA); \
+                iowrite32(p[tx_ptr][channels - 1], \
+                          i2s->regs + XTFPGA_I2S_CHAN0_DATA); \
+                if (++tx_ptr >= runtime->buffer_size) \
+                        tx_ptr = 0; \
+        } \
+        return tx_ptr; \
+}
+
+xtfpga_pcm_tx_fn(1, 16)
+xtfpga_pcm_tx_fn(2, 16)
+xtfpga_pcm_tx_fn(1, 32)
+xtfpga_pcm_tx_fn(2, 32)
+
+#undef xtfpga_pcm_tx_fn
+
+static bool xtfpga_pcm_push_tx(struct xtfpga_i2s *i2s)
+{
+        struct snd_pcm_substream *tx_substream;
+        bool tx_active;
+
+        rcu_read_lock();
+        tx_substream = rcu_dereference(i2s->tx_substream);
+        tx_active = tx_substream && snd_pcm_running(tx_substream);
+        if (tx_active) {
+                unsigned tx_ptr = ACCESS_ONCE(i2s->tx_ptr);
+                unsigned new_tx_ptr = i2s->tx_fn(i2s, tx_substream->runtime,
+                                                 tx_ptr);
+
+                cmpxchg(&i2s->tx_ptr, tx_ptr, new_tx_ptr);
+        }
+        rcu_read_unlock();
+
+        return tx_active;
+}
+
+static void xtfpga_pcm_refill_fifo(struct xtfpga_i2s *i2s)
+{
+        unsigned int_status;
+        unsigned i;
+
+        regmap_read(i2s->regmap, XTFPGA_I2S_INT_STATUS,
+                    &int_status);
+
+        for (i = 0; i < 2; ++i) {
+                bool tx_active = xtfpga_pcm_push_tx(i2s);
+
+                regmap_write(i2s->regmap, XTFPGA_I2S_INT_STATUS,
+                             XTFPGA_I2S_INT_VALID);
+                if (tx_active)
+                        regmap_read(i2s->regmap, XTFPGA_I2S_INT_STATUS,
+                                    &int_status);
+
+                if (!tx_active ||
+                    !(int_status & XTFPGA_I2S_INT_LEVEL))
+                        break;
+
+                /* After the push the level IRQ is still asserted,
+                 * means FIFO level is below tx_fifo_low. Estimate
+                 * it as tx_fifo_low.
+                 */
+                i2s->tx_fifo_level = i2s->tx_fifo_low;
+        }
+
+        if (!(int_status & XTFPGA_I2S_INT_LEVEL))
+                regmap_write(i2s->regmap, XTFPGA_I2S_INT_MASK,
+                             XTFPGA_I2S_INT_VALID);
+        else if (!(int_status & XTFPGA_I2S_INT_UNDERRUN))
+                regmap_write(i2s->regmap, XTFPGA_I2S_INT_MASK,
+                             XTFPGA_I2S_INT_UNDERRUN);
+
+        if (!(int_status & XTFPGA_I2S_INT_UNDERRUN))
+                regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG,
+                                   XTFPGA_I2S_CONFIG_INT_ENABLE |
+                                   XTFPGA_I2S_CONFIG_TX_ENABLE,
+                                   XTFPGA_I2S_CONFIG_INT_ENABLE |
+                                   XTFPGA_I2S_CONFIG_TX_ENABLE);
+        else
+                regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG,
+                                   XTFPGA_I2S_CONFIG_INT_ENABLE |
+                                   XTFPGA_I2S_CONFIG_TX_ENABLE, 0);
+}
+
+static irqreturn_t xtfpga_i2s_threaded_irq_handler(int irq, void *dev_id)
+{
+        struct xtfpga_i2s *i2s = dev_id;
+        struct snd_pcm_substream *tx_substream;
+        unsigned config, int_status, int_mask;
+
+        regmap_read(i2s->regmap, XTFPGA_I2S_CONFIG, &config);
+        regmap_read(i2s->regmap, XTFPGA_I2S_INT_MASK, &int_mask);
+        regmap_read(i2s->regmap, XTFPGA_I2S_INT_STATUS, &int_status);
+
+        if (!(config & XTFPGA_I2S_CONFIG_INT_ENABLE) ||
+            !(int_status & int_mask & XTFPGA_I2S_INT_VALID))
+                return IRQ_NONE;
+
+        /* Update FIFO level estimate in accordance with interrupt status
+         * register.
+         */
+        if (int_status & XTFPGA_I2S_INT_UNDERRUN) {
+                i2s->tx_fifo_level = 0;
+                regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG,
+                                   XTFPGA_I2S_CONFIG_TX_ENABLE, 0);
+        } else {
+                /* The FIFO isn't empty, but is below tx_fifo_low. Estimate
+                 * it as tx_fifo_low.
+                 */
+                i2s->tx_fifo_level = i2s->tx_fifo_low;
+        }
+
+        rcu_read_lock();
+        tx_substream = rcu_dereference(i2s->tx_substream);
+
+        if (tx_substream && snd_pcm_running(tx_substream)) {
+                snd_pcm_period_elapsed(tx_substream);
+                if (int_status & XTFPGA_I2S_INT_UNDERRUN)
+                        dev_dbg_ratelimited(i2s->dev, "%s: underrun\n",
+                                            __func__);
+        }
+        rcu_read_unlock();
+
+        /* Refill FIFO, update allowed IRQ reasons, enable IRQ if FIFO is
+         * not empty.
+         */
+        xtfpga_pcm_refill_fifo(i2s);
+
+        return IRQ_HANDLED;
+}
+
+static int xtfpga_i2s_startup(struct snd_pcm_substream *substream,
+                              struct snd_soc_dai *dai)
+{
+        struct xtfpga_i2s *i2s = snd_soc_dai_get_drvdata(dai);
+
+        snd_soc_dai_set_dma_data(dai, substream, i2s);
+        return 0;
+}
+
+static int xtfpga_i2s_hw_params(struct snd_pcm_substream *substream,
+                                struct snd_pcm_hw_params *params,
+                                struct snd_soc_dai *dai)
+{
+        struct xtfpga_i2s *i2s = snd_soc_dai_get_drvdata(dai);
+        unsigned srate = params_rate(params);
+        unsigned channels = params_channels(params);
+        unsigned period_size = params_period_size(params);
+        unsigned sample_size = snd_pcm_format_width(params_format(params));
+        unsigned freq, ratio, level;
+        int err;
+
+        regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG,
+                           XTFPGA_I2S_CONFIG_RES_MASK,
+                           sample_size << XTFPGA_I2S_CONFIG_RES_BASE);
+
+        freq = 256 * srate;
+        err = clk_set_rate(i2s->clk, freq);
+        if (err < 0)
+                return err;
+
+        /* ratio field of the config register controls MCLK->I2S clock
+         * derivation: I2S clock = MCLK / (2 * (ratio + 2)).
+         *
+         * So with MCLK = 256 * sample rate ratio is 0 for 32 bit stereo
+         * and 2 for 16 bit stereo.
+         */
+        ratio = (freq - (srate * sample_size * 8)) /
+                (srate * sample_size * 4);
+
+        regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG,
+                           XTFPGA_I2S_CONFIG_RATIO_MASK,
+                           ratio << XTFPGA_I2S_CONFIG_RATIO_BASE);
+
+        i2s->tx_fifo_low = XTFPGA_I2S_FIFO_SIZE / 2;
+
+        /* period_size * 2: FIFO always gets 2 samples per frame */
+        for (level = 1;
+             i2s->tx_fifo_low / 2 >= period_size * 2 &&
+             level < (XTFPGA_I2S_CONFIG_LEVEL_MASK >>
+                      XTFPGA_I2S_CONFIG_LEVEL_BASE); ++level)
+                i2s->tx_fifo_low /= 2;
+
+        i2s->tx_fifo_high = 2 * i2s->tx_fifo_low;
+
+        regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG,
+                           XTFPGA_I2S_CONFIG_LEVEL_MASK,
+                           level << XTFPGA_I2S_CONFIG_LEVEL_BASE);
+
+        dev_dbg(i2s->dev,
+                "%s srate: %u, channels: %u, sample_size: %u, period_size: %u\n",
+                __func__, srate, channels, sample_size, period_size);
+        dev_dbg(i2s->dev, "%s freq: %u, ratio: %u, level: %u\n",
+                __func__, freq, ratio, level);
+
+        return 0;
+}
+
+static int xtfpga_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
+                              unsigned int fmt)
+{
+        if ((fmt & SND_SOC_DAIFMT_INV_MASK) != SND_SOC_DAIFMT_NB_NF)
+                return -EINVAL;
+        if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS)
+                return -EINVAL;
+        if ((fmt & SND_SOC_DAIFMT_FORMAT_MASK) != SND_SOC_DAIFMT_I2S)
+                return -EINVAL;
+
+        return 0;
+}
+
+/* PCM */
+
+static const struct snd_pcm_hardware xtfpga_pcm_hardware = {
+        .info = SNDRV_PCM_INFO_INTERLEAVED |
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_BLOCK_TRANSFER,
+        .formats                = SNDRV_PCM_FMTBIT_S16_LE |
+                                  SNDRV_PCM_FMTBIT_S32_LE,
+        .channels_min           = 1,
+        .channels_max           = 2,
+        .period_bytes_min       = 2,
+        .period_bytes_max       = XTFPGA_I2S_FIFO_SIZE / 2 * 8,
+        .periods_min            = 2,
+        .periods_max            = XTFPGA_I2S_FIFO_SIZE * 8 / 2,
+        .buffer_bytes_max       = XTFPGA_I2S_FIFO_SIZE * 8,
+        .fifo_size              = 16,
+};
+
+static int xtfpga_pcm_open(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        void *p;
+
+        snd_soc_set_runtime_hwparams(substream, &xtfpga_pcm_hardware);
+        p = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
+        runtime->private_data = p;
+
+        return 0;
+}
+
+static int xtfpga_pcm_close(struct snd_pcm_substream *substream)
+{
+        synchronize_rcu();
+        return 0;
+}
+
+static int xtfpga_pcm_hw_params(struct snd_pcm_substream *substream,
+                                struct snd_pcm_hw_params *hw_params)
+{
+        int ret;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct xtfpga_i2s *i2s = runtime->private_data;
+        unsigned channels = params_channels(hw_params);
+
+        switch (channels) {
+        case 1:
+        case 2:
+                break;
+
+        default:
+                return -EINVAL;
+
+        }
+
+        switch (params_format(hw_params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                i2s->tx_fn = (channels == 1) ?
+                        xtfpga_pcm_tx_1x16 :
+                        xtfpga_pcm_tx_2x16;
+                break;
+
+        case SNDRV_PCM_FORMAT_S32_LE:
+                i2s->tx_fn = (channels == 1) ?
+                        xtfpga_pcm_tx_1x32 :
+                        xtfpga_pcm_tx_2x32;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        ret = snd_pcm_lib_malloc_pages(substream,
+                                       params_buffer_bytes(hw_params));
+        return ret;
+}
+
+static int xtfpga_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        int ret = 0;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct xtfpga_i2s *i2s = runtime->private_data;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                ACCESS_ONCE(i2s->tx_ptr) = 0;
+                rcu_assign_pointer(i2s->tx_substream, substream);
+                xtfpga_pcm_refill_fifo(i2s);
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                rcu_assign_pointer(i2s->tx_substream, NULL);
+                break;
+
+        default:
+                ret = -EINVAL;
+                break;
+        }
+        return ret;
+}
+
+static snd_pcm_uframes_t xtfpga_pcm_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct xtfpga_i2s *i2s = runtime->private_data;
+        snd_pcm_uframes_t pos = ACCESS_ONCE(i2s->tx_ptr);
+
+        return pos < runtime->buffer_size ? pos : 0;
+}
+
+static int xtfpga_pcm_new(struct snd_soc_pcm_runtime *rtd)
+{
+        struct snd_card *card = rtd->card->snd_card;
+        size_t size = xtfpga_pcm_hardware.buffer_bytes_max;
+
+        return snd_pcm_lib_preallocate_pages_for_all(rtd->pcm,
+                                                     SNDRV_DMA_TYPE_DEV,
+                                                     card->dev, size, size);
+}
+
+static void xtfpga_pcm_free(struct snd_pcm *pcm)
+{
+        snd_pcm_lib_preallocate_free_for_all(pcm);
+}
+
+static const struct snd_pcm_ops xtfpga_pcm_ops = {
+        .open           = xtfpga_pcm_open,
+        .close          = xtfpga_pcm_close,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = xtfpga_pcm_hw_params,
+        .trigger        = xtfpga_pcm_trigger,
+        .pointer        = xtfpga_pcm_pointer,
+};
+
+static const struct snd_soc_platform_driver xtfpga_soc_platform = {
+        .pcm_new        = xtfpga_pcm_new,
+        .pcm_free       = xtfpga_pcm_free,
+        .ops            = &xtfpga_pcm_ops,
+};
+
+static const struct snd_soc_component_driver xtfpga_i2s_component = {
+        .name           = DRV_NAME,
+};
+
+static const struct snd_soc_dai_ops xtfpga_i2s_dai_ops = {
+        .startup        = xtfpga_i2s_startup,
+        .hw_params      = xtfpga_i2s_hw_params,
+        .set_fmt        = xtfpga_i2s_set_fmt,
+};
+
+static struct snd_soc_dai_driver xtfpga_i2s_dai[] = {
+        {
+                .name = "xtfpga-i2s",
+                .id = 0,
+                .playback = {
+                        .channels_min = 1,
+                        .channels_max = 2,
+                        .rates = SNDRV_PCM_RATE_8000_96000,
+                        .formats = SNDRV_PCM_FMTBIT_S16_LE |
+                                   SNDRV_PCM_FMTBIT_S32_LE,
+                },
+                .ops = &xtfpga_i2s_dai_ops,
+        },
+};
+
+static int xtfpga_i2s_runtime_suspend(struct device *dev)
+{
+        struct xtfpga_i2s *i2s = dev_get_drvdata(dev);
+
+        clk_disable_unprepare(i2s->clk);
+        return 0;
+}
+
+static int xtfpga_i2s_runtime_resume(struct device *dev)
+{
+        struct xtfpga_i2s *i2s = dev_get_drvdata(dev);
+        int ret;
+
+        ret = clk_prepare_enable(i2s->clk);
+        if (ret) {
+                dev_err(dev, "clk_prepare_enable failed: %d\n", ret);
+                return ret;
+        }
+        return 0;
+}
+
+static int xtfpga_i2s_probe(struct platform_device *pdev)
+{
+        struct xtfpga_i2s *i2s;
+        struct resource *mem;
+        int err, irq;
+
+        i2s = devm_kzalloc(&pdev->dev, sizeof(*i2s), GFP_KERNEL);
+        if (!i2s) {
+                err = -ENOMEM;
+                goto err;
+        }
+        platform_set_drvdata(pdev, i2s);
+        i2s->dev = &pdev->dev;
+        dev_dbg(&pdev->dev, "dev: %p, i2s: %p\n", &pdev->dev, i2s);
+
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        i2s->regs = devm_ioremap_resource(&pdev->dev, mem);
+        if (IS_ERR(i2s->regs)) {
+                err = PTR_ERR(i2s->regs);
+                goto err;
+        }
+
+        i2s->regmap = devm_regmap_init_mmio(&pdev->dev, i2s->regs,
+                                            &xtfpga_i2s_regmap_config);
+        if (IS_ERR(i2s->regmap)) {
+                dev_err(&pdev->dev, "regmap init failed\n");
+                err = PTR_ERR(i2s->regmap);
+                goto err;
+        }
+
+        i2s->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(i2s->clk)) {
+                dev_err(&pdev->dev, "couldn't get clock\n");
+                err = PTR_ERR(i2s->clk);
+                goto err;
+        }
+
+        regmap_write(i2s->regmap, XTFPGA_I2S_CONFIG,
+                     (0x1 << XTFPGA_I2S_CONFIG_CHANNEL_BASE));
+        regmap_write(i2s->regmap, XTFPGA_I2S_INT_STATUS, XTFPGA_I2S_INT_VALID);
+        regmap_write(i2s->regmap, XTFPGA_I2S_INT_MASK, XTFPGA_I2S_INT_UNDERRUN);
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "No IRQ resource\n");
+                err = irq;
+                goto err;
+        }
+        err = devm_request_threaded_irq(&pdev->dev, irq, NULL,
+                                        xtfpga_i2s_threaded_irq_handler,
+                                        IRQF_SHARED | IRQF_ONESHOT,
+                                        pdev->name, i2s);
+        if (err < 0) {
+                dev_err(&pdev->dev, "request_irq failed\n");
+                goto err;
+        }
+
+        err = snd_soc_register_platform(&pdev->dev, &xtfpga_soc_platform);
+        if (err < 0) {
+                dev_err(&pdev->dev, "couldn't register platform\n");
+                goto err;
+        }
+        err = devm_snd_soc_register_component(&pdev->dev,
+                                              &xtfpga_i2s_component,
+                                              xtfpga_i2s_dai,
+                                              ARRAY_SIZE(xtfpga_i2s_dai));
+        if (err < 0) {
+                dev_err(&pdev->dev, "couldn't register component\n");
+                goto err_unregister_platform;
+        }
+
+        pm_runtime_enable(&pdev->dev);
+        if (!pm_runtime_enabled(&pdev->dev)) {
+                err = xtfpga_i2s_runtime_resume(&pdev->dev);
+                if (err)
+                        goto err_pm_disable;
+        }
+        return 0;
+
+err_pm_disable:
+        pm_runtime_disable(&pdev->dev);
+err_unregister_platform:
+        snd_soc_unregister_platform(&pdev->dev);
+err:
+        dev_err(&pdev->dev, "%s: err = %d\n", __func__, err);
+        return err;
+}
+
+static int xtfpga_i2s_remove(struct platform_device *pdev)
+{
+        struct xtfpga_i2s *i2s = dev_get_drvdata(&pdev->dev);
+
+        snd_soc_unregister_platform(&pdev->dev);
+        if (i2s->regmap && !IS_ERR(i2s->regmap)) {
+                regmap_write(i2s->regmap, XTFPGA_I2S_CONFIG, 0);
+                regmap_write(i2s->regmap, XTFPGA_I2S_INT_MASK, 0);
+                regmap_write(i2s->regmap, XTFPGA_I2S_INT_STATUS,
+                             XTFPGA_I2S_INT_VALID);
+        }
+        pm_runtime_disable(&pdev->dev);
+        if (!pm_runtime_status_suspended(&pdev->dev))
+                xtfpga_i2s_runtime_suspend(&pdev->dev);
+        return 0;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id xtfpga_i2s_of_match[] = {
+        { .compatible = "cdns,xtfpga-i2s", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, xtfpga_i2s_of_match);
+#endif
+
+static const struct dev_pm_ops xtfpga_i2s_pm_ops = {
+        SET_RUNTIME_PM_OPS(xtfpga_i2s_runtime_suspend,
+                           xtfpga_i2s_runtime_resume, NULL)
+};
+
+static struct platform_driver xtfpga_i2s_driver = {
+        .probe   = xtfpga_i2s_probe,
+        .remove  = xtfpga_i2s_remove,
+        .driver  = {
+                .name = "xtfpga-i2s",
+                .of_match_table = of_match_ptr(xtfpga_i2s_of_match),
+                .pm = &xtfpga_i2s_pm_ops,
+        },
+};
+
+module_platform_driver(xtfpga_i2s_driver);
+
+MODULE_AUTHOR("Max Filippov <jcmvbkbc@gmail.com>");
+MODULE_DESCRIPTION("xtfpga I2S controller driver");
+MODULE_LICENSE("GPL v2");
diff --git a/sound/sparc/amd7930.c b/sound/sparc/amd7930.c
index 86280d63b76d..1b1a89e80d13 100644
--- a/sound/sparc/amd7930.c
+++ b/sound/sparc/amd7930.c
@@ -37,6 +37,7 @@
 #include <linux/moduleparam.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -44,7 +45,6 @@
 #include <sound/control.h>
 #include <sound/initval.h>
 
-#include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/prom.h>
 
diff --git a/sound/synth/emux/emux.c b/sound/synth/emux/emux.c
index 93522072bc87..49195325fdf6 100644
--- a/sound/synth/emux/emux.c
+++ b/sound/synth/emux/emux.c
@@ -53,9 +53,7 @@ int snd_emux_new(struct snd_emux **remu)
         emu->max_voices = 0;
         emu->use_time = 0;
 
-        init_timer(&emu->tlist);
-        emu->tlist.function = snd_emux_timer_callback;
-        emu->tlist.data = (unsigned long)emu;
+        setup_timer(&emu->tlist, snd_emux_timer_callback, (unsigned long)emu);
         emu->timer_active = 0;
 
         *remu = emu;
@@ -160,12 +158,8 @@ int snd_emux_free(struct snd_emux *emu)
         snd_emux_detach_seq_oss(emu);
 #endif
         snd_emux_detach_seq(emu);
-
         snd_emux_delete_hwdep(emu);
-
-        if (emu->sflist)
-                snd_sf_free(emu->sflist);
-
+        snd_sf_free(emu->sflist);
         kfree(emu->voices);
         kfree(emu->name);
         kfree(emu);
diff --git a/sound/synth/emux/emux_hwdep.c b/sound/synth/emux/emux_hwdep.c
index 5ae1eae9f6db..e557946718a9 100644
--- a/sound/synth/emux/emux_hwdep.c
+++ b/sound/synth/emux/emux_hwdep.c
@@ -21,7 +21,7 @@
 
 #include <sound/core.h>
 #include <sound/hwdep.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include "emux_voice.h"
 
 
diff --git a/sound/synth/emux/emux_oss.c b/sound/synth/emux/emux_oss.c
index 319754cf6208..ab37add269ae 100644
--- a/sound/synth/emux/emux_oss.c
+++ b/sound/synth/emux/emux_oss.c
@@ -26,7 +26,7 @@
 #ifdef CONFIG_SND_SEQUENCER_OSS
 
 #include <linux/export.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <sound/core.h>
 #include "emux_voice.h"
 #include <sound/asoundef.h>
diff --git a/sound/synth/emux/emux_synth.c b/sound/synth/emux/emux_synth.c
index 9a38de459acb..599551b5af44 100644
--- a/sound/synth/emux/emux_synth.c
+++ b/sound/synth/emux/emux_synth.c
@@ -186,8 +186,7 @@ snd_emux_note_off(void *p, int note, int vel, struct snd_midi_channel *chan)
                                  */
                                 vp->state = SNDRV_EMUX_ST_PENDING;
                                 if (! emu->timer_active) {
-                                        emu->tlist.expires = jiffies + 1;
-                                        add_timer(&emu->tlist);
+                                        mod_timer(&emu->tlist, jiffies + 1);
                                         emu->timer_active = 1;
                                 }
                         } else
@@ -223,8 +222,7 @@ void snd_emux_timer_callback(unsigned long data)
                 }
         }
         if (do_again) {
-                emu->tlist.expires = jiffies + 1;
-                add_timer(&emu->tlist);
+                mod_timer(&emu->tlist, jiffies + 1);
                 emu->timer_active = 1;
         } else
                 emu->timer_active = 0;
diff --git a/sound/synth/emux/soundfont.c b/sound/synth/emux/soundfont.c
index 78683b2064f7..31a4ea94830e 100644
--- a/sound/synth/emux/soundfont.c
+++ b/sound/synth/emux/soundfont.c
@@ -25,7 +25,7 @@
  * of doing things so that the old sfxload utility can be used.
  * Everything may change when there is an alsa way of doing things.
  */
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/slab.h>
 #include <linux/export.h>
 #include <sound/core.h>
diff --git a/sound/usb/Kconfig b/sound/usb/Kconfig
index d393153c474f..a452ad7cec40 100644
--- a/sound/usb/Kconfig
+++ b/sound/usb/Kconfig
@@ -160,5 +160,7 @@ config SND_BCD2000
           To compile this driver as a module, choose M here: the module
           will be called snd-bcd2000.
 
+source "sound/usb/line6/Kconfig"
+
 endif   # SND_USB
 
diff --git a/sound/usb/Makefile b/sound/usb/Makefile
index bcee4060fd18..2d2d122b069f 100644
--- a/sound/usb/Makefile
+++ b/sound/usb/Makefile
@@ -25,3 +25,4 @@ obj-$(CONFIG_SND_USB_USX2Y) += snd-usbmidi-lib.o
 obj-$(CONFIG_SND_USB_US122L) += snd-usbmidi-lib.o
 
 obj-$(CONFIG_SND) += misc/ usx2y/ caiaq/ 6fire/ hiface/ bcd2000/
+obj-$(CONFIG_SND_USB_LINE6)     += line6/
diff --git a/sound/usb/card.h b/sound/usb/card.h
index 97acb906acc2..ef580b43f1e3 100644
--- a/sound/usb/card.h
+++ b/sound/usb/card.h
@@ -153,6 +153,8 @@ struct snd_usb_substream {
                 int channel;
                 int byte_idx;
         } dsd_dop;
+
+        bool trigger_tstamp_pending_update; /* trigger timestamp being updated from initial estimate */
 };
 
 struct snd_usb_stream {
diff --git a/sound/usb/clock.c b/sound/usb/clock.c
index 03fed6611d9e..2ed260b10f6d 100644
--- a/sound/usb/clock.c
+++ b/sound/usb/clock.c
@@ -303,6 +303,11 @@ static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface,
                 return err;
         }
 
+        /* Don't check the sample rate for devices which we know don't
+         * support reading */
+        if (snd_usb_get_sample_rate_quirk(chip))
+                return 0;
+
         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,
diff --git a/sound/usb/line6/Kconfig b/sound/usb/line6/Kconfig
new file mode 100644
index 000000000000..f4585d378ef3
--- /dev/null
+++ b/sound/usb/line6/Kconfig
@@ -0,0 +1,42 @@
+config SND_USB_LINE6
+        tristate
+        select SND_RAWMIDI
+        select SND_PCM
+
+config SND_USB_POD
+        tristate "Line 6 POD USB support"
+        select SND_USB_LINE6
+        help
+          This is a driver for PODxt and other similar devices,
+          supporting the following features:
+            * Reading/writing individual parameters
+            * Reading/writing complete channel, effects setup, and amp
+              setup data
+            * Channel switching
+            * Virtual MIDI interface
+            * Tuner access
+            * Playback/capture/mixer device for any ALSA-compatible PCM
+              audio application
+            * Signal routing (record clean/processed guitar signal,
+              re-amping)
+
+config SND_USB_PODHD
+        tristate "Line 6 POD HD300/400/500 USB support"
+        select SND_USB_LINE6
+        help
+          This is a driver for POD HD300, 400 and 500 devices.
+
+config SND_USB_TONEPORT
+        tristate "TonePort GX, UX1 and UX2 USB support"
+        select SND_USB_LINE6
+        select NEW_LEDS
+        select LEDS_CLASS
+        help
+          This is a driver for TonePort GX, UX1 and UX2 devices.
+
+config SND_USB_VARIAX
+        tristate "Variax Workbench USB support"
+        select SND_USB_LINE6
+        help
+          This is a driver for Variax Workbench device.
+
diff --git a/sound/usb/line6/Makefile b/sound/usb/line6/Makefile
new file mode 100644
index 000000000000..b8b3b2a543d8
--- /dev/null
+++ b/sound/usb/line6/Makefile
@@ -0,0 +1,18 @@
+snd-usb-line6-y :=              \
+                capture.o       \
+                driver.o        \
+                midi.o          \
+                midibuf.o       \
+                pcm.o           \
+                playback.o
+
+snd-usb-pod-y := pod.o
+snd-usb-podhd-y := podhd.o
+snd-usb-toneport-y := toneport.o
+snd-usb-variax-y := variax.o
+
+obj-$(CONFIG_SND_USB_LINE6)     += snd-usb-line6.o
+obj-$(CONFIG_SND_USB_POD)       += snd-usb-pod.o
+obj-$(CONFIG_SND_USB_PODHD)     += snd-usb-podhd.o
+obj-$(CONFIG_SND_USB_TONEPORT)  += snd-usb-toneport.o
+obj-$(CONFIG_SND_USB_VARIAX)    += snd-usb-variax.o
diff --git a/sound/usb/line6/capture.c b/sound/usb/line6/capture.c
new file mode 100644
index 000000000000..f518fbbe88de
--- /dev/null
+++ b/sound/usb/line6/capture.c
@@ -0,0 +1,275 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+
+#include "capture.h"
+#include "driver.h"
+#include "pcm.h"
+
+/*
+        Find a free URB and submit it.
+        must be called in line6pcm->in.lock context
+*/
+static int submit_audio_in_urb(struct snd_line6_pcm *line6pcm)
+{
+        int index;
+        int i, urb_size;
+        int ret;
+        struct urb *urb_in;
+
+        index =
+            find_first_zero_bit(&line6pcm->in.active_urbs, LINE6_ISO_BUFFERS);
+
+        if (index < 0 || index >= LINE6_ISO_BUFFERS) {
+                dev_err(line6pcm->line6->ifcdev, "no free URB found\n");
+                return -EINVAL;
+        }
+
+        urb_in = line6pcm->in.urbs[index];
+        urb_size = 0;
+
+        for (i = 0; i < LINE6_ISO_PACKETS; ++i) {
+                struct usb_iso_packet_descriptor *fin =
+                    &urb_in->iso_frame_desc[i];
+                fin->offset = urb_size;
+                fin->length = line6pcm->max_packet_size;
+                urb_size += line6pcm->max_packet_size;
+        }
+
+        urb_in->transfer_buffer =
+            line6pcm->in.buffer +
+            index * LINE6_ISO_PACKETS * line6pcm->max_packet_size;
+        urb_in->transfer_buffer_length = urb_size;
+        urb_in->context = line6pcm;
+
+        ret = usb_submit_urb(urb_in, GFP_ATOMIC);
+
+        if (ret == 0)
+                set_bit(index, &line6pcm->in.active_urbs);
+        else
+                dev_err(line6pcm->line6->ifcdev,
+                        "URB in #%d submission failed (%d)\n", index, ret);
+
+        return 0;
+}
+
+/*
+        Submit all currently available capture URBs.
+        must be called in line6pcm->in.lock context
+*/
+int line6_submit_audio_in_all_urbs(struct snd_line6_pcm *line6pcm)
+{
+        int ret = 0, i;
+
+        for (i = 0; i < LINE6_ISO_BUFFERS; ++i) {
+                ret = submit_audio_in_urb(line6pcm);
+                if (ret < 0)
+                        break;
+        }
+
+        return ret;
+}
+
+/*
+        Copy data into ALSA capture buffer.
+*/
+void line6_capture_copy(struct snd_line6_pcm *line6pcm, char *fbuf, int fsize)
+{
+        struct snd_pcm_substream *substream =
+            get_substream(line6pcm, SNDRV_PCM_STREAM_CAPTURE);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        const int bytes_per_frame = line6pcm->properties->bytes_per_frame;
+        int frames = fsize / bytes_per_frame;
+
+        if (runtime == NULL)
+                return;
+
+        if (line6pcm->in.pos_done + frames > runtime->buffer_size) {
+                /*
+                   The transferred area goes over buffer boundary,
+                   copy two separate chunks.
+                 */
+                int len;
+
+                len = runtime->buffer_size - line6pcm->in.pos_done;
+
+                if (len > 0) {
+                        memcpy(runtime->dma_area +
+                               line6pcm->in.pos_done * bytes_per_frame, fbuf,
+                               len * bytes_per_frame);
+                        memcpy(runtime->dma_area, fbuf + len * bytes_per_frame,
+                               (frames - len) * bytes_per_frame);
+                } else {
+                        /* this is somewhat paranoid */
+                        dev_err(line6pcm->line6->ifcdev,
+                                "driver bug: len = %d\n", len);
+                }
+        } else {
+                /* copy single chunk */
+                memcpy(runtime->dma_area +
+                       line6pcm->in.pos_done * bytes_per_frame, fbuf, fsize);
+        }
+
+        line6pcm->in.pos_done += frames;
+        if (line6pcm->in.pos_done >= runtime->buffer_size)
+                line6pcm->in.pos_done -= runtime->buffer_size;
+}
+
+void line6_capture_check_period(struct snd_line6_pcm *line6pcm, int length)
+{
+        struct snd_pcm_substream *substream =
+            get_substream(line6pcm, SNDRV_PCM_STREAM_CAPTURE);
+
+        line6pcm->in.bytes += length;
+        if (line6pcm->in.bytes >= line6pcm->in.period) {
+                line6pcm->in.bytes %= line6pcm->in.period;
+                spin_unlock(&line6pcm->in.lock);
+                snd_pcm_period_elapsed(substream);
+                spin_lock(&line6pcm->in.lock);
+        }
+}
+
+/*
+ * Callback for completed capture URB.
+ */
+static void audio_in_callback(struct urb *urb)
+{
+        int i, index, length = 0, shutdown = 0;
+        unsigned long flags;
+
+        struct snd_line6_pcm *line6pcm = (struct snd_line6_pcm *)urb->context;
+
+        line6pcm->in.last_frame = urb->start_frame;
+
+        /* find index of URB */
+        for (index = 0; index < LINE6_ISO_BUFFERS; ++index)
+                if (urb == line6pcm->in.urbs[index])
+                        break;
+
+        spin_lock_irqsave(&line6pcm->in.lock, flags);
+
+        for (i = 0; i < LINE6_ISO_PACKETS; ++i) {
+                char *fbuf;
+                int fsize;
+                struct usb_iso_packet_descriptor *fin = &urb->iso_frame_desc[i];
+
+                if (fin->status == -EXDEV) {
+                        shutdown = 1;
+                        break;
+                }
+
+                fbuf = urb->transfer_buffer + fin->offset;
+                fsize = fin->actual_length;
+
+                if (fsize > line6pcm->max_packet_size) {
+                        dev_err(line6pcm->line6->ifcdev,
+                                "driver and/or device bug: packet too large (%d > %d)\n",
+                                fsize, line6pcm->max_packet_size);
+                }
+
+                length += fsize;
+
+                /* the following assumes LINE6_ISO_PACKETS == 1: */
+                line6pcm->prev_fbuf = fbuf;
+                line6pcm->prev_fsize = fsize;
+
+                if (!test_bit(LINE6_STREAM_IMPULSE, &line6pcm->in.running) &&
+                    test_bit(LINE6_STREAM_PCM, &line6pcm->in.running) &&
+                    fsize > 0)
+                        line6_capture_copy(line6pcm, fbuf, fsize);
+        }
+
+        clear_bit(index, &line6pcm->in.active_urbs);
+
+        if (test_and_clear_bit(index, &line6pcm->in.unlink_urbs))
+                shutdown = 1;
+
+        if (!shutdown) {
+                submit_audio_in_urb(line6pcm);
+
+                if (!test_bit(LINE6_STREAM_IMPULSE, &line6pcm->in.running) &&
+                    test_bit(LINE6_STREAM_PCM, &line6pcm->in.running))
+                        line6_capture_check_period(line6pcm, length);
+        }
+
+        spin_unlock_irqrestore(&line6pcm->in.lock, flags);
+}
+
+/* open capture callback */
+static int snd_line6_capture_open(struct snd_pcm_substream *substream)
+{
+        int err;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
+
+        err = snd_pcm_hw_constraint_ratdens(runtime, 0,
+                                            SNDRV_PCM_HW_PARAM_RATE,
+                                            &line6pcm->properties->rates);
+        if (err < 0)
+                return err;
+
+        runtime->hw = line6pcm->properties->capture_hw;
+        return 0;
+}
+
+/* close capture callback */
+static int snd_line6_capture_close(struct snd_pcm_substream *substream)
+{
+        return 0;
+}
+
+/* capture operators */
+struct snd_pcm_ops snd_line6_capture_ops = {
+        .open = snd_line6_capture_open,
+        .close = snd_line6_capture_close,
+        .ioctl = snd_pcm_lib_ioctl,
+        .hw_params = snd_line6_hw_params,
+        .hw_free = snd_line6_hw_free,
+        .prepare = snd_line6_prepare,
+        .trigger = snd_line6_trigger,
+        .pointer = snd_line6_pointer,
+};
+
+int line6_create_audio_in_urbs(struct snd_line6_pcm *line6pcm)
+{
+        struct usb_line6 *line6 = line6pcm->line6;
+        int i;
+
+        /* create audio URBs and fill in constant values: */
+        for (i = 0; i < LINE6_ISO_BUFFERS; ++i) {
+                struct urb *urb;
+
+                /* URB for audio in: */
+                urb = line6pcm->in.urbs[i] =
+                    usb_alloc_urb(LINE6_ISO_PACKETS, GFP_KERNEL);
+
+                if (urb == NULL)
+                        return -ENOMEM;
+
+                urb->dev = line6->usbdev;
+                urb->pipe =
+                    usb_rcvisocpipe(line6->usbdev,
+                                    line6->properties->ep_audio_r &
+                                    USB_ENDPOINT_NUMBER_MASK);
+                urb->transfer_flags = URB_ISO_ASAP;
+                urb->start_frame = -1;
+                urb->number_of_packets = LINE6_ISO_PACKETS;
+                urb->interval = LINE6_ISO_INTERVAL;
+                urb->error_count = 0;
+                urb->complete = audio_in_callback;
+        }
+
+        return 0;
+}
diff --git a/sound/usb/line6/capture.h b/sound/usb/line6/capture.h
new file mode 100644
index 000000000000..890b21bff18c
--- /dev/null
+++ b/sound/usb/line6/capture.h
@@ -0,0 +1,29 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#ifndef CAPTURE_H
+#define CAPTURE_H
+
+#include <sound/pcm.h>
+
+#include "driver.h"
+#include "pcm.h"
+
+extern struct snd_pcm_ops snd_line6_capture_ops;
+
+extern void line6_capture_copy(struct snd_line6_pcm *line6pcm, char *fbuf,
+                               int fsize);
+extern void line6_capture_check_period(struct snd_line6_pcm *line6pcm,
+                                       int length);
+extern int line6_create_audio_in_urbs(struct snd_line6_pcm *line6pcm);
+extern int line6_submit_audio_in_all_urbs(struct snd_line6_pcm *line6pcm);
+
+#endif
diff --git a/sound/usb/line6/driver.c b/sound/usb/line6/driver.c
new file mode 100644
index 000000000000..81b7da8e56d3
--- /dev/null
+++ b/sound/usb/line6/driver.c
@@ -0,0 +1,672 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/export.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+
+#include <sound/core.h>
+#include <sound/initval.h>
+
+#include "capture.h"
+#include "driver.h"
+#include "midi.h"
+#include "playback.h"
+
+#define DRIVER_AUTHOR  "Markus Grabner <grabner@icg.tugraz.at>"
+#define DRIVER_DESC    "Line 6 USB Driver"
+
+/*
+        This is Line 6's MIDI manufacturer ID.
+*/
+const unsigned char line6_midi_id[] = {
+        0x00, 0x01, 0x0c
+};
+EXPORT_SYMBOL_GPL(line6_midi_id);
+
+/*
+        Code to request version of POD, Variax interface
+        (and maybe other devices).
+*/
+static const char line6_request_version[] = {
+        0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7
+};
+
+/*
+         Class for asynchronous messages.
+*/
+struct message {
+        struct usb_line6 *line6;
+        const char *buffer;
+        int size;
+        int done;
+};
+
+/*
+        Forward declarations.
+*/
+static void line6_data_received(struct urb *urb);
+static int line6_send_raw_message_async_part(struct message *msg,
+                                             struct urb *urb);
+
+/*
+        Start to listen on endpoint.
+*/
+static int line6_start_listen(struct usb_line6 *line6)
+{
+        int err;
+
+        usb_fill_int_urb(line6->urb_listen, line6->usbdev,
+                usb_rcvintpipe(line6->usbdev, line6->properties->ep_ctrl_r),
+                line6->buffer_listen, LINE6_BUFSIZE_LISTEN,
+                line6_data_received, line6, line6->interval);
+        line6->urb_listen->actual_length = 0;
+        err = usb_submit_urb(line6->urb_listen, GFP_ATOMIC);
+        return err;
+}
+
+/*
+        Stop listening on endpoint.
+*/
+static void line6_stop_listen(struct usb_line6 *line6)
+{
+        usb_kill_urb(line6->urb_listen);
+}
+
+/*
+        Send raw message in pieces of wMaxPacketSize bytes.
+*/
+static int line6_send_raw_message(struct usb_line6 *line6, const char *buffer,
+                                  int size)
+{
+        int i, done = 0;
+
+        for (i = 0; i < size; i += line6->max_packet_size) {
+                int partial;
+                const char *frag_buf = buffer + i;
+                int frag_size = min(line6->max_packet_size, size - i);
+                int retval;
+
+                retval = usb_interrupt_msg(line6->usbdev,
+                                        usb_sndintpipe(line6->usbdev,
+                                                line6->properties->ep_ctrl_w),
+                                        (char *)frag_buf, frag_size,
+                                        &partial, LINE6_TIMEOUT * HZ);
+
+                if (retval) {
+                        dev_err(line6->ifcdev,
+                                "usb_interrupt_msg failed (%d)\n", retval);
+                        break;
+                }
+
+                done += frag_size;
+        }
+
+        return done;
+}
+
+/*
+        Notification of completion of asynchronous request transmission.
+*/
+static void line6_async_request_sent(struct urb *urb)
+{
+        struct message *msg = (struct message *)urb->context;
+
+        if (msg->done >= msg->size) {
+                usb_free_urb(urb);
+                kfree(msg);
+        } else
+                line6_send_raw_message_async_part(msg, urb);
+}
+
+/*
+        Asynchronously send part of a raw message.
+*/
+static int line6_send_raw_message_async_part(struct message *msg,
+                                             struct urb *urb)
+{
+        int retval;
+        struct usb_line6 *line6 = msg->line6;
+        int done = msg->done;
+        int bytes = min(msg->size - done, line6->max_packet_size);
+
+        usb_fill_int_urb(urb, line6->usbdev,
+                usb_sndintpipe(line6->usbdev, line6->properties->ep_ctrl_w),
+                (char *)msg->buffer + done, bytes,
+                line6_async_request_sent, msg, line6->interval);
+
+        msg->done += bytes;
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
+
+        if (retval < 0) {
+                dev_err(line6->ifcdev, "%s: usb_submit_urb failed (%d)\n",
+                        __func__, retval);
+                usb_free_urb(urb);
+                kfree(msg);
+                return retval;
+        }
+
+        return 0;
+}
+
+/*
+        Setup and start timer.
+*/
+void line6_start_timer(struct timer_list *timer, unsigned long msecs,
+                       void (*function)(unsigned long), unsigned long data)
+{
+        setup_timer(timer, function, data);
+        mod_timer(timer, jiffies + msecs_to_jiffies(msecs));
+}
+EXPORT_SYMBOL_GPL(line6_start_timer);
+
+/*
+        Asynchronously send raw message.
+*/
+int line6_send_raw_message_async(struct usb_line6 *line6, const char *buffer,
+                                 int size)
+{
+        struct message *msg;
+        struct urb *urb;
+
+        /* create message: */
+        msg = kmalloc(sizeof(struct message), GFP_ATOMIC);
+        if (msg == NULL)
+                return -ENOMEM;
+
+        /* create URB: */
+        urb = usb_alloc_urb(0, GFP_ATOMIC);
+
+        if (urb == NULL) {
+                kfree(msg);
+                return -ENOMEM;
+        }
+
+        /* set message data: */
+        msg->line6 = line6;
+        msg->buffer = buffer;
+        msg->size = size;
+        msg->done = 0;
+
+        /* start sending: */
+        return line6_send_raw_message_async_part(msg, urb);
+}
+EXPORT_SYMBOL_GPL(line6_send_raw_message_async);
+
+/*
+        Send asynchronous device version request.
+*/
+int line6_version_request_async(struct usb_line6 *line6)
+{
+        char *buffer;
+        int retval;
+
+        buffer = kmemdup(line6_request_version,
+                        sizeof(line6_request_version), GFP_ATOMIC);
+        if (buffer == NULL)
+                return -ENOMEM;
+
+        retval = line6_send_raw_message_async(line6, buffer,
+                                              sizeof(line6_request_version));
+        kfree(buffer);
+        return retval;
+}
+EXPORT_SYMBOL_GPL(line6_version_request_async);
+
+/*
+        Send sysex message in pieces of wMaxPacketSize bytes.
+*/
+int line6_send_sysex_message(struct usb_line6 *line6, const char *buffer,
+                             int size)
+{
+        return line6_send_raw_message(line6, buffer,
+                                      size + SYSEX_EXTRA_SIZE) -
+            SYSEX_EXTRA_SIZE;
+}
+EXPORT_SYMBOL_GPL(line6_send_sysex_message);
+
+/*
+        Allocate buffer for sysex message and prepare header.
+        @param code sysex message code
+        @param size number of bytes between code and sysex end
+*/
+char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1, int code2,
+                               int size)
+{
+        char *buffer = kmalloc(size + SYSEX_EXTRA_SIZE, GFP_ATOMIC);
+
+        if (!buffer)
+                return NULL;
+
+        buffer[0] = LINE6_SYSEX_BEGIN;
+        memcpy(buffer + 1, line6_midi_id, sizeof(line6_midi_id));
+        buffer[sizeof(line6_midi_id) + 1] = code1;
+        buffer[sizeof(line6_midi_id) + 2] = code2;
+        buffer[sizeof(line6_midi_id) + 3 + size] = LINE6_SYSEX_END;
+        return buffer;
+}
+EXPORT_SYMBOL_GPL(line6_alloc_sysex_buffer);
+
+/*
+        Notification of data received from the Line 6 device.
+*/
+static void line6_data_received(struct urb *urb)
+{
+        struct usb_line6 *line6 = (struct usb_line6 *)urb->context;
+        struct midi_buffer *mb = &line6->line6midi->midibuf_in;
+        int done;
+
+        if (urb->status == -ESHUTDOWN)
+                return;
+
+        done =
+            line6_midibuf_write(mb, urb->transfer_buffer, urb->actual_length);
+
+        if (done < urb->actual_length) {
+                line6_midibuf_ignore(mb, done);
+                dev_dbg(line6->ifcdev, "%d %d buffer overflow - message skipped\n",
+                        done, urb->actual_length);
+        }
+
+        for (;;) {
+                done =
+                    line6_midibuf_read(mb, line6->buffer_message,
+                                       LINE6_MESSAGE_MAXLEN);
+
+                if (done == 0)
+                        break;
+
+                line6->message_length = done;
+                line6_midi_receive(line6, line6->buffer_message, done);
+
+                if (line6->process_message)
+                        line6->process_message(line6);
+        }
+
+        line6_start_listen(line6);
+}
+
+#define LINE6_READ_WRITE_STATUS_DELAY 2  /* milliseconds */
+#define LINE6_READ_WRITE_MAX_RETRIES 50
+
+/*
+        Read data from device.
+*/
+int line6_read_data(struct usb_line6 *line6, unsigned address, void *data,
+                    unsigned datalen)
+{
+        struct usb_device *usbdev = line6->usbdev;
+        int ret;
+        unsigned char len;
+        unsigned count;
+
+        if (address > 0xffff || datalen > 0xff)
+                return -EINVAL;
+
+        /* query the serial number: */
+        ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67,
+                              USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
+                              (datalen << 8) | 0x21, address,
+                              NULL, 0, LINE6_TIMEOUT * HZ);
+
+        if (ret < 0) {
+                dev_err(line6->ifcdev, "read request failed (error %d)\n", ret);
+                return ret;
+        }
+
+        /* Wait for data length. We'll get 0xff until length arrives. */
+        for (count = 0; count < LINE6_READ_WRITE_MAX_RETRIES; count++) {
+                mdelay(LINE6_READ_WRITE_STATUS_DELAY);
+
+                ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
+                                      USB_TYPE_VENDOR | USB_RECIP_DEVICE |
+                                      USB_DIR_IN,
+                                      0x0012, 0x0000, &len, 1,
+                                      LINE6_TIMEOUT * HZ);
+                if (ret < 0) {
+                        dev_err(line6->ifcdev,
+                                "receive length failed (error %d)\n", ret);
+                        return ret;
+                }
+
+                if (len != 0xff)
+                        break;
+        }
+
+        if (len == 0xff) {
+                dev_err(line6->ifcdev, "read failed after %d retries\n",
+                        count);
+                return -EIO;
+        } else if (len != datalen) {
+                /* should be equal or something went wrong */
+                dev_err(line6->ifcdev,
+                        "length mismatch (expected %d, got %d)\n",
+                        (int)datalen, (int)len);
+                return -EIO;
+        }
+
+        /* receive the result: */
+        ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0), 0x67,
+                              USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
+                              0x0013, 0x0000, data, datalen,
+                              LINE6_TIMEOUT * HZ);
+
+        if (ret < 0) {
+                dev_err(line6->ifcdev, "read failed (error %d)\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(line6_read_data);
+
+/*
+        Write data to device.
+*/
+int line6_write_data(struct usb_line6 *line6, unsigned address, void *data,
+                     unsigned datalen)
+{
+        struct usb_device *usbdev = line6->usbdev;
+        int ret;
+        unsigned char status;
+        int count;
+
+        if (address > 0xffff || datalen > 0xffff)
+                return -EINVAL;
+
+        ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67,
+                              USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
+                              0x0022, address, data, datalen,
+                              LINE6_TIMEOUT * HZ);
+
+        if (ret < 0) {
+                dev_err(line6->ifcdev,
+                        "write request failed (error %d)\n", ret);
+                return ret;
+        }
+
+        for (count = 0; count < LINE6_READ_WRITE_MAX_RETRIES; count++) {
+                mdelay(LINE6_READ_WRITE_STATUS_DELAY);
+
+                ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
+                                      0x67,
+                                      USB_TYPE_VENDOR | USB_RECIP_DEVICE |
+                                      USB_DIR_IN,
+                                      0x0012, 0x0000,
+                                      &status, 1, LINE6_TIMEOUT * HZ);
+
+                if (ret < 0) {
+                        dev_err(line6->ifcdev,
+                                "receiving status failed (error %d)\n", ret);
+                        return ret;
+                }
+
+                if (status != 0xff)
+                        break;
+        }
+
+        if (status == 0xff) {
+                dev_err(line6->ifcdev, "write failed after %d retries\n",
+                        count);
+                return -EIO;
+        } else if (status != 0) {
+                dev_err(line6->ifcdev, "write failed (error %d)\n", ret);
+                return -EIO;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(line6_write_data);
+
+/*
+        Read Line 6 device serial number.
+        (POD, TonePort, GuitarPort)
+*/
+int line6_read_serial_number(struct usb_line6 *line6, u32 *serial_number)
+{
+        return line6_read_data(line6, 0x80d0, serial_number,
+                               sizeof(*serial_number));
+}
+EXPORT_SYMBOL_GPL(line6_read_serial_number);
+
+/*
+        Card destructor.
+*/
+static void line6_destruct(struct snd_card *card)
+{
+        struct usb_line6 *line6 = card->private_data;
+        struct usb_device *usbdev = line6->usbdev;
+
+        /* free buffer memory first: */
+        kfree(line6->buffer_message);
+        kfree(line6->buffer_listen);
+
+        /* then free URBs: */
+        usb_free_urb(line6->urb_listen);
+
+        /* decrement reference counters: */
+        usb_put_dev(usbdev);
+}
+
+/* get data from endpoint descriptor (see usb_maxpacket): */
+static void line6_get_interval(struct usb_line6 *line6)
+{
+        struct usb_device *usbdev = line6->usbdev;
+        struct usb_host_endpoint *ep;
+        unsigned pipe = usb_rcvintpipe(usbdev, line6->properties->ep_ctrl_r);
+        unsigned epnum = usb_pipeendpoint(pipe);
+
+        ep = usbdev->ep_in[epnum];
+        if (ep) {
+                line6->interval = ep->desc.bInterval;
+                line6->max_packet_size = le16_to_cpu(ep->desc.wMaxPacketSize);
+        } else {
+                dev_err(line6->ifcdev,
+                        "endpoint not available, using fallback values");
+                line6->interval = LINE6_FALLBACK_INTERVAL;
+                line6->max_packet_size = LINE6_FALLBACK_MAXPACKETSIZE;
+        }
+}
+
+static int line6_init_cap_control(struct usb_line6 *line6)
+{
+        int ret;
+
+        /* initialize USB buffers: */
+        line6->buffer_listen = kmalloc(LINE6_BUFSIZE_LISTEN, GFP_KERNEL);
+        if (!line6->buffer_listen)
+                return -ENOMEM;
+
+        line6->buffer_message = kmalloc(LINE6_MESSAGE_MAXLEN, GFP_KERNEL);
+        if (!line6->buffer_message)
+                return -ENOMEM;
+
+        line6->urb_listen = usb_alloc_urb(0, GFP_KERNEL);
+        if (!line6->urb_listen)
+                return -ENOMEM;
+
+        ret = line6_start_listen(line6);
+        if (ret < 0) {
+                dev_err(line6->ifcdev, "cannot start listening: %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+/*
+        Probe USB device.
+*/
+int line6_probe(struct usb_interface *interface,
+                const struct usb_device_id *id,
+                const char *driver_name,
+                const struct line6_properties *properties,
+                int (*private_init)(struct usb_line6 *, const struct usb_device_id *id),
+                size_t data_size)
+{
+        struct usb_device *usbdev = interface_to_usbdev(interface);
+        struct snd_card *card;
+        struct usb_line6 *line6;
+        int interface_number;
+        int ret;
+
+        if (WARN_ON(data_size < sizeof(*line6)))
+                return -EINVAL;
+
+        /* we don't handle multiple configurations */
+        if (usbdev->descriptor.bNumConfigurations != 1)
+                return -ENODEV;
+
+        ret = snd_card_new(&interface->dev,
+                           SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
+                           THIS_MODULE, data_size, &card);
+        if (ret < 0)
+                return ret;
+
+        /* store basic data: */
+        line6 = card->private_data;
+        line6->card = card;
+        line6->properties = properties;
+        line6->usbdev = usbdev;
+        line6->ifcdev = &interface->dev;
+
+        strcpy(card->id, properties->id);
+        strcpy(card->driver, driver_name);
+        strcpy(card->shortname, properties->name);
+        sprintf(card->longname, "Line 6 %s at USB %s", properties->name,
+                dev_name(line6->ifcdev));
+        card->private_free = line6_destruct;
+
+        usb_set_intfdata(interface, line6);
+
+        /* increment reference counters: */
+        usb_get_dev(usbdev);
+
+        /* initialize device info: */
+        dev_info(&interface->dev, "Line 6 %s found\n", properties->name);
+
+        /* query interface number */
+        interface_number = interface->cur_altsetting->desc.bInterfaceNumber;
+
+        ret = usb_set_interface(usbdev, interface_number,
+                                properties->altsetting);
+        if (ret < 0) {
+                dev_err(&interface->dev, "set_interface failed\n");
+                goto error;
+        }
+
+        line6_get_interval(line6);
+
+        if (properties->capabilities & LINE6_CAP_CONTROL) {
+                ret = line6_init_cap_control(line6);
+                if (ret < 0)
+                        goto error;
+        }
+
+        /* initialize device data based on device: */
+        ret = private_init(line6, id);
+        if (ret < 0)
+                goto error;
+
+        /* creation of additional special files should go here */
+
+        dev_info(&interface->dev, "Line 6 %s now attached\n",
+                 properties->name);
+
+        return 0;
+
+ error:
+        if (line6->disconnect)
+                line6->disconnect(line6);
+        snd_card_free(card);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(line6_probe);
+
+/*
+        Line 6 device disconnected.
+*/
+void line6_disconnect(struct usb_interface *interface)
+{
+        struct usb_line6 *line6 = usb_get_intfdata(interface);
+        struct usb_device *usbdev = interface_to_usbdev(interface);
+
+        if (!line6)
+                return;
+
+        if (WARN_ON(usbdev != line6->usbdev))
+                return;
+
+        if (line6->urb_listen != NULL)
+                line6_stop_listen(line6);
+
+        snd_card_disconnect(line6->card);
+        if (line6->line6pcm)
+                line6_pcm_disconnect(line6->line6pcm);
+        if (line6->disconnect)
+                line6->disconnect(line6);
+
+        dev_info(&interface->dev, "Line 6 %s now disconnected\n",
+                 line6->properties->name);
+
+        /* make sure the device isn't destructed twice: */
+        usb_set_intfdata(interface, NULL);
+
+        snd_card_free_when_closed(line6->card);
+}
+EXPORT_SYMBOL_GPL(line6_disconnect);
+
+#ifdef CONFIG_PM
+
+/*
+        Suspend Line 6 device.
+*/
+int line6_suspend(struct usb_interface *interface, pm_message_t message)
+{
+        struct usb_line6 *line6 = usb_get_intfdata(interface);
+        struct snd_line6_pcm *line6pcm = line6->line6pcm;
+
+        snd_power_change_state(line6->card, SNDRV_CTL_POWER_D3hot);
+
+        if (line6->properties->capabilities & LINE6_CAP_CONTROL)
+                line6_stop_listen(line6);
+
+        if (line6pcm != NULL) {
+                snd_pcm_suspend_all(line6pcm->pcm);
+                line6pcm->flags = 0;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(line6_suspend);
+
+/*
+        Resume Line 6 device.
+*/
+int line6_resume(struct usb_interface *interface)
+{
+        struct usb_line6 *line6 = usb_get_intfdata(interface);
+
+        if (line6->properties->capabilities & LINE6_CAP_CONTROL)
+                line6_start_listen(line6);
+
+        snd_power_change_state(line6->card, SNDRV_CTL_POWER_D0);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(line6_resume);
+
+#endif /* CONFIG_PM */
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
diff --git a/sound/usb/line6/driver.h b/sound/usb/line6/driver.h
new file mode 100644
index 000000000000..7da643e79e3b
--- /dev/null
+++ b/sound/usb/line6/driver.h
@@ -0,0 +1,181 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#ifndef DRIVER_H
+#define DRIVER_H
+
+#include <linux/spinlock.h>
+#include <linux/usb.h>
+#include <sound/core.h>
+
+#include "midi.h"
+
+#define USB_INTERVALS_PER_SECOND 1000
+
+/* Fallback USB interval and max packet size values */
+#define LINE6_FALLBACK_INTERVAL 10
+#define LINE6_FALLBACK_MAXPACKETSIZE 16
+
+#define LINE6_TIMEOUT 1
+#define LINE6_BUFSIZE_LISTEN 32
+#define LINE6_MESSAGE_MAXLEN 256
+
+/*
+        Line 6 MIDI control commands
+*/
+#define LINE6_PARAM_CHANGE   0xb0
+#define LINE6_PROGRAM_CHANGE 0xc0
+#define LINE6_SYSEX_BEGIN    0xf0
+#define LINE6_SYSEX_END      0xf7
+#define LINE6_RESET          0xff
+
+/*
+        MIDI channel for messages initiated by the host
+        (and eventually echoed back by the device)
+*/
+#define LINE6_CHANNEL_HOST   0x00
+
+/*
+        MIDI channel for messages initiated by the device
+*/
+#define LINE6_CHANNEL_DEVICE 0x02
+
+#define LINE6_CHANNEL_UNKNOWN 5 /* don't know yet what this is good for */
+
+#define LINE6_CHANNEL_MASK 0x0f
+
+#define CHECK_STARTUP_PROGRESS(x, n)    \
+do {                                    \
+        if ((x) >= (n))                 \
+                return;                 \
+        x = (n);                        \
+} while (0)
+
+extern const unsigned char line6_midi_id[3];
+
+static const int SYSEX_DATA_OFS = sizeof(line6_midi_id) + 3;
+static const int SYSEX_EXTRA_SIZE = sizeof(line6_midi_id) + 4;
+
+/*
+         Common properties of Line 6 devices.
+*/
+struct line6_properties {
+        /* Card id string (maximum 16 characters).
+         * This can be used to address the device in ALSA programs as
+         * "default:CARD=<id>"
+         */
+        const char *id;
+
+        /* Card short name (maximum 32 characters) */
+        const char *name;
+
+        /* Bit vector defining this device's capabilities in line6usb driver */
+        int capabilities;
+
+        int altsetting;
+
+        unsigned ep_ctrl_r;
+        unsigned ep_ctrl_w;
+        unsigned ep_audio_r;
+        unsigned ep_audio_w;
+};
+
+/* Capability bits */
+enum {
+        /* device supports settings parameter via USB */
+        LINE6_CAP_CONTROL =     1 << 0,
+        /* device supports PCM input/output via USB */
+        LINE6_CAP_PCM =         1 << 1,
+        /* device support hardware monitoring */
+        LINE6_CAP_HWMON =       1 << 2,
+};
+
+/*
+         Common data shared by all Line 6 devices.
+         Corresponds to a pair of USB endpoints.
+*/
+struct usb_line6 {
+        /* USB device */
+        struct usb_device *usbdev;
+
+        /* Properties */
+        const struct line6_properties *properties;
+
+        /* Interval (ms) */
+        int interval;
+
+        /* Maximum size of USB packet */
+        int max_packet_size;
+
+        /* Device representing the USB interface */
+        struct device *ifcdev;
+
+        /* Line 6 sound card data structure.
+         * Each device has at least MIDI or PCM.
+         */
+        struct snd_card *card;
+
+        /* Line 6 PCM device data structure */
+        struct snd_line6_pcm *line6pcm;
+
+        /* Line 6 MIDI device data structure */
+        struct snd_line6_midi *line6midi;
+
+        /* URB for listening to PODxt Pro control endpoint */
+        struct urb *urb_listen;
+
+        /* Buffer for listening to PODxt Pro control endpoint */
+        unsigned char *buffer_listen;
+
+        /* Buffer for message to be processed */
+        unsigned char *buffer_message;
+
+        /* Length of message to be processed */
+        int message_length;
+
+        void (*process_message)(struct usb_line6 *);
+        void (*disconnect)(struct usb_line6 *line6);
+};
+
+extern char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1,
+                                      int code2, int size);
+extern int line6_read_data(struct usb_line6 *line6, unsigned address,
+                           void *data, unsigned datalen);
+extern int line6_read_serial_number(struct usb_line6 *line6,
+                                    u32 *serial_number);
+extern int line6_send_raw_message_async(struct usb_line6 *line6,
+                                        const char *buffer, int size);
+extern int line6_send_sysex_message(struct usb_line6 *line6,
+                                    const char *buffer, int size);
+extern ssize_t line6_set_raw(struct device *dev, struct device_attribute *attr,
+                             const char *buf, size_t count);
+extern void line6_start_timer(struct timer_list *timer, unsigned long msecs,
+                              void (*function)(unsigned long),
+                              unsigned long data);
+extern int line6_version_request_async(struct usb_line6 *line6);
+extern int line6_write_data(struct usb_line6 *line6, unsigned address,
+                            void *data, unsigned datalen);
+
+int line6_probe(struct usb_interface *interface,
+                const struct usb_device_id *id,
+                const char *driver_name,
+                const struct line6_properties *properties,
+                int (*private_init)(struct usb_line6 *, const struct usb_device_id *id),
+                size_t data_size);
+
+void line6_disconnect(struct usb_interface *interface);
+
+#ifdef CONFIG_PM
+int line6_suspend(struct usb_interface *interface, pm_message_t message);
+int line6_resume(struct usb_interface *interface);
+#endif
+
+#endif
diff --git a/sound/usb/line6/midi.c b/sound/usb/line6/midi.c
new file mode 100644
index 000000000000..cebea9b7f769
--- /dev/null
+++ b/sound/usb/line6/midi.c
@@ -0,0 +1,292 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/export.h>
+#include <sound/core.h>
+#include <sound/rawmidi.h>
+
+#include "driver.h"
+#include "midi.h"
+
+#define line6_rawmidi_substream_midi(substream) \
+        ((struct snd_line6_midi *)((substream)->rmidi->private_data))
+
+static int send_midi_async(struct usb_line6 *line6, unsigned char *data,
+                           int length);
+
+/*
+        Pass data received via USB to MIDI.
+*/
+void line6_midi_receive(struct usb_line6 *line6, unsigned char *data,
+                        int length)
+{
+        if (line6->line6midi->substream_receive)
+                snd_rawmidi_receive(line6->line6midi->substream_receive,
+                                    data, length);
+}
+
+/*
+        Read data from MIDI buffer and transmit them via USB.
+*/
+static void line6_midi_transmit(struct snd_rawmidi_substream *substream)
+{
+        struct usb_line6 *line6 =
+            line6_rawmidi_substream_midi(substream)->line6;
+        struct snd_line6_midi *line6midi = line6->line6midi;
+        struct midi_buffer *mb = &line6midi->midibuf_out;
+        unsigned char chunk[LINE6_FALLBACK_MAXPACKETSIZE];
+        int req, done;
+
+        for (;;) {
+                req = min(line6_midibuf_bytes_free(mb), line6->max_packet_size);
+                done = snd_rawmidi_transmit_peek(substream, chunk, req);
+
+                if (done == 0)
+                        break;
+
+                line6_midibuf_write(mb, chunk, done);
+                snd_rawmidi_transmit_ack(substream, done);
+        }
+
+        for (;;) {
+                done = line6_midibuf_read(mb, chunk,
+                                          LINE6_FALLBACK_MAXPACKETSIZE);
+
+                if (done == 0)
+                        break;
+
+                send_midi_async(line6, chunk, done);
+        }
+}
+
+/*
+        Notification of completion of MIDI transmission.
+*/
+static void midi_sent(struct urb *urb)
+{
+        unsigned long flags;
+        int status;
+        int num;
+        struct usb_line6 *line6 = (struct usb_line6 *)urb->context;
+
+        status = urb->status;
+        kfree(urb->transfer_buffer);
+        usb_free_urb(urb);
+
+        if (status == -ESHUTDOWN)
+                return;
+
+        spin_lock_irqsave(&line6->line6midi->lock, flags);
+        num = --line6->line6midi->num_active_send_urbs;
+
+        if (num == 0) {
+                line6_midi_transmit(line6->line6midi->substream_transmit);
+                num = line6->line6midi->num_active_send_urbs;
+        }
+
+        if (num == 0)
+                wake_up(&line6->line6midi->send_wait);
+
+        spin_unlock_irqrestore(&line6->line6midi->lock, flags);
+}
+
+/*
+        Send an asynchronous MIDI message.
+        Assumes that line6->line6midi->lock is held
+        (i.e., this function is serialized).
+*/
+static int send_midi_async(struct usb_line6 *line6, unsigned char *data,
+                           int length)
+{
+        struct urb *urb;
+        int retval;
+        unsigned char *transfer_buffer;
+
+        urb = usb_alloc_urb(0, GFP_ATOMIC);
+
+        if (urb == NULL)
+                return -ENOMEM;
+
+        transfer_buffer = kmemdup(data, length, GFP_ATOMIC);
+
+        if (transfer_buffer == NULL) {
+                usb_free_urb(urb);
+                return -ENOMEM;
+        }
+
+        usb_fill_int_urb(urb, line6->usbdev,
+                         usb_sndbulkpipe(line6->usbdev,
+                                         line6->properties->ep_ctrl_w),
+                         transfer_buffer, length, midi_sent, line6,
+                         line6->interval);
+        urb->actual_length = 0;
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
+
+        if (retval < 0) {
+                dev_err(line6->ifcdev, "usb_submit_urb failed\n");
+                usb_free_urb(urb);
+                return retval;
+        }
+
+        ++line6->line6midi->num_active_send_urbs;
+        return 0;
+}
+
+static int line6_midi_output_open(struct snd_rawmidi_substream *substream)
+{
+        return 0;
+}
+
+static int line6_midi_output_close(struct snd_rawmidi_substream *substream)
+{
+        return 0;
+}
+
+static void line6_midi_output_trigger(struct snd_rawmidi_substream *substream,
+                                      int up)
+{
+        unsigned long flags;
+        struct usb_line6 *line6 =
+            line6_rawmidi_substream_midi(substream)->line6;
+
+        line6->line6midi->substream_transmit = substream;
+        spin_lock_irqsave(&line6->line6midi->lock, flags);
+
+        if (line6->line6midi->num_active_send_urbs == 0)
+                line6_midi_transmit(substream);
+
+        spin_unlock_irqrestore(&line6->line6midi->lock, flags);
+}
+
+static void line6_midi_output_drain(struct snd_rawmidi_substream *substream)
+{
+        struct usb_line6 *line6 =
+            line6_rawmidi_substream_midi(substream)->line6;
+        struct snd_line6_midi *midi = line6->line6midi;
+
+        wait_event_interruptible(midi->send_wait,
+                                 midi->num_active_send_urbs == 0);
+}
+
+static int line6_midi_input_open(struct snd_rawmidi_substream *substream)
+{
+        return 0;
+}
+
+static int line6_midi_input_close(struct snd_rawmidi_substream *substream)
+{
+        return 0;
+}
+
+static void line6_midi_input_trigger(struct snd_rawmidi_substream *substream,
+                                     int up)
+{
+        struct usb_line6 *line6 =
+            line6_rawmidi_substream_midi(substream)->line6;
+
+        if (up)
+                line6->line6midi->substream_receive = substream;
+        else
+                line6->line6midi->substream_receive = NULL;
+}
+
+static struct snd_rawmidi_ops line6_midi_output_ops = {
+        .open = line6_midi_output_open,
+        .close = line6_midi_output_close,
+        .trigger = line6_midi_output_trigger,
+        .drain = line6_midi_output_drain,
+};
+
+static struct snd_rawmidi_ops line6_midi_input_ops = {
+        .open = line6_midi_input_open,
+        .close = line6_midi_input_close,
+        .trigger = line6_midi_input_trigger,
+};
+
+/* Create a MIDI device */
+static int snd_line6_new_midi(struct usb_line6 *line6,
+                              struct snd_rawmidi **rmidi_ret)
+{
+        struct snd_rawmidi *rmidi;
+        int err;
+
+        err = snd_rawmidi_new(line6->card, "Line 6 MIDI", 0, 1, 1, rmidi_ret);
+        if (err < 0)
+                return err;
+
+        rmidi = *rmidi_ret;
+        strcpy(rmidi->id, line6->properties->id);
+        strcpy(rmidi->name, line6->properties->name);
+
+        rmidi->info_flags =
+            SNDRV_RAWMIDI_INFO_OUTPUT |
+            SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
+
+        snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
+                            &line6_midi_output_ops);
+        snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
+                            &line6_midi_input_ops);
+        return 0;
+}
+
+/* MIDI device destructor */
+static void snd_line6_midi_free(struct snd_rawmidi *rmidi)
+{
+        struct snd_line6_midi *line6midi = rmidi->private_data;
+
+        line6_midibuf_destroy(&line6midi->midibuf_in);
+        line6_midibuf_destroy(&line6midi->midibuf_out);
+        kfree(line6midi);
+}
+
+/*
+        Initialize the Line 6 MIDI subsystem.
+*/
+int line6_init_midi(struct usb_line6 *line6)
+{
+        int err;
+        struct snd_rawmidi *rmidi;
+        struct snd_line6_midi *line6midi;
+
+        if (!(line6->properties->capabilities & LINE6_CAP_CONTROL)) {
+                /* skip MIDI initialization and report success */
+                return 0;
+        }
+
+        err = snd_line6_new_midi(line6, &rmidi);
+        if (err < 0)
+                return err;
+
+        line6midi = kzalloc(sizeof(struct snd_line6_midi), GFP_KERNEL);
+        if (!line6midi)
+                return -ENOMEM;
+
+        rmidi->private_data = line6midi;
+        rmidi->private_free = snd_line6_midi_free;
+
+        init_waitqueue_head(&line6midi->send_wait);
+        spin_lock_init(&line6midi->lock);
+        line6midi->line6 = line6;
+
+        err = line6_midibuf_init(&line6midi->midibuf_in, MIDI_BUFFER_SIZE, 0);
+        if (err < 0)
+                return err;
+
+        err = line6_midibuf_init(&line6midi->midibuf_out, MIDI_BUFFER_SIZE, 1);
+        if (err < 0)
+                return err;
+
+        line6->line6midi = line6midi;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(line6_init_midi);
diff --git a/sound/usb/line6/midi.h b/sound/usb/line6/midi.h
new file mode 100644
index 000000000000..cf82d69e2747
--- /dev/null
+++ b/sound/usb/line6/midi.h
@@ -0,0 +1,51 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#ifndef MIDI_H
+#define MIDI_H
+
+#include <sound/rawmidi.h>
+
+#include "midibuf.h"
+
+#define MIDI_BUFFER_SIZE 1024
+
+struct snd_line6_midi {
+        /* Pointer back to the Line 6 driver data structure */
+        struct usb_line6 *line6;
+
+        /* MIDI substream for receiving (or NULL if not active) */
+        struct snd_rawmidi_substream *substream_receive;
+
+        /* MIDI substream for transmitting (or NULL if not active) */
+        struct snd_rawmidi_substream *substream_transmit;
+
+        /* Number of currently active MIDI send URBs */
+        int num_active_send_urbs;
+
+        /* Spin lock to protect MIDI buffer handling */
+        spinlock_t lock;
+
+        /* Wait queue for MIDI transmission */
+        wait_queue_head_t send_wait;
+
+        /* Buffer for incoming MIDI stream */
+        struct midi_buffer midibuf_in;
+
+        /* Buffer for outgoing MIDI stream */
+        struct midi_buffer midibuf_out;
+};
+
+extern int line6_init_midi(struct usb_line6 *line6);
+extern void line6_midi_receive(struct usb_line6 *line6, unsigned char *data,
+                               int length);
+
+#endif
diff --git a/sound/usb/line6/midibuf.c b/sound/usb/line6/midibuf.c
new file mode 100644
index 000000000000..36a610ba342e
--- /dev/null
+++ b/sound/usb/line6/midibuf.c
@@ -0,0 +1,252 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#include <linux/slab.h>
+
+#include "midibuf.h"
+
+static int midibuf_message_length(unsigned char code)
+{
+        int message_length;
+
+        if (code < 0x80)
+                message_length = -1;
+        else if (code < 0xf0) {
+                static const int length[] = { 3, 3, 3, 3, 2, 2, 3 };
+
+                message_length = length[(code >> 4) - 8];
+        } else {
+                /*
+                   Note that according to the MIDI specification 0xf2 is
+                   the "Song Position Pointer", but this is used by Line 6
+                   to send sysex messages to the host.
+                 */
+                static const int length[] = { -1, 2, -1, 2, -1, -1, 1, 1, 1, 1,
+                        1, 1, 1, -1, 1, 1
+                };
+                message_length = length[code & 0x0f];
+        }
+
+        return message_length;
+}
+
+static int midibuf_is_empty(struct midi_buffer *this)
+{
+        return (this->pos_read == this->pos_write) && !this->full;
+}
+
+static int midibuf_is_full(struct midi_buffer *this)
+{
+        return this->full;
+}
+
+void line6_midibuf_reset(struct midi_buffer *this)
+{
+        this->pos_read = this->pos_write = this->full = 0;
+        this->command_prev = -1;
+}
+
+int line6_midibuf_init(struct midi_buffer *this, int size, int split)
+{
+        this->buf = kmalloc(size, GFP_KERNEL);
+
+        if (this->buf == NULL)
+                return -ENOMEM;
+
+        this->size = size;
+        this->split = split;
+        line6_midibuf_reset(this);
+        return 0;
+}
+
+int line6_midibuf_bytes_free(struct midi_buffer *this)
+{
+        return
+            midibuf_is_full(this) ?
+            0 :
+            (this->pos_read - this->pos_write + this->size - 1) % this->size +
+            1;
+}
+
+int line6_midibuf_bytes_used(struct midi_buffer *this)
+{
+        return
+            midibuf_is_empty(this) ?
+            0 :
+            (this->pos_write - this->pos_read + this->size - 1) % this->size +
+            1;
+}
+
+int line6_midibuf_write(struct midi_buffer *this, unsigned char *data,
+                        int length)
+{
+        int bytes_free;
+        int length1, length2;
+        int skip_active_sense = 0;
+
+        if (midibuf_is_full(this) || (length <= 0))
+                return 0;
+
+        /* skip trailing active sense */
+        if (data[length - 1] == 0xfe) {
+                --length;
+                skip_active_sense = 1;
+        }
+
+        bytes_free = line6_midibuf_bytes_free(this);
+
+        if (length > bytes_free)
+                length = bytes_free;
+
+        if (length > 0) {
+                length1 = this->size - this->pos_write;
+
+                if (length < length1) {
+                        /* no buffer wraparound */
+                        memcpy(this->buf + this->pos_write, data, length);
+                        this->pos_write += length;
+                } else {
+                        /* buffer wraparound */
+                        length2 = length - length1;
+                        memcpy(this->buf + this->pos_write, data, length1);
+                        memcpy(this->buf, data + length1, length2);
+                        this->pos_write = length2;
+                }
+
+                if (this->pos_write == this->pos_read)
+                        this->full = 1;
+        }
+
+        return length + skip_active_sense;
+}
+
+int line6_midibuf_read(struct midi_buffer *this, unsigned char *data,
+                       int length)
+{
+        int bytes_used;
+        int length1, length2;
+        int command;
+        int midi_length;
+        int repeat = 0;
+        int i;
+
+        /* we need to be able to store at least a 3 byte MIDI message */
+        if (length < 3)
+                return -EINVAL;
+
+        if (midibuf_is_empty(this))
+                return 0;
+
+        bytes_used = line6_midibuf_bytes_used(this);
+
+        if (length > bytes_used)
+                length = bytes_used;
+
+        length1 = this->size - this->pos_read;
+
+        /* check MIDI command length */
+        command = this->buf[this->pos_read];
+
+        if (command & 0x80) {
+                midi_length = midibuf_message_length(command);
+                this->command_prev = command;
+        } else {
+                if (this->command_prev > 0) {
+                        int midi_length_prev =
+                            midibuf_message_length(this->command_prev);
+
+                        if (midi_length_prev > 0) {
+                                midi_length = midi_length_prev - 1;
+                                repeat = 1;
+                        } else
+                                midi_length = -1;
+                } else
+                        midi_length = -1;
+        }
+
+        if (midi_length < 0) {
+                /* search for end of message */
+                if (length < length1) {
+                        /* no buffer wraparound */
+                        for (i = 1; i < length; ++i)
+                                if (this->buf[this->pos_read + i] & 0x80)
+                                        break;
+
+                        midi_length = i;
+                } else {
+                        /* buffer wraparound */
+                        length2 = length - length1;
+
+                        for (i = 1; i < length1; ++i)
+                                if (this->buf[this->pos_read + i] & 0x80)
+                                        break;
+
+                        if (i < length1)
+                                midi_length = i;
+                        else {
+                                for (i = 0; i < length2; ++i)
+                                        if (this->buf[i] & 0x80)
+                                                break;
+
+                                midi_length = length1 + i;
+                        }
+                }
+
+                if (midi_length == length)
+                        midi_length = -1;       /* end of message not found */
+        }
+
+        if (midi_length < 0) {
+                if (!this->split)
+                        return 0;       /* command is not yet complete */
+        } else {
+                if (length < midi_length)
+                        return 0;       /* command is not yet complete */
+
+                length = midi_length;
+        }
+
+        if (length < length1) {
+                /* no buffer wraparound */
+                memcpy(data + repeat, this->buf + this->pos_read, length);
+                this->pos_read += length;
+        } else {
+                /* buffer wraparound */
+                length2 = length - length1;
+                memcpy(data + repeat, this->buf + this->pos_read, length1);
+                memcpy(data + repeat + length1, this->buf, length2);
+                this->pos_read = length2;
+        }
+
+        if (repeat)
+                data[0] = this->command_prev;
+
+        this->full = 0;
+        return length + repeat;
+}
+
+int line6_midibuf_ignore(struct midi_buffer *this, int length)
+{
+        int bytes_used = line6_midibuf_bytes_used(this);
+
+        if (length > bytes_used)
+                length = bytes_used;
+
+        this->pos_read = (this->pos_read + length) % this->size;
+        this->full = 0;
+        return length;
+}
+
+void line6_midibuf_destroy(struct midi_buffer *this)
+{
+        kfree(this->buf);
+        this->buf = NULL;
+}
diff --git a/sound/usb/line6/midibuf.h b/sound/usb/line6/midibuf.h
new file mode 100644
index 000000000000..6ea21ffb6627
--- /dev/null
+++ b/sound/usb/line6/midibuf.h
@@ -0,0 +1,35 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#ifndef MIDIBUF_H
+#define MIDIBUF_H
+
+struct midi_buffer {
+        unsigned char *buf;
+        int size;
+        int split;
+        int pos_read, pos_write;
+        int full;
+        int command_prev;
+};
+
+extern int line6_midibuf_bytes_used(struct midi_buffer *mb);
+extern int line6_midibuf_bytes_free(struct midi_buffer *mb);
+extern void line6_midibuf_destroy(struct midi_buffer *mb);
+extern int line6_midibuf_ignore(struct midi_buffer *mb, int length);
+extern int line6_midibuf_init(struct midi_buffer *mb, int size, int split);
+extern int line6_midibuf_read(struct midi_buffer *mb, unsigned char *data,
+                              int length);
+extern void line6_midibuf_reset(struct midi_buffer *mb);
+extern int line6_midibuf_write(struct midi_buffer *mb, unsigned char *data,
+                               int length);
+
+#endif
diff --git a/sound/usb/line6/pcm.c b/sound/usb/line6/pcm.c
new file mode 100644
index 000000000000..8461d6bf992f
--- /dev/null
+++ b/sound/usb/line6/pcm.c
@@ -0,0 +1,588 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/export.h>
+#include <sound/core.h>
+#include <sound/control.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+
+#include "capture.h"
+#include "driver.h"
+#include "playback.h"
+
+/* impulse response volume controls */
+static int snd_line6_impulse_volume_info(struct snd_kcontrol *kcontrol,
+                                         struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 255;
+        return 0;
+}
+
+static int snd_line6_impulse_volume_get(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.integer.value[0] = line6pcm->impulse_volume;
+        return 0;
+}
+
+static int snd_line6_impulse_volume_put(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+        int value = ucontrol->value.integer.value[0];
+        int err;
+
+        if (line6pcm->impulse_volume == value)
+                return 0;
+
+        line6pcm->impulse_volume = value;
+        if (value > 0) {
+                err = line6_pcm_acquire(line6pcm, LINE6_STREAM_IMPULSE);
+                if (err < 0) {
+                        line6pcm->impulse_volume = 0;
+                        line6_pcm_release(line6pcm, LINE6_STREAM_IMPULSE);
+                        return err;
+                }
+        } else {
+                line6_pcm_release(line6pcm, LINE6_STREAM_IMPULSE);
+        }
+        return 1;
+}
+
+/* impulse response period controls */
+static int snd_line6_impulse_period_info(struct snd_kcontrol *kcontrol,
+                                         struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 2000;
+        return 0;
+}
+
+static int snd_line6_impulse_period_get(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.integer.value[0] = line6pcm->impulse_period;
+        return 0;
+}
+
+static int snd_line6_impulse_period_put(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+        int value = ucontrol->value.integer.value[0];
+
+        if (line6pcm->impulse_period == value)
+                return 0;
+
+        line6pcm->impulse_period = value;
+        return 1;
+}
+
+/*
+        Unlink all currently active URBs.
+*/
+static void line6_unlink_audio_urbs(struct snd_line6_pcm *line6pcm,
+                                    struct line6_pcm_stream *pcms)
+{
+        int i;
+
+        for (i = 0; i < LINE6_ISO_BUFFERS; i++) {
+                if (test_bit(i, &pcms->active_urbs)) {
+                        if (!test_and_set_bit(i, &pcms->unlink_urbs))
+                                usb_unlink_urb(pcms->urbs[i]);
+                }
+        }
+}
+
+/*
+        Wait until unlinking of all currently active URBs has been finished.
+*/
+static void line6_wait_clear_audio_urbs(struct snd_line6_pcm *line6pcm,
+                                        struct line6_pcm_stream *pcms)
+{
+        int timeout = HZ;
+        int i;
+        int alive;
+
+        do {
+                alive = 0;
+                for (i = 0; i < LINE6_ISO_BUFFERS; i++) {
+                        if (test_bit(i, &pcms->active_urbs))
+                                alive++;
+                }
+                if (!alive)
+                        break;
+                set_current_state(TASK_UNINTERRUPTIBLE);
+                schedule_timeout(1);
+        } while (--timeout > 0);
+        if (alive)
+                dev_err(line6pcm->line6->ifcdev,
+                        "timeout: still %d active urbs..\n", alive);
+}
+
+static inline struct line6_pcm_stream *
+get_stream(struct snd_line6_pcm *line6pcm, int direction)
+{
+        return (direction == SNDRV_PCM_STREAM_PLAYBACK) ?
+                &line6pcm->out : &line6pcm->in;
+}
+
+/* allocate a buffer if not opened yet;
+ * call this in line6pcm.state_change mutex
+ */
+static int line6_buffer_acquire(struct snd_line6_pcm *line6pcm,
+                                struct line6_pcm_stream *pstr, int type)
+{
+        /* Invoked multiple times in a row so allocate once only */
+        if (!test_and_set_bit(type, &pstr->opened) && !pstr->buffer) {
+                pstr->buffer = kmalloc(LINE6_ISO_BUFFERS * LINE6_ISO_PACKETS *
+                                       line6pcm->max_packet_size, GFP_KERNEL);
+                if (!pstr->buffer)
+                        return -ENOMEM;
+        }
+        return 0;
+}
+
+/* free a buffer if all streams are closed;
+ * call this in line6pcm.state_change mutex
+ */
+static void line6_buffer_release(struct snd_line6_pcm *line6pcm,
+                                 struct line6_pcm_stream *pstr, int type)
+{
+
+        clear_bit(type, &pstr->opened);
+        if (!pstr->opened) {
+                line6_wait_clear_audio_urbs(line6pcm, pstr);
+                kfree(pstr->buffer);
+                pstr->buffer = NULL;
+        }
+}
+
+/* start a PCM stream */
+static int line6_stream_start(struct snd_line6_pcm *line6pcm, int direction,
+                              int type)
+{
+        unsigned long flags;
+        struct line6_pcm_stream *pstr = get_stream(line6pcm, direction);
+        int ret = 0;
+
+        spin_lock_irqsave(&pstr->lock, flags);
+        if (!test_and_set_bit(type, &pstr->running)) {
+                if (pstr->active_urbs || pstr->unlink_urbs) {
+                        ret = -EBUSY;
+                        goto error;
+                }
+
+                pstr->count = 0;
+                /* Submit all currently available URBs */
+                if (direction == SNDRV_PCM_STREAM_PLAYBACK)
+                        ret = line6_submit_audio_out_all_urbs(line6pcm);
+                else
+                        ret = line6_submit_audio_in_all_urbs(line6pcm);
+        }
+ error:
+        if (ret < 0)
+                clear_bit(type, &pstr->running);
+        spin_unlock_irqrestore(&pstr->lock, flags);
+        return ret;
+}
+
+/* stop a PCM stream; this doesn't sync with the unlinked URBs */
+static void line6_stream_stop(struct snd_line6_pcm *line6pcm, int direction,
+                          int type)
+{
+        unsigned long flags;
+        struct line6_pcm_stream *pstr = get_stream(line6pcm, direction);
+
+        spin_lock_irqsave(&pstr->lock, flags);
+        clear_bit(type, &pstr->running);
+        if (!pstr->running) {
+                line6_unlink_audio_urbs(line6pcm, pstr);
+                if (direction == SNDRV_PCM_STREAM_CAPTURE) {
+                        line6pcm->prev_fbuf = NULL;
+                        line6pcm->prev_fsize = 0;
+                }
+        }
+        spin_unlock_irqrestore(&pstr->lock, flags);
+}
+
+/* common PCM trigger callback */
+int snd_line6_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
+        struct snd_pcm_substream *s;
+        int err;
+
+        clear_bit(LINE6_FLAG_PREPARED, &line6pcm->flags);
+
+        snd_pcm_group_for_each_entry(s, substream) {
+                if (s->pcm->card != substream->pcm->card)
+                        continue;
+
+                switch (cmd) {
+                case SNDRV_PCM_TRIGGER_START:
+                case SNDRV_PCM_TRIGGER_RESUME:
+                        err = line6_stream_start(line6pcm, s->stream,
+                                                 LINE6_STREAM_PCM);
+                        if (err < 0)
+                                return err;
+                        break;
+
+                case SNDRV_PCM_TRIGGER_STOP:
+                case SNDRV_PCM_TRIGGER_SUSPEND:
+                        line6_stream_stop(line6pcm, s->stream,
+                                          LINE6_STREAM_PCM);
+                        break;
+
+                case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                        if (s->stream != SNDRV_PCM_STREAM_PLAYBACK)
+                                return -EINVAL;
+                        set_bit(LINE6_FLAG_PAUSE_PLAYBACK, &line6pcm->flags);
+                        break;
+
+                case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                        if (s->stream != SNDRV_PCM_STREAM_PLAYBACK)
+                                return -EINVAL;
+                        clear_bit(LINE6_FLAG_PAUSE_PLAYBACK, &line6pcm->flags);
+                        break;
+
+                default:
+                        return -EINVAL;
+                }
+        }
+
+        return 0;
+}
+
+/* common PCM pointer callback */
+snd_pcm_uframes_t snd_line6_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
+        struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream);
+
+        return pstr->pos_done;
+}
+
+/* Acquire and start duplex streams:
+ * type is either LINE6_STREAM_IMPULSE or LINE6_STREAM_MONITOR
+ */
+int line6_pcm_acquire(struct snd_line6_pcm *line6pcm, int type)
+{
+        struct line6_pcm_stream *pstr;
+        int ret = 0, dir;
+
+        mutex_lock(&line6pcm->state_mutex);
+        for (dir = 0; dir < 2; dir++) {
+                pstr = get_stream(line6pcm, dir);
+                ret = line6_buffer_acquire(line6pcm, pstr, type);
+                if (ret < 0)
+                        goto error;
+                if (!pstr->running)
+                        line6_wait_clear_audio_urbs(line6pcm, pstr);
+        }
+        for (dir = 0; dir < 2; dir++) {
+                ret = line6_stream_start(line6pcm, dir, type);
+                if (ret < 0)
+                        goto error;
+        }
+ error:
+        mutex_unlock(&line6pcm->state_mutex);
+        if (ret < 0)
+                line6_pcm_release(line6pcm, type);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(line6_pcm_acquire);
+
+/* Stop and release duplex streams */
+void line6_pcm_release(struct snd_line6_pcm *line6pcm, int type)
+{
+        struct line6_pcm_stream *pstr;
+        int dir;
+
+        mutex_lock(&line6pcm->state_mutex);
+        for (dir = 0; dir < 2; dir++)
+                line6_stream_stop(line6pcm, dir, type);
+        for (dir = 0; dir < 2; dir++) {
+                pstr = get_stream(line6pcm, dir);
+                line6_buffer_release(line6pcm, pstr, type);
+        }
+        mutex_unlock(&line6pcm->state_mutex);
+}
+EXPORT_SYMBOL_GPL(line6_pcm_release);
+
+/* common PCM hw_params callback */
+int snd_line6_hw_params(struct snd_pcm_substream *substream,
+                        struct snd_pcm_hw_params *hw_params)
+{
+        int ret;
+        struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
+        struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream);
+
+        mutex_lock(&line6pcm->state_mutex);
+        ret = line6_buffer_acquire(line6pcm, pstr, LINE6_STREAM_PCM);
+        if (ret < 0)
+                goto error;
+
+        ret = snd_pcm_lib_malloc_pages(substream,
+                                       params_buffer_bytes(hw_params));
+        if (ret < 0) {
+                line6_buffer_release(line6pcm, pstr, LINE6_STREAM_PCM);
+                goto error;
+        }
+
+        pstr->period = params_period_bytes(hw_params);
+ error:
+        mutex_unlock(&line6pcm->state_mutex);
+        return ret;
+}
+
+/* common PCM hw_free callback */
+int snd_line6_hw_free(struct snd_pcm_substream *substream)
+{
+        struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
+        struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream);
+
+        mutex_lock(&line6pcm->state_mutex);
+        line6_buffer_release(line6pcm, pstr, LINE6_STREAM_PCM);
+        mutex_unlock(&line6pcm->state_mutex);
+        return snd_pcm_lib_free_pages(substream);
+}
+
+
+/* control info callback */
+static int snd_line6_control_playback_info(struct snd_kcontrol *kcontrol,
+                                           struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 2;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 256;
+        return 0;
+}
+
+/* control get callback */
+static int snd_line6_control_playback_get(struct snd_kcontrol *kcontrol,
+                                          struct snd_ctl_elem_value *ucontrol)
+{
+        int i;
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+
+        for (i = 0; i < 2; i++)
+                ucontrol->value.integer.value[i] = line6pcm->volume_playback[i];
+
+        return 0;
+}
+
+/* control put callback */
+static int snd_line6_control_playback_put(struct snd_kcontrol *kcontrol,
+                                          struct snd_ctl_elem_value *ucontrol)
+{
+        int i, changed = 0;
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+
+        for (i = 0; i < 2; i++)
+                if (line6pcm->volume_playback[i] !=
+                    ucontrol->value.integer.value[i]) {
+                        line6pcm->volume_playback[i] =
+                            ucontrol->value.integer.value[i];
+                        changed = 1;
+                }
+
+        return changed;
+}
+
+/* control definition */
+static struct snd_kcontrol_new line6_controls[] = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "PCM Playback Volume",
+                .info = snd_line6_control_playback_info,
+                .get = snd_line6_control_playback_get,
+                .put = snd_line6_control_playback_put
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Impulse Response Volume",
+                .info = snd_line6_impulse_volume_info,
+                .get = snd_line6_impulse_volume_get,
+                .put = snd_line6_impulse_volume_put
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Impulse Response Period",
+                .info = snd_line6_impulse_period_info,
+                .get = snd_line6_impulse_period_get,
+                .put = snd_line6_impulse_period_put
+        },
+};
+
+/*
+        Cleanup the PCM device.
+*/
+static void cleanup_urbs(struct line6_pcm_stream *pcms)
+{
+        int i;
+
+        for (i = 0; i < LINE6_ISO_BUFFERS; i++) {
+                if (pcms->urbs[i]) {
+                        usb_kill_urb(pcms->urbs[i]);
+                        usb_free_urb(pcms->urbs[i]);
+                }
+        }
+}
+
+static void line6_cleanup_pcm(struct snd_pcm *pcm)
+{
+        struct snd_line6_pcm *line6pcm = snd_pcm_chip(pcm);
+
+        cleanup_urbs(&line6pcm->out);
+        cleanup_urbs(&line6pcm->in);
+        kfree(line6pcm);
+}
+
+/* create a PCM device */
+static int snd_line6_new_pcm(struct usb_line6 *line6, struct snd_pcm **pcm_ret)
+{
+        struct snd_pcm *pcm;
+        int err;
+
+        err = snd_pcm_new(line6->card, (char *)line6->properties->name,
+                          0, 1, 1, pcm_ret);
+        if (err < 0)
+                return err;
+        pcm = *pcm_ret;
+        strcpy(pcm->name, line6->properties->name);
+
+        /* set operators */
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                        &snd_line6_playback_ops);
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_line6_capture_ops);
+
+        /* pre-allocation of buffers */
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
+                                              snd_dma_continuous_data
+                                              (GFP_KERNEL), 64 * 1024,
+                                              128 * 1024);
+        return 0;
+}
+
+/*
+        Sync with PCM stream stops.
+*/
+void line6_pcm_disconnect(struct snd_line6_pcm *line6pcm)
+{
+        line6_unlink_audio_urbs(line6pcm, &line6pcm->out);
+        line6_unlink_audio_urbs(line6pcm, &line6pcm->in);
+        line6_wait_clear_audio_urbs(line6pcm, &line6pcm->out);
+        line6_wait_clear_audio_urbs(line6pcm, &line6pcm->in);
+}
+
+/*
+        Create and register the PCM device and mixer entries.
+        Create URBs for playback and capture.
+*/
+int line6_init_pcm(struct usb_line6 *line6,
+                   struct line6_pcm_properties *properties)
+{
+        int i, err;
+        unsigned ep_read = line6->properties->ep_audio_r;
+        unsigned ep_write = line6->properties->ep_audio_w;
+        struct snd_pcm *pcm;
+        struct snd_line6_pcm *line6pcm;
+
+        if (!(line6->properties->capabilities & LINE6_CAP_PCM))
+                return 0;       /* skip PCM initialization and report success */
+
+        err = snd_line6_new_pcm(line6, &pcm);
+        if (err < 0)
+                return err;
+
+        line6pcm = kzalloc(sizeof(*line6pcm), GFP_KERNEL);
+        if (!line6pcm)
+                return -ENOMEM;
+
+        mutex_init(&line6pcm->state_mutex);
+        line6pcm->pcm = pcm;
+        line6pcm->properties = properties;
+        line6pcm->volume_playback[0] = line6pcm->volume_playback[1] = 255;
+        line6pcm->volume_monitor = 255;
+        line6pcm->line6 = line6;
+
+        /* Read and write buffers are sized identically, so choose minimum */
+        line6pcm->max_packet_size = min(
+                        usb_maxpacket(line6->usbdev,
+                                usb_rcvisocpipe(line6->usbdev, ep_read), 0),
+                        usb_maxpacket(line6->usbdev,
+                                usb_sndisocpipe(line6->usbdev, ep_write), 1));
+
+        spin_lock_init(&line6pcm->out.lock);
+        spin_lock_init(&line6pcm->in.lock);
+        line6pcm->impulse_period = LINE6_IMPULSE_DEFAULT_PERIOD;
+
+        line6->line6pcm = line6pcm;
+
+        pcm->private_data = line6pcm;
+        pcm->private_free = line6_cleanup_pcm;
+
+        err = line6_create_audio_out_urbs(line6pcm);
+        if (err < 0)
+                return err;
+
+        err = line6_create_audio_in_urbs(line6pcm);
+        if (err < 0)
+                return err;
+
+        /* mixer: */
+        for (i = 0; i < ARRAY_SIZE(line6_controls); i++) {
+                err = snd_ctl_add(line6->card,
+                                  snd_ctl_new1(&line6_controls[i], line6pcm));
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(line6_init_pcm);
+
+/* prepare pcm callback */
+int snd_line6_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
+        struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream);
+
+        mutex_lock(&line6pcm->state_mutex);
+        if (!pstr->running)
+                line6_wait_clear_audio_urbs(line6pcm, pstr);
+
+        if (!test_and_set_bit(LINE6_FLAG_PREPARED, &line6pcm->flags)) {
+                line6pcm->out.count = 0;
+                line6pcm->out.pos = 0;
+                line6pcm->out.pos_done = 0;
+                line6pcm->out.bytes = 0;
+                line6pcm->in.count = 0;
+                line6pcm->in.pos_done = 0;
+                line6pcm->in.bytes = 0;
+        }
+
+        mutex_unlock(&line6pcm->state_mutex);
+        return 0;
+}
diff --git a/sound/usb/line6/pcm.h b/sound/usb/line6/pcm.h
new file mode 100644
index 000000000000..508410adbd51
--- /dev/null
+++ b/sound/usb/line6/pcm.h
@@ -0,0 +1,197 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+/*
+        PCM interface to POD series devices.
+*/
+
+#ifndef PCM_H
+#define PCM_H
+
+#include <sound/pcm.h>
+
+#include "driver.h"
+
+/* number of URBs */
+#define LINE6_ISO_BUFFERS       2
+
+/*
+        number of USB frames per URB
+        The Line 6 Windows driver always transmits two frames per packet, but
+        the Linux driver performs significantly better (i.e., lower latency)
+        with only one frame per packet.
+*/
+#define LINE6_ISO_PACKETS       1
+
+/* in a "full speed" device (such as the PODxt Pro) this means 1ms */
+#define LINE6_ISO_INTERVAL      1
+
+#define LINE6_IMPULSE_DEFAULT_PERIOD 100
+
+/*
+        Get substream from Line 6 PCM data structure
+*/
+#define get_substream(line6pcm, stream) \
+                (line6pcm->pcm->streams[stream].substream)
+
+/*
+        PCM mode bits.
+
+        There are several features of the Line 6 USB driver which require PCM
+        data to be exchanged with the device:
+        *) PCM playback and capture via ALSA
+        *) software monitoring (for devices without hardware monitoring)
+        *) optional impulse response measurement
+        However, from the device's point of view, there is just a single
+        capture and playback stream, which must be shared between these
+        subsystems. It is therefore necessary to maintain the state of the
+        subsystems with respect to PCM usage.
+
+        We define two bit flags, "opened" and "running", for each playback
+        or capture stream.  Both can contain the bit flag corresponding to
+        LINE6_STREAM_* type,
+          LINE6_STREAM_PCM = ALSA PCM playback or capture
+          LINE6_STREAM_MONITOR = software monitoring
+          IMPULSE = optional impulse response measurement
+        The opened flag indicates whether the buffer is allocated while
+        the running flag indicates whether the stream is running.
+
+        For monitor or impulse operations, the driver needs to call
+        line6_pcm_acquire() or line6_pcm_release() with the appropriate
+        LINE6_STREAM_* flag.
+*/
+
+/* stream types */
+enum {
+        LINE6_STREAM_PCM,
+        LINE6_STREAM_MONITOR,
+        LINE6_STREAM_IMPULSE,
+};
+
+/* misc bit flags for PCM operation */
+enum {
+        LINE6_FLAG_PAUSE_PLAYBACK,
+        LINE6_FLAG_PREPARED,
+};
+
+struct line6_pcm_properties {
+        struct snd_pcm_hardware playback_hw, capture_hw;
+        struct snd_pcm_hw_constraint_ratdens rates;
+        int bytes_per_frame;
+};
+
+struct line6_pcm_stream {
+        /* allocated URBs */
+        struct urb *urbs[LINE6_ISO_BUFFERS];
+
+        /* Temporary buffer;
+         * Since the packet size is not known in advance, this buffer is
+         * large enough to store maximum size packets.
+         */
+        unsigned char *buffer;
+
+        /* Free frame position in the buffer. */
+        snd_pcm_uframes_t pos;
+
+        /* Count processed bytes;
+         * This is modulo period size (to determine when a period is finished).
+         */
+        unsigned bytes;
+
+        /* Counter to create desired sample rate */
+        unsigned count;
+
+        /* period size in bytes */
+        unsigned period;
+
+        /* Processed frame position in the buffer;
+         * The contents of the ring buffer have been consumed by the USB
+         * subsystem (i.e., sent to the USB device) up to this position.
+         */
+        snd_pcm_uframes_t pos_done;
+
+        /* Bit mask of active URBs */
+        unsigned long active_urbs;
+
+        /* Bit mask of URBs currently being unlinked */
+        unsigned long unlink_urbs;
+
+        /* Spin lock to protect updates of the buffer positions (not contents)
+         */
+        spinlock_t lock;
+
+        /* Bit flags for operational stream types */
+        unsigned long opened;
+
+        /* Bit flags for running stream types */
+        unsigned long running;
+
+        int last_frame;
+};
+
+struct snd_line6_pcm {
+        /* Pointer back to the Line 6 driver data structure */
+        struct usb_line6 *line6;
+
+        /* Properties. */
+        struct line6_pcm_properties *properties;
+
+        /* ALSA pcm stream */
+        struct snd_pcm *pcm;
+
+        /* protection to state changes of in/out streams */
+        struct mutex state_mutex;
+
+        /* Capture and playback streams */
+        struct line6_pcm_stream in;
+        struct line6_pcm_stream out;
+
+        /* Previously captured frame (for software monitoring) */
+        unsigned char *prev_fbuf;
+
+        /* Size of previously captured frame (for software monitoring) */
+        int prev_fsize;
+
+        /* Maximum size of USB packet */
+        int max_packet_size;
+
+        /* PCM playback volume (left and right) */
+        int volume_playback[2];
+
+        /* PCM monitor volume */
+        int volume_monitor;
+
+        /* Volume of impulse response test signal (if zero, test is disabled) */
+        int impulse_volume;
+
+        /* Period of impulse response test signal */
+        int impulse_period;
+
+        /* Counter for impulse response test signal */
+        int impulse_count;
+
+        /* Several status bits (see LINE6_FLAG_*) */
+        unsigned long flags;
+};
+
+extern int line6_init_pcm(struct usb_line6 *line6,
+                          struct line6_pcm_properties *properties);
+extern int snd_line6_trigger(struct snd_pcm_substream *substream, int cmd);
+extern int snd_line6_prepare(struct snd_pcm_substream *substream);
+extern int snd_line6_hw_params(struct snd_pcm_substream *substream,
+                               struct snd_pcm_hw_params *hw_params);
+extern int snd_line6_hw_free(struct snd_pcm_substream *substream);
+extern snd_pcm_uframes_t snd_line6_pointer(struct snd_pcm_substream *substream);
+extern void line6_pcm_disconnect(struct snd_line6_pcm *line6pcm);
+extern int line6_pcm_acquire(struct snd_line6_pcm *line6pcm, int type);
+extern void line6_pcm_release(struct snd_line6_pcm *line6pcm, int type);
+
+#endif
diff --git a/sound/usb/line6/playback.c b/sound/usb/line6/playback.c
new file mode 100644
index 000000000000..05dee690f487
--- /dev/null
+++ b/sound/usb/line6/playback.c
@@ -0,0 +1,429 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+
+#include "capture.h"
+#include "driver.h"
+#include "pcm.h"
+#include "playback.h"
+
+/*
+        Software stereo volume control.
+*/
+static void change_volume(struct urb *urb_out, int volume[],
+                          int bytes_per_frame)
+{
+        int chn = 0;
+
+        if (volume[0] == 256 && volume[1] == 256)
+                return;         /* maximum volume - no change */
+
+        if (bytes_per_frame == 4) {
+                __le16 *p, *buf_end;
+
+                p = (__le16 *)urb_out->transfer_buffer;
+                buf_end = p + urb_out->transfer_buffer_length / sizeof(*p);
+
+                for (; p < buf_end; ++p) {
+                        short pv = le16_to_cpu(*p);
+                        int val = (pv * volume[chn & 1]) >> 8;
+                        pv = clamp(val, 0x7fff, -0x8000);
+                        *p = cpu_to_le16(pv);
+                        ++chn;
+                }
+        } else if (bytes_per_frame == 6) {
+                unsigned char *p, *buf_end;
+
+                p = (unsigned char *)urb_out->transfer_buffer;
+                buf_end = p + urb_out->transfer_buffer_length;
+
+                for (; p < buf_end; p += 3) {
+                        int val;
+
+                        val = p[0] + (p[1] << 8) + ((signed char)p[2] << 16);
+                        val = (val * volume[chn & 1]) >> 8;
+                        val = clamp(val, 0x7fffff, -0x800000);
+                        p[0] = val;
+                        p[1] = val >> 8;
+                        p[2] = val >> 16;
+                        ++chn;
+                }
+        }
+}
+
+/*
+        Create signal for impulse response test.
+*/
+static void create_impulse_test_signal(struct snd_line6_pcm *line6pcm,
+                                       struct urb *urb_out, int bytes_per_frame)
+{
+        int frames = urb_out->transfer_buffer_length / bytes_per_frame;
+
+        if (bytes_per_frame == 4) {
+                int i;
+                short *pi = (short *)line6pcm->prev_fbuf;
+                short *po = (short *)urb_out->transfer_buffer;
+
+                for (i = 0; i < frames; ++i) {
+                        po[0] = pi[0];
+                        po[1] = 0;
+                        pi += 2;
+                        po += 2;
+                }
+        } else if (bytes_per_frame == 6) {
+                int i, j;
+                unsigned char *pi = line6pcm->prev_fbuf;
+                unsigned char *po = urb_out->transfer_buffer;
+
+                for (i = 0; i < frames; ++i) {
+                        for (j = 0; j < bytes_per_frame / 2; ++j)
+                                po[j] = pi[j];
+
+                        for (; j < bytes_per_frame; ++j)
+                                po[j] = 0;
+
+                        pi += bytes_per_frame;
+                        po += bytes_per_frame;
+                }
+        }
+        if (--line6pcm->impulse_count <= 0) {
+                ((unsigned char *)(urb_out->transfer_buffer))[bytes_per_frame -
+                                                              1] =
+                    line6pcm->impulse_volume;
+                line6pcm->impulse_count = line6pcm->impulse_period;
+        }
+}
+
+/*
+        Add signal to buffer for software monitoring.
+*/
+static void add_monitor_signal(struct urb *urb_out, unsigned char *signal,
+                               int volume, int bytes_per_frame)
+{
+        if (volume == 0)
+                return;         /* zero volume - no change */
+
+        if (bytes_per_frame == 4) {
+                __le16 *pi, *po, *buf_end;
+
+                pi = (__le16 *)signal;
+                po = (__le16 *)urb_out->transfer_buffer;
+                buf_end = po + urb_out->transfer_buffer_length / sizeof(*po);
+
+                for (; po < buf_end; ++pi, ++po) {
+                        short pov = le16_to_cpu(*po);
+                        short piv = le16_to_cpu(*pi);
+                        int val = pov + ((piv * volume) >> 8);
+                        pov = clamp(val, 0x7fff, -0x8000);
+                        *po = cpu_to_le16(pov);
+                }
+        }
+
+        /*
+           We don't need to handle devices with 6 bytes per frame here
+           since they all support hardware monitoring.
+         */
+}
+
+/*
+        Find a free URB, prepare audio data, and submit URB.
+        must be called in line6pcm->out.lock context
+*/
+static int submit_audio_out_urb(struct snd_line6_pcm *line6pcm)
+{
+        int index;
+        int i, urb_size, urb_frames;
+        int ret;
+        const int bytes_per_frame = line6pcm->properties->bytes_per_frame;
+        const int frame_increment =
+                line6pcm->properties->rates.rats[0].num_min;
+        const int frame_factor =
+                line6pcm->properties->rates.rats[0].den *
+                (USB_INTERVALS_PER_SECOND / LINE6_ISO_INTERVAL);
+        struct urb *urb_out;
+
+        index =
+            find_first_zero_bit(&line6pcm->out.active_urbs, LINE6_ISO_BUFFERS);
+
+        if (index < 0 || index >= LINE6_ISO_BUFFERS) {
+                dev_err(line6pcm->line6->ifcdev, "no free URB found\n");
+                return -EINVAL;
+        }
+
+        urb_out = line6pcm->out.urbs[index];
+        urb_size = 0;
+
+        for (i = 0; i < LINE6_ISO_PACKETS; ++i) {
+                /* compute frame size for given sampling rate */
+                int fsize = 0;
+                struct usb_iso_packet_descriptor *fout =
+                    &urb_out->iso_frame_desc[i];
+
+                fsize = line6pcm->prev_fsize;
+                if (fsize == 0) {
+                        int n;
+
+                        line6pcm->out.count += frame_increment;
+                        n = line6pcm->out.count / frame_factor;
+                        line6pcm->out.count -= n * frame_factor;
+                        fsize = n * bytes_per_frame;
+                }
+
+                fout->offset = urb_size;
+                fout->length = fsize;
+                urb_size += fsize;
+        }
+
+        if (urb_size == 0) {
+                /* can't determine URB size */
+                dev_err(line6pcm->line6->ifcdev, "driver bug: urb_size = 0\n");
+                return -EINVAL;
+        }
+
+        urb_frames = urb_size / bytes_per_frame;
+        urb_out->transfer_buffer =
+            line6pcm->out.buffer +
+            index * LINE6_ISO_PACKETS * line6pcm->max_packet_size;
+        urb_out->transfer_buffer_length = urb_size;
+        urb_out->context = line6pcm;
+
+        if (test_bit(LINE6_STREAM_PCM, &line6pcm->out.running) &&
+            !test_bit(LINE6_FLAG_PAUSE_PLAYBACK, &line6pcm->flags)) {
+                struct snd_pcm_runtime *runtime =
+                    get_substream(line6pcm, SNDRV_PCM_STREAM_PLAYBACK)->runtime;
+
+                if (line6pcm->out.pos + urb_frames > runtime->buffer_size) {
+                        /*
+                           The transferred area goes over buffer boundary,
+                           copy the data to the temp buffer.
+                         */
+                        int len;
+
+                        len = runtime->buffer_size - line6pcm->out.pos;
+
+                        if (len > 0) {
+                                memcpy(urb_out->transfer_buffer,
+                                       runtime->dma_area +
+                                       line6pcm->out.pos * bytes_per_frame,
+                                       len * bytes_per_frame);
+                                memcpy(urb_out->transfer_buffer +
+                                       len * bytes_per_frame, runtime->dma_area,
+                                       (urb_frames - len) * bytes_per_frame);
+                        } else
+                                dev_err(line6pcm->line6->ifcdev, "driver bug: len = %d\n",
+                                        len);
+                } else {
+                        memcpy(urb_out->transfer_buffer,
+                               runtime->dma_area +
+                               line6pcm->out.pos * bytes_per_frame,
+                               urb_out->transfer_buffer_length);
+                }
+
+                line6pcm->out.pos += urb_frames;
+                if (line6pcm->out.pos >= runtime->buffer_size)
+                        line6pcm->out.pos -= runtime->buffer_size;
+
+                change_volume(urb_out, line6pcm->volume_playback,
+                              bytes_per_frame);
+        } else {
+                memset(urb_out->transfer_buffer, 0,
+                       urb_out->transfer_buffer_length);
+        }
+
+        spin_lock_nested(&line6pcm->in.lock, SINGLE_DEPTH_NESTING);
+        if (line6pcm->prev_fbuf) {
+                if (test_bit(LINE6_STREAM_IMPULSE, &line6pcm->out.running)) {
+                        create_impulse_test_signal(line6pcm, urb_out,
+                                                   bytes_per_frame);
+                        if (test_bit(LINE6_STREAM_PCM, &line6pcm->in.running)) {
+                                line6_capture_copy(line6pcm,
+                                                   urb_out->transfer_buffer,
+                                                   urb_out->
+                                                   transfer_buffer_length);
+                                line6_capture_check_period(line6pcm,
+                                        urb_out->transfer_buffer_length);
+                        }
+                } else {
+                        if (!(line6pcm->line6->properties->capabilities & LINE6_CAP_HWMON)
+                            && line6pcm->out.running && line6pcm->in.running)
+                                add_monitor_signal(urb_out, line6pcm->prev_fbuf,
+                                                   line6pcm->volume_monitor,
+                                                   bytes_per_frame);
+                }
+                line6pcm->prev_fbuf = NULL;
+                line6pcm->prev_fsize = 0;
+        }
+        spin_unlock(&line6pcm->in.lock);
+
+        ret = usb_submit_urb(urb_out, GFP_ATOMIC);
+
+        if (ret == 0)
+                set_bit(index, &line6pcm->out.active_urbs);
+        else
+                dev_err(line6pcm->line6->ifcdev,
+                        "URB out #%d submission failed (%d)\n", index, ret);
+
+        return 0;
+}
+
+/*
+        Submit all currently available playback URBs.
+        must be called in line6pcm->out.lock context
+ */
+int line6_submit_audio_out_all_urbs(struct snd_line6_pcm *line6pcm)
+{
+        int ret = 0, i;
+
+        for (i = 0; i < LINE6_ISO_BUFFERS; ++i) {
+                ret = submit_audio_out_urb(line6pcm);
+                if (ret < 0)
+                        break;
+        }
+
+        return ret;
+}
+
+/*
+        Callback for completed playback URB.
+*/
+static void audio_out_callback(struct urb *urb)
+{
+        int i, index, length = 0, shutdown = 0;
+        unsigned long flags;
+        struct snd_line6_pcm *line6pcm = (struct snd_line6_pcm *)urb->context;
+        struct snd_pcm_substream *substream =
+            get_substream(line6pcm, SNDRV_PCM_STREAM_PLAYBACK);
+
+#if USE_CLEAR_BUFFER_WORKAROUND
+        memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
+#endif
+
+        line6pcm->out.last_frame = urb->start_frame;
+
+        /* find index of URB */
+        for (index = 0; index < LINE6_ISO_BUFFERS; index++)
+                if (urb == line6pcm->out.urbs[index])
+                        break;
+
+        if (index >= LINE6_ISO_BUFFERS)
+                return;         /* URB has been unlinked asynchronously */
+
+        for (i = 0; i < LINE6_ISO_PACKETS; i++)
+                length += urb->iso_frame_desc[i].length;
+
+        spin_lock_irqsave(&line6pcm->out.lock, flags);
+
+        if (test_bit(LINE6_STREAM_PCM, &line6pcm->out.running)) {
+                struct snd_pcm_runtime *runtime = substream->runtime;
+
+                line6pcm->out.pos_done +=
+                    length / line6pcm->properties->bytes_per_frame;
+
+                if (line6pcm->out.pos_done >= runtime->buffer_size)
+                        line6pcm->out.pos_done -= runtime->buffer_size;
+        }
+
+        clear_bit(index, &line6pcm->out.active_urbs);
+
+        for (i = 0; i < LINE6_ISO_PACKETS; i++)
+                if (urb->iso_frame_desc[i].status == -EXDEV) {
+                        shutdown = 1;
+                        break;
+                }
+
+        if (test_and_clear_bit(index, &line6pcm->out.unlink_urbs))
+                shutdown = 1;
+
+        if (!shutdown) {
+                submit_audio_out_urb(line6pcm);
+
+                if (test_bit(LINE6_STREAM_PCM, &line6pcm->out.running)) {
+                        line6pcm->out.bytes += length;
+                        if (line6pcm->out.bytes >= line6pcm->out.period) {
+                                line6pcm->out.bytes %= line6pcm->out.period;
+                                spin_unlock(&line6pcm->out.lock);
+                                snd_pcm_period_elapsed(substream);
+                                spin_lock(&line6pcm->out.lock);
+                        }
+                }
+        }
+        spin_unlock_irqrestore(&line6pcm->out.lock, flags);
+}
+
+/* open playback callback */
+static int snd_line6_playback_open(struct snd_pcm_substream *substream)
+{
+        int err;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
+
+        err = snd_pcm_hw_constraint_ratdens(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
+                                            &line6pcm->properties->rates);
+        if (err < 0)
+                return err;
+
+        runtime->hw = line6pcm->properties->playback_hw;
+        return 0;
+}
+
+/* close playback callback */
+static int snd_line6_playback_close(struct snd_pcm_substream *substream)
+{
+        return 0;
+}
+
+/* playback operators */
+struct snd_pcm_ops snd_line6_playback_ops = {
+        .open = snd_line6_playback_open,
+        .close = snd_line6_playback_close,
+        .ioctl = snd_pcm_lib_ioctl,
+        .hw_params = snd_line6_hw_params,
+        .hw_free = snd_line6_hw_free,
+        .prepare = snd_line6_prepare,
+        .trigger = snd_line6_trigger,
+        .pointer = snd_line6_pointer,
+};
+
+int line6_create_audio_out_urbs(struct snd_line6_pcm *line6pcm)
+{
+        struct usb_line6 *line6 = line6pcm->line6;
+        int i;
+
+        /* create audio URBs and fill in constant values: */
+        for (i = 0; i < LINE6_ISO_BUFFERS; ++i) {
+                struct urb *urb;
+
+                /* URB for audio out: */
+                urb = line6pcm->out.urbs[i] =
+                    usb_alloc_urb(LINE6_ISO_PACKETS, GFP_KERNEL);
+
+                if (urb == NULL)
+                        return -ENOMEM;
+
+                urb->dev = line6->usbdev;
+                urb->pipe =
+                    usb_sndisocpipe(line6->usbdev,
+                                    line6->properties->ep_audio_w &
+                                    USB_ENDPOINT_NUMBER_MASK);
+                urb->transfer_flags = URB_ISO_ASAP;
+                urb->start_frame = -1;
+                urb->number_of_packets = LINE6_ISO_PACKETS;
+                urb->interval = LINE6_ISO_INTERVAL;
+                urb->error_count = 0;
+                urb->complete = audio_out_callback;
+        }
+
+        return 0;
+}
diff --git a/sound/usb/line6/playback.h b/sound/usb/line6/playback.h
new file mode 100644
index 000000000000..51fce29e8726
--- /dev/null
+++ b/sound/usb/line6/playback.h
@@ -0,0 +1,35 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#ifndef PLAYBACK_H
+#define PLAYBACK_H
+
+#include <sound/pcm.h>
+
+#include "driver.h"
+
+/*
+ * When the TonePort is used with jack in full duplex mode and the outputs are
+ * not connected, the software monitor produces an ugly noise since everything
+ * written to the output buffer (i.e., the input signal) will be repeated in
+ * the next period (sounds like a delay effect). As a workaround, the output
+ * buffer is cleared after the data have been read, but there must be a better
+ * solution. Until one is found, this workaround can be used to fix the
+ * problem.
+ */
+#define USE_CLEAR_BUFFER_WORKAROUND 1
+
+extern struct snd_pcm_ops snd_line6_playback_ops;
+
+extern int line6_create_audio_out_urbs(struct snd_line6_pcm *line6pcm);
+extern int line6_submit_audio_out_all_urbs(struct snd_line6_pcm *line6pcm);
+
+#endif
diff --git a/sound/usb/line6/pod.c b/sound/usb/line6/pod.c
new file mode 100644
index 000000000000..daf81d169a42
--- /dev/null
+++ b/sound/usb/line6/pod.c
@@ -0,0 +1,584 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/wait.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+
+#include <sound/core.h>
+#include <sound/control.h>
+
+#include "capture.h"
+#include "driver.h"
+#include "playback.h"
+
+/*
+        Locate name in binary program dump
+*/
+#define POD_NAME_OFFSET 0
+#define POD_NAME_LENGTH 16
+
+/*
+        Other constants
+*/
+#define POD_CONTROL_SIZE 0x80
+#define POD_BUFSIZE_DUMPREQ 7
+#define POD_STARTUP_DELAY 1000
+
+/*
+        Stages of POD startup procedure
+*/
+enum {
+        POD_STARTUP_INIT = 1,
+        POD_STARTUP_VERSIONREQ,
+        POD_STARTUP_WORKQUEUE,
+        POD_STARTUP_SETUP,
+        POD_STARTUP_LAST = POD_STARTUP_SETUP - 1
+};
+
+enum {
+        LINE6_BASSPODXT,
+        LINE6_BASSPODXTLIVE,
+        LINE6_BASSPODXTPRO,
+        LINE6_POCKETPOD,
+        LINE6_PODXT,
+        LINE6_PODXTLIVE_POD,
+        LINE6_PODXTPRO,
+};
+
+struct usb_line6_pod {
+        /* Generic Line 6 USB data */
+        struct usb_line6 line6;
+
+        /* Instrument monitor level */
+        int monitor_level;
+
+        /* Timer for device initialization */
+        struct timer_list startup_timer;
+
+        /* Work handler for device initialization */
+        struct work_struct startup_work;
+
+        /* Current progress in startup procedure */
+        int startup_progress;
+
+        /* Serial number of device */
+        u32 serial_number;
+
+        /* Firmware version (x 100) */
+        int firmware_version;
+
+        /* Device ID */
+        int device_id;
+};
+
+#define POD_SYSEX_CODE 3
+#define POD_BYTES_PER_FRAME 6   /* 24bit audio (stereo) */
+
+/* *INDENT-OFF* */
+
+enum {
+        POD_SYSEX_SAVE      = 0x24,
+        POD_SYSEX_SYSTEM    = 0x56,
+        POD_SYSEX_SYSTEMREQ = 0x57,
+        /* POD_SYSEX_UPDATE    = 0x6c, */  /* software update! */
+        POD_SYSEX_STORE     = 0x71,
+        POD_SYSEX_FINISH    = 0x72,
+        POD_SYSEX_DUMPMEM   = 0x73,
+        POD_SYSEX_DUMP      = 0x74,
+        POD_SYSEX_DUMPREQ   = 0x75
+
+        /* dumps entire internal memory of PODxt Pro */
+        /* POD_SYSEX_DUMPMEM2  = 0x76 */
+};
+
+enum {
+        POD_MONITOR_LEVEL  = 0x04,
+        POD_SYSTEM_INVALID = 0x10000
+};
+
+/* *INDENT-ON* */
+
+enum {
+        POD_DUMP_MEMORY = 2
+};
+
+enum {
+        POD_BUSY_READ,
+        POD_BUSY_WRITE,
+        POD_CHANNEL_DIRTY,
+        POD_SAVE_PRESSED,
+        POD_BUSY_MIDISEND
+};
+
+static struct snd_ratden pod_ratden = {
+        .num_min = 78125,
+        .num_max = 78125,
+        .num_step = 1,
+        .den = 2
+};
+
+static struct line6_pcm_properties pod_pcm_properties = {
+        .playback_hw = {
+                                  .info = (SNDRV_PCM_INFO_MMAP |
+                                           SNDRV_PCM_INFO_INTERLEAVED |
+                                           SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                                           SNDRV_PCM_INFO_MMAP_VALID |
+                                           SNDRV_PCM_INFO_PAUSE |
+                                           SNDRV_PCM_INFO_SYNC_START),
+                                  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
+                                  .rates = SNDRV_PCM_RATE_KNOT,
+                                  .rate_min = 39062,
+                                  .rate_max = 39063,
+                                  .channels_min = 2,
+                                  .channels_max = 2,
+                                  .buffer_bytes_max = 60000,
+                                  .period_bytes_min = 64,
+                                  .period_bytes_max = 8192,
+                                  .periods_min = 1,
+                                  .periods_max = 1024},
+        .capture_hw = {
+                                 .info = (SNDRV_PCM_INFO_MMAP |
+                                          SNDRV_PCM_INFO_INTERLEAVED |
+                                          SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                                          SNDRV_PCM_INFO_MMAP_VALID |
+                                          SNDRV_PCM_INFO_SYNC_START),
+                                 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
+                                 .rates = SNDRV_PCM_RATE_KNOT,
+                                 .rate_min = 39062,
+                                 .rate_max = 39063,
+                                 .channels_min = 2,
+                                 .channels_max = 2,
+                                 .buffer_bytes_max = 60000,
+                                 .period_bytes_min = 64,
+                                 .period_bytes_max = 8192,
+                                 .periods_min = 1,
+                                 .periods_max = 1024},
+        .rates = {
+                            .nrats = 1,
+                            .rats = &pod_ratden},
+        .bytes_per_frame = POD_BYTES_PER_FRAME
+};
+
+static const char pod_version_header[] = {
+        0xf2, 0x7e, 0x7f, 0x06, 0x02
+};
+
+/* forward declarations: */
+static void pod_startup2(unsigned long data);
+static void pod_startup3(struct usb_line6_pod *pod);
+
+static char *pod_alloc_sysex_buffer(struct usb_line6_pod *pod, int code,
+                                    int size)
+{
+        return line6_alloc_sysex_buffer(&pod->line6, POD_SYSEX_CODE, code,
+                                        size);
+}
+
+/*
+        Process a completely received message.
+*/
+static void line6_pod_process_message(struct usb_line6 *line6)
+{
+        struct usb_line6_pod *pod = (struct usb_line6_pod *) line6;
+        const unsigned char *buf = pod->line6.buffer_message;
+
+        if (memcmp(buf, pod_version_header, sizeof(pod_version_header)) == 0) {
+                pod->firmware_version = buf[13] * 100 + buf[14] * 10 + buf[15];
+                pod->device_id = ((int)buf[8] << 16) | ((int)buf[9] << 8) |
+                                 (int) buf[10];
+                pod_startup3(pod);
+                return;
+        }
+
+        /* Only look for sysex messages from this device */
+        if (buf[0] != (LINE6_SYSEX_BEGIN | LINE6_CHANNEL_DEVICE) &&
+            buf[0] != (LINE6_SYSEX_BEGIN | LINE6_CHANNEL_UNKNOWN)) {
+                return;
+        }
+        if (memcmp(buf + 1, line6_midi_id, sizeof(line6_midi_id)) != 0)
+                return;
+
+        if (buf[5] == POD_SYSEX_SYSTEM && buf[6] == POD_MONITOR_LEVEL) {
+                short value = ((int)buf[7] << 12) | ((int)buf[8] << 8) |
+                              ((int)buf[9] << 4) | (int)buf[10];
+                pod->monitor_level = value;
+        }
+}
+
+/*
+        Send system parameter (from integer).
+*/
+static int pod_set_system_param_int(struct usb_line6_pod *pod, int value,
+                                    int code)
+{
+        char *sysex;
+        static const int size = 5;
+
+        sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEM, size);
+        if (!sysex)
+                return -ENOMEM;
+        sysex[SYSEX_DATA_OFS] = code;
+        sysex[SYSEX_DATA_OFS + 1] = (value >> 12) & 0x0f;
+        sysex[SYSEX_DATA_OFS + 2] = (value >> 8) & 0x0f;
+        sysex[SYSEX_DATA_OFS + 3] = (value >> 4) & 0x0f;
+        sysex[SYSEX_DATA_OFS + 4] = (value) & 0x0f;
+        line6_send_sysex_message(&pod->line6, sysex, size);
+        kfree(sysex);
+        return 0;
+}
+
+/*
+        "read" request on "serial_number" special file.
+*/
+static ssize_t serial_number_show(struct device *dev,
+                                  struct device_attribute *attr, char *buf)
+{
+        struct usb_interface *interface = to_usb_interface(dev);
+        struct usb_line6_pod *pod = usb_get_intfdata(interface);
+
+        return sprintf(buf, "%u\n", pod->serial_number);
+}
+
+/*
+        "read" request on "firmware_version" special file.
+*/
+static ssize_t firmware_version_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct usb_interface *interface = to_usb_interface(dev);
+        struct usb_line6_pod *pod = usb_get_intfdata(interface);
+
+        return sprintf(buf, "%d.%02d\n", pod->firmware_version / 100,
+                       pod->firmware_version % 100);
+}
+
+/*
+        "read" request on "device_id" special file.
+*/
+static ssize_t device_id_show(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct usb_interface *interface = to_usb_interface(dev);
+        struct usb_line6_pod *pod = usb_get_intfdata(interface);
+
+        return sprintf(buf, "%d\n", pod->device_id);
+}
+
+/*
+        POD startup procedure.
+        This is a sequence of functions with special requirements (e.g., must
+        not run immediately after initialization, must not run in interrupt
+        context). After the last one has finished, the device is ready to use.
+*/
+
+static void pod_startup1(struct usb_line6_pod *pod)
+{
+        CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_INIT);
+
+        /* delay startup procedure: */
+        line6_start_timer(&pod->startup_timer, POD_STARTUP_DELAY, pod_startup2,
+                          (unsigned long)pod);
+}
+
+static void pod_startup2(unsigned long data)
+{
+        struct usb_line6_pod *pod = (struct usb_line6_pod *)data;
+        struct usb_line6 *line6 = &pod->line6;
+
+        CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_VERSIONREQ);
+
+        /* request firmware version: */
+        line6_version_request_async(line6);
+}
+
+static void pod_startup3(struct usb_line6_pod *pod)
+{
+        CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_WORKQUEUE);
+
+        /* schedule work for global work queue: */
+        schedule_work(&pod->startup_work);
+}
+
+static void pod_startup4(struct work_struct *work)
+{
+        struct usb_line6_pod *pod =
+            container_of(work, struct usb_line6_pod, startup_work);
+        struct usb_line6 *line6 = &pod->line6;
+
+        CHECK_STARTUP_PROGRESS(pod->startup_progress, POD_STARTUP_SETUP);
+
+        /* serial number: */
+        line6_read_serial_number(&pod->line6, &pod->serial_number);
+
+        /* ALSA audio interface: */
+        snd_card_register(line6->card);
+}
+
+/* POD special files: */
+static DEVICE_ATTR_RO(device_id);
+static DEVICE_ATTR_RO(firmware_version);
+static DEVICE_ATTR_RO(serial_number);
+
+static struct attribute *pod_dev_attrs[] = {
+        &dev_attr_device_id.attr,
+        &dev_attr_firmware_version.attr,
+        &dev_attr_serial_number.attr,
+        NULL
+};
+
+static const struct attribute_group pod_dev_attr_group = {
+        .name = "pod",
+        .attrs = pod_dev_attrs,
+};
+
+/* control info callback */
+static int snd_pod_control_monitor_info(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 65535;
+        return 0;
+}
+
+/* control get callback */
+static int snd_pod_control_monitor_get(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+        struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6;
+
+        ucontrol->value.integer.value[0] = pod->monitor_level;
+        return 0;
+}
+
+/* control put callback */
+static int snd_pod_control_monitor_put(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+        struct usb_line6_pod *pod = (struct usb_line6_pod *)line6pcm->line6;
+
+        if (ucontrol->value.integer.value[0] == pod->monitor_level)
+                return 0;
+
+        pod->monitor_level = ucontrol->value.integer.value[0];
+        pod_set_system_param_int(pod, ucontrol->value.integer.value[0],
+                                 POD_MONITOR_LEVEL);
+        return 1;
+}
+
+/* control definition */
+static struct snd_kcontrol_new pod_control_monitor = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Monitor Playback Volume",
+        .index = 0,
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = snd_pod_control_monitor_info,
+        .get = snd_pod_control_monitor_get,
+        .put = snd_pod_control_monitor_put
+};
+
+/*
+        POD device disconnected.
+*/
+static void line6_pod_disconnect(struct usb_line6 *line6)
+{
+        struct usb_line6_pod *pod = (struct usb_line6_pod *)line6;
+
+        del_timer_sync(&pod->startup_timer);
+        cancel_work_sync(&pod->startup_work);
+}
+
+/*
+         Try to init POD device.
+*/
+static int pod_init(struct usb_line6 *line6,
+                    const struct usb_device_id *id)
+{
+        int err;
+        struct usb_line6_pod *pod = (struct usb_line6_pod *) line6;
+
+        line6->process_message = line6_pod_process_message;
+        line6->disconnect = line6_pod_disconnect;
+
+        init_timer(&pod->startup_timer);
+        INIT_WORK(&pod->startup_work, pod_startup4);
+
+        /* create sysfs entries: */
+        err = snd_card_add_dev_attr(line6->card, &pod_dev_attr_group);
+        if (err < 0)
+                return err;
+
+        /* initialize MIDI subsystem: */
+        err = line6_init_midi(line6);
+        if (err < 0)
+                return err;
+
+        /* initialize PCM subsystem: */
+        err = line6_init_pcm(line6, &pod_pcm_properties);
+        if (err < 0)
+                return err;
+
+        /* register monitor control: */
+        err = snd_ctl_add(line6->card,
+                          snd_ctl_new1(&pod_control_monitor, line6->line6pcm));
+        if (err < 0)
+                return err;
+
+        /*
+           When the sound card is registered at this point, the PODxt Live
+           displays "Invalid Code Error 07", so we do it later in the event
+           handler.
+         */
+
+        if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) {
+                pod->monitor_level = POD_SYSTEM_INVALID;
+
+                /* initiate startup procedure: */
+                pod_startup1(pod);
+        }
+
+        return 0;
+}
+
+#define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod)
+#define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n)
+
+/* table of devices that work with this driver */
+static const struct usb_device_id pod_id_table[] = {
+        { LINE6_DEVICE(0x4250),    .driver_info = LINE6_BASSPODXT },
+        { LINE6_DEVICE(0x4642),    .driver_info = LINE6_BASSPODXTLIVE },
+        { LINE6_DEVICE(0x4252),    .driver_info = LINE6_BASSPODXTPRO },
+        { LINE6_IF_NUM(0x5051, 1), .driver_info = LINE6_POCKETPOD },
+        { LINE6_DEVICE(0x5044),    .driver_info = LINE6_PODXT },
+        { LINE6_IF_NUM(0x4650, 0), .driver_info = LINE6_PODXTLIVE_POD },
+        { LINE6_DEVICE(0x5050),    .driver_info = LINE6_PODXTPRO },
+        {}
+};
+
+MODULE_DEVICE_TABLE(usb, pod_id_table);
+
+static const struct line6_properties pod_properties_table[] = {
+        [LINE6_BASSPODXT] = {
+                .id = "BassPODxt",
+                .name = "BassPODxt",
+                .capabilities   = LINE6_CAP_CONTROL
+                                | LINE6_CAP_PCM
+                                | LINE6_CAP_HWMON,
+                .altsetting = 5,
+                .ep_ctrl_r = 0x84,
+                .ep_ctrl_w = 0x03,
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_BASSPODXTLIVE] = {
+                .id = "BassPODxtLive",
+                .name = "BassPODxt Live",
+                .capabilities   = LINE6_CAP_CONTROL
+                                | LINE6_CAP_PCM
+                                | LINE6_CAP_HWMON,
+                .altsetting = 1,
+                .ep_ctrl_r = 0x84,
+                .ep_ctrl_w = 0x03,
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_BASSPODXTPRO] = {
+                .id = "BassPODxtPro",
+                .name = "BassPODxt Pro",
+                .capabilities   = LINE6_CAP_CONTROL
+                                | LINE6_CAP_PCM
+                                | LINE6_CAP_HWMON,
+                .altsetting = 5,
+                .ep_ctrl_r = 0x84,
+                .ep_ctrl_w = 0x03,
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_POCKETPOD] = {
+                .id = "PocketPOD",
+                .name = "Pocket POD",
+                .capabilities   = LINE6_CAP_CONTROL,
+                .altsetting = 0,
+                .ep_ctrl_r = 0x82,
+                .ep_ctrl_w = 0x02,
+                /* no audio channel */
+        },
+        [LINE6_PODXT] = {
+                .id = "PODxt",
+                .name = "PODxt",
+                .capabilities   = LINE6_CAP_CONTROL
+                                | LINE6_CAP_PCM
+                                | LINE6_CAP_HWMON,
+                .altsetting = 5,
+                .ep_ctrl_r = 0x84,
+                .ep_ctrl_w = 0x03,
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_PODXTLIVE_POD] = {
+                .id = "PODxtLive",
+                .name = "PODxt Live",
+                .capabilities   = LINE6_CAP_CONTROL
+                                | LINE6_CAP_PCM
+                                | LINE6_CAP_HWMON,
+                .altsetting = 1,
+                .ep_ctrl_r = 0x84,
+                .ep_ctrl_w = 0x03,
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_PODXTPRO] = {
+                .id = "PODxtPro",
+                .name = "PODxt Pro",
+                .capabilities   = LINE6_CAP_CONTROL
+                                | LINE6_CAP_PCM
+                                | LINE6_CAP_HWMON,
+                .altsetting = 5,
+                .ep_ctrl_r = 0x84,
+                .ep_ctrl_w = 0x03,
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+};
+
+/*
+        Probe USB device.
+*/
+static int pod_probe(struct usb_interface *interface,
+                     const struct usb_device_id *id)
+{
+        return line6_probe(interface, id, "Line6-POD",
+                           &pod_properties_table[id->driver_info],
+                           pod_init, sizeof(struct usb_line6_pod));
+}
+
+static struct usb_driver pod_driver = {
+        .name = KBUILD_MODNAME,
+        .probe = pod_probe,
+        .disconnect = line6_disconnect,
+#ifdef CONFIG_PM
+        .suspend = line6_suspend,
+        .resume = line6_resume,
+        .reset_resume = line6_resume,
+#endif
+        .id_table = pod_id_table,
+};
+
+module_usb_driver(pod_driver);
+
+MODULE_DESCRIPTION("Line 6 POD USB driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/usb/line6/podhd.c b/sound/usb/line6/podhd.c
new file mode 100644
index 000000000000..63dcaef41ac3
--- /dev/null
+++ b/sound/usb/line6/podhd.c
@@ -0,0 +1,192 @@
+/*
+ * Line 6 Pod HD
+ *
+ * Copyright (C) 2011 Stefan Hajnoczi <stefanha@gmail.com>
+ *
+ *      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, version 2.
+ *
+ */
+
+#include <linux/usb.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+
+#include "driver.h"
+#include "pcm.h"
+
+enum {
+        LINE6_PODHD300,
+        LINE6_PODHD400,
+        LINE6_PODHD500_0,
+        LINE6_PODHD500_1,
+};
+
+#define PODHD_BYTES_PER_FRAME 6 /* 24bit audio (stereo) */
+
+static struct snd_ratden podhd_ratden = {
+        .num_min = 48000,
+        .num_max = 48000,
+        .num_step = 1,
+        .den = 1,
+};
+
+static struct line6_pcm_properties podhd_pcm_properties = {
+        .playback_hw = {
+                                  .info = (SNDRV_PCM_INFO_MMAP |
+                                           SNDRV_PCM_INFO_INTERLEAVED |
+                                           SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                                           SNDRV_PCM_INFO_MMAP_VALID |
+                                           SNDRV_PCM_INFO_PAUSE |
+                                           SNDRV_PCM_INFO_SYNC_START),
+                                  .formats = SNDRV_PCM_FMTBIT_S24_3LE,
+                                  .rates = SNDRV_PCM_RATE_48000,
+                                  .rate_min = 48000,
+                                  .rate_max = 48000,
+                                  .channels_min = 2,
+                                  .channels_max = 2,
+                                  .buffer_bytes_max = 60000,
+                                  .period_bytes_min = 64,
+                                  .period_bytes_max = 8192,
+                                  .periods_min = 1,
+                                  .periods_max = 1024},
+        .capture_hw = {
+                                 .info = (SNDRV_PCM_INFO_MMAP |
+                                          SNDRV_PCM_INFO_INTERLEAVED |
+                                          SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                                          SNDRV_PCM_INFO_MMAP_VALID |
+                                          SNDRV_PCM_INFO_SYNC_START),
+                                 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
+                                 .rates = SNDRV_PCM_RATE_48000,
+                                 .rate_min = 48000,
+                                 .rate_max = 48000,
+                                 .channels_min = 2,
+                                 .channels_max = 2,
+                                 .buffer_bytes_max = 60000,
+                                 .period_bytes_min = 64,
+                                 .period_bytes_max = 8192,
+                                 .periods_min = 1,
+                                 .periods_max = 1024},
+        .rates = {
+                            .nrats = 1,
+                            .rats = &podhd_ratden},
+        .bytes_per_frame = PODHD_BYTES_PER_FRAME
+};
+
+/*
+        Try to init POD HD device.
+*/
+static int podhd_init(struct usb_line6 *line6,
+                      const struct usb_device_id *id)
+{
+        int err;
+
+        /* initialize MIDI subsystem: */
+        err = line6_init_midi(line6);
+        if (err < 0)
+                return err;
+
+        /* initialize PCM subsystem: */
+        err = line6_init_pcm(line6, &podhd_pcm_properties);
+        if (err < 0)
+                return err;
+
+        /* register USB audio system: */
+        return snd_card_register(line6->card);
+}
+
+#define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod)
+#define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n)
+
+/* table of devices that work with this driver */
+static const struct usb_device_id podhd_id_table[] = {
+        { LINE6_DEVICE(0x5057),    .driver_info = LINE6_PODHD300 },
+        { LINE6_DEVICE(0x5058),    .driver_info = LINE6_PODHD400 },
+        { LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500_0 },
+        { LINE6_IF_NUM(0x414D, 1), .driver_info = LINE6_PODHD500_1 },
+        {}
+};
+
+MODULE_DEVICE_TABLE(usb, podhd_id_table);
+
+static const struct line6_properties podhd_properties_table[] = {
+        [LINE6_PODHD300] = {
+                .id = "PODHD300",
+                .name = "POD HD300",
+                .capabilities   = LINE6_CAP_CONTROL
+                                | LINE6_CAP_PCM
+                                | LINE6_CAP_HWMON,
+                .altsetting = 5,
+                .ep_ctrl_r = 0x84,
+                .ep_ctrl_w = 0x03,
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_PODHD400] = {
+                .id = "PODHD400",
+                .name = "POD HD400",
+                .capabilities   = LINE6_CAP_CONTROL
+                                | LINE6_CAP_PCM
+                                | LINE6_CAP_HWMON,
+                .altsetting = 5,
+                .ep_ctrl_r = 0x84,
+                .ep_ctrl_w = 0x03,
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_PODHD500_0] = {
+                .id = "PODHD500",
+                .name = "POD HD500",
+                .capabilities   = LINE6_CAP_CONTROL
+                                | LINE6_CAP_PCM
+                                | LINE6_CAP_HWMON,
+                .altsetting = 1,
+                .ep_ctrl_r = 0x81,
+                .ep_ctrl_w = 0x01,
+                .ep_audio_r = 0x86,
+                .ep_audio_w = 0x02,
+        },
+        [LINE6_PODHD500_1] = {
+                .id = "PODHD500",
+                .name = "POD HD500",
+                .capabilities   = LINE6_CAP_CONTROL
+                                | LINE6_CAP_PCM
+                                | LINE6_CAP_HWMON,
+                .altsetting = 1,
+                .ep_ctrl_r = 0x81,
+                .ep_ctrl_w = 0x01,
+                .ep_audio_r = 0x86,
+                .ep_audio_w = 0x02,
+        },
+};
+
+/*
+        Probe USB device.
+*/
+static int podhd_probe(struct usb_interface *interface,
+                       const struct usb_device_id *id)
+{
+        return line6_probe(interface, id, "Line6-PODHD",
+                           &podhd_properties_table[id->driver_info],
+                           podhd_init, sizeof(struct usb_line6));
+}
+
+static struct usb_driver podhd_driver = {
+        .name = KBUILD_MODNAME,
+        .probe = podhd_probe,
+        .disconnect = line6_disconnect,
+#ifdef CONFIG_PM
+        .suspend = line6_suspend,
+        .resume = line6_resume,
+        .reset_resume = line6_resume,
+#endif
+        .id_table = podhd_id_table,
+};
+
+module_usb_driver(podhd_driver);
+
+MODULE_DESCRIPTION("Line 6 PODHD USB driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/usb/line6/toneport.c b/sound/usb/line6/toneport.c
new file mode 100644
index 000000000000..6d4c50c9b17d
--- /dev/null
+++ b/sound/usb/line6/toneport.c
@@ -0,0 +1,580 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *                         Emil Myhrman (emil.myhrman@gmail.com)
+ *
+ *      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, version 2.
+ *
+ */
+
+#include <linux/wait.h>
+#include <linux/usb.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/leds.h>
+#include <sound/core.h>
+#include <sound/control.h>
+
+#include "capture.h"
+#include "driver.h"
+#include "playback.h"
+
+enum line6_device_type {
+        LINE6_GUITARPORT,
+        LINE6_PODSTUDIO_GX,
+        LINE6_PODSTUDIO_UX1,
+        LINE6_PODSTUDIO_UX2,
+        LINE6_TONEPORT_GX,
+        LINE6_TONEPORT_UX1,
+        LINE6_TONEPORT_UX2,
+};
+
+struct usb_line6_toneport;
+
+struct toneport_led {
+        struct led_classdev dev;
+        char name[64];
+        struct usb_line6_toneport *toneport;
+        bool registered;
+};
+
+struct usb_line6_toneport {
+        /* Generic Line 6 USB data */
+        struct usb_line6 line6;
+
+        /* Source selector */
+        int source;
+
+        /* Serial number of device */
+        u32 serial_number;
+
+        /* Firmware version (x 100) */
+        u8 firmware_version;
+
+        /* Timer for delayed PCM startup */
+        struct timer_list timer;
+
+        /* Device type */
+        enum line6_device_type type;
+
+        /* LED instances */
+        struct toneport_led leds[2];
+};
+
+static int toneport_send_cmd(struct usb_device *usbdev, int cmd1, int cmd2);
+
+#define TONEPORT_PCM_DELAY 1
+
+static struct snd_ratden toneport_ratden = {
+        .num_min = 44100,
+        .num_max = 44100,
+        .num_step = 1,
+        .den = 1
+};
+
+static struct line6_pcm_properties toneport_pcm_properties = {
+        .playback_hw = {
+                                  .info = (SNDRV_PCM_INFO_MMAP |
+                                           SNDRV_PCM_INFO_INTERLEAVED |
+                                           SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                                           SNDRV_PCM_INFO_MMAP_VALID |
+                                           SNDRV_PCM_INFO_PAUSE |
+                                           SNDRV_PCM_INFO_SYNC_START),
+                                  .formats = SNDRV_PCM_FMTBIT_S16_LE,
+                                  .rates = SNDRV_PCM_RATE_KNOT,
+                                  .rate_min = 44100,
+                                  .rate_max = 44100,
+                                  .channels_min = 2,
+                                  .channels_max = 2,
+                                  .buffer_bytes_max = 60000,
+                                  .period_bytes_min = 64,
+                                  .period_bytes_max = 8192,
+                                  .periods_min = 1,
+                                  .periods_max = 1024},
+        .capture_hw = {
+                                 .info = (SNDRV_PCM_INFO_MMAP |
+                                          SNDRV_PCM_INFO_INTERLEAVED |
+                                          SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                                          SNDRV_PCM_INFO_MMAP_VALID |
+                                          SNDRV_PCM_INFO_SYNC_START),
+                                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
+                                 .rates = SNDRV_PCM_RATE_KNOT,
+                                 .rate_min = 44100,
+                                 .rate_max = 44100,
+                                 .channels_min = 2,
+                                 .channels_max = 2,
+                                 .buffer_bytes_max = 60000,
+                                 .period_bytes_min = 64,
+                                 .period_bytes_max = 8192,
+                                 .periods_min = 1,
+                                 .periods_max = 1024},
+        .rates = {
+                            .nrats = 1,
+                            .rats = &toneport_ratden},
+        .bytes_per_frame = 4
+};
+
+static const struct {
+        const char *name;
+        int code;
+} toneport_source_info[] = {
+        {"Microphone", 0x0a01},
+        {"Line", 0x0801},
+        {"Instrument", 0x0b01},
+        {"Inst & Mic", 0x0901}
+};
+
+static int toneport_send_cmd(struct usb_device *usbdev, int cmd1, int cmd2)
+{
+        int ret;
+
+        ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x67,
+                              USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
+                              cmd1, cmd2, NULL, 0, LINE6_TIMEOUT * HZ);
+
+        if (ret < 0) {
+                dev_err(&usbdev->dev, "send failed (error %d)\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+/* monitor info callback */
+static int snd_toneport_monitor_info(struct snd_kcontrol *kcontrol,
+                                     struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 256;
+        return 0;
+}
+
+/* monitor get callback */
+static int snd_toneport_monitor_get(struct snd_kcontrol *kcontrol,
+                                    struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.integer.value[0] = line6pcm->volume_monitor;
+        return 0;
+}
+
+/* monitor put callback */
+static int snd_toneport_monitor_put(struct snd_kcontrol *kcontrol,
+                                    struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+        int err;
+
+        if (ucontrol->value.integer.value[0] == line6pcm->volume_monitor)
+                return 0;
+
+        line6pcm->volume_monitor = ucontrol->value.integer.value[0];
+
+        if (line6pcm->volume_monitor > 0) {
+                err = line6_pcm_acquire(line6pcm, LINE6_STREAM_MONITOR);
+                if (err < 0) {
+                        line6pcm->volume_monitor = 0;
+                        line6_pcm_release(line6pcm, LINE6_STREAM_MONITOR);
+                        return err;
+                }
+        } else {
+                line6_pcm_release(line6pcm, LINE6_STREAM_MONITOR);
+        }
+
+        return 1;
+}
+
+/* source info callback */
+static int snd_toneport_source_info(struct snd_kcontrol *kcontrol,
+                                    struct snd_ctl_elem_info *uinfo)
+{
+        const int size = ARRAY_SIZE(toneport_source_info);
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = size;
+
+        if (uinfo->value.enumerated.item >= size)
+                uinfo->value.enumerated.item = size - 1;
+
+        strcpy(uinfo->value.enumerated.name,
+               toneport_source_info[uinfo->value.enumerated.item].name);
+
+        return 0;
+}
+
+/* source get callback */
+static int snd_toneport_source_get(struct snd_kcontrol *kcontrol,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+        struct usb_line6_toneport *toneport =
+            (struct usb_line6_toneport *)line6pcm->line6;
+        ucontrol->value.enumerated.item[0] = toneport->source;
+        return 0;
+}
+
+/* source put callback */
+static int snd_toneport_source_put(struct snd_kcontrol *kcontrol,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
+        struct usb_line6_toneport *toneport =
+            (struct usb_line6_toneport *)line6pcm->line6;
+        unsigned int source;
+
+        source = ucontrol->value.enumerated.item[0];
+        if (source >= ARRAY_SIZE(toneport_source_info))
+                return -EINVAL;
+        if (source == toneport->source)
+                return 0;
+
+        toneport->source = source;
+        toneport_send_cmd(toneport->line6.usbdev,
+                          toneport_source_info[source].code, 0x0000);
+        return 1;
+}
+
+static void toneport_start_pcm(unsigned long arg)
+{
+        struct usb_line6_toneport *toneport = (struct usb_line6_toneport *)arg;
+        struct usb_line6 *line6 = &toneport->line6;
+
+        line6_pcm_acquire(line6->line6pcm, LINE6_STREAM_MONITOR);
+}
+
+/* control definition */
+static struct snd_kcontrol_new toneport_control_monitor = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Monitor Playback Volume",
+        .index = 0,
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = snd_toneport_monitor_info,
+        .get = snd_toneport_monitor_get,
+        .put = snd_toneport_monitor_put
+};
+
+/* source selector definition */
+static struct snd_kcontrol_new toneport_control_source = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "PCM Capture Source",
+        .index = 0,
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = snd_toneport_source_info,
+        .get = snd_toneport_source_get,
+        .put = snd_toneport_source_put
+};
+
+/*
+        For the led on Guitarport.
+        Brightness goes from 0x00 to 0x26. Set a value above this to have led
+        blink.
+        (void cmd_0x02(byte red, byte green)
+*/
+
+static bool toneport_has_led(struct usb_line6_toneport *toneport)
+{
+        switch (toneport->type) {
+        case LINE6_GUITARPORT:
+        case LINE6_TONEPORT_GX:
+        /* add your device here if you are missing support for the LEDs */
+                return true;
+
+        default:
+                return false;
+        }
+}
+
+static const char * const led_colors[2] = { "red", "green" };
+static const int led_init_vals[2] = { 0x00, 0x26 };
+
+static void toneport_update_led(struct usb_line6_toneport *toneport)
+{
+        toneport_send_cmd(toneport->line6.usbdev,
+                          (toneport->leds[0].dev.brightness << 8) | 0x0002,
+                          toneport->leds[1].dev.brightness);
+}
+
+static void toneport_led_brightness_set(struct led_classdev *led_cdev,
+                                        enum led_brightness brightness)
+{
+        struct toneport_led *leds =
+                container_of(led_cdev, struct toneport_led, dev);
+        toneport_update_led(leds->toneport);
+}
+
+static int toneport_init_leds(struct usb_line6_toneport *toneport)
+{
+        struct device *dev = &toneport->line6.usbdev->dev;
+        int i, err;
+
+        for (i = 0; i < 2; i++) {
+                struct toneport_led *led = &toneport->leds[i];
+                struct led_classdev *leddev = &led->dev;
+
+                led->toneport = toneport;
+                snprintf(led->name, sizeof(led->name), "%s::%s",
+                         dev_name(dev), led_colors[i]);
+                leddev->name = led->name;
+                leddev->brightness = led_init_vals[i];
+                leddev->max_brightness = 0x26;
+                leddev->brightness_set = toneport_led_brightness_set;
+                err = led_classdev_register(dev, leddev);
+                if (err)
+                        return err;
+                led->registered = true;
+        }
+
+        return 0;
+}
+
+static void toneport_remove_leds(struct usb_line6_toneport *toneport)
+{
+        struct toneport_led *led;
+        int i;
+
+        for (i = 0; i < 2; i++) {
+                led = &toneport->leds[i];
+                if (!led->registered)
+                        break;
+                led_classdev_unregister(&led->dev);
+                led->registered = false;
+        }
+}
+
+static bool toneport_has_source_select(struct usb_line6_toneport *toneport)
+{
+        switch (toneport->type) {
+        case LINE6_TONEPORT_UX1:
+        case LINE6_TONEPORT_UX2:
+        case LINE6_PODSTUDIO_UX1:
+        case LINE6_PODSTUDIO_UX2:
+                return true;
+
+        default:
+                return false;
+        }
+}
+
+/*
+        Setup Toneport device.
+*/
+static void toneport_setup(struct usb_line6_toneport *toneport)
+{
+        int ticks;
+        struct usb_line6 *line6 = &toneport->line6;
+        struct usb_device *usbdev = line6->usbdev;
+
+        /* sync time on device with host: */
+        ticks = (int)get_seconds();
+        line6_write_data(line6, 0x80c6, &ticks, 4);
+
+        /* enable device: */
+        toneport_send_cmd(usbdev, 0x0301, 0x0000);
+
+        /* initialize source select: */
+        if (toneport_has_source_select(toneport))
+                toneport_send_cmd(usbdev,
+                                  toneport_source_info[toneport->source].code,
+                                  0x0000);
+
+        if (toneport_has_led(toneport))
+                toneport_update_led(toneport);
+
+        mod_timer(&toneport->timer, jiffies + TONEPORT_PCM_DELAY * HZ);
+}
+
+/*
+        Toneport device disconnected.
+*/
+static void line6_toneport_disconnect(struct usb_line6 *line6)
+{
+        struct usb_line6_toneport *toneport =
+                (struct usb_line6_toneport *)line6;
+
+        del_timer_sync(&toneport->timer);
+
+        if (toneport_has_led(toneport))
+                toneport_remove_leds(toneport);
+}
+
+
+/*
+         Try to init Toneport device.
+*/
+static int toneport_init(struct usb_line6 *line6,
+                         const struct usb_device_id *id)
+{
+        int err;
+        struct usb_line6_toneport *toneport =  (struct usb_line6_toneport *) line6;
+
+        toneport->type = id->driver_info;
+        setup_timer(&toneport->timer, toneport_start_pcm,
+                    (unsigned long)toneport);
+
+        line6->disconnect = line6_toneport_disconnect;
+
+        /* initialize PCM subsystem: */
+        err = line6_init_pcm(line6, &toneport_pcm_properties);
+        if (err < 0)
+                return err;
+
+        /* register monitor control: */
+        err = snd_ctl_add(line6->card,
+                          snd_ctl_new1(&toneport_control_monitor,
+                                       line6->line6pcm));
+        if (err < 0)
+                return err;
+
+        /* register source select control: */
+        if (toneport_has_source_select(toneport)) {
+                err =
+                    snd_ctl_add(line6->card,
+                                snd_ctl_new1(&toneport_control_source,
+                                             line6->line6pcm));
+                if (err < 0)
+                        return err;
+        }
+
+        line6_read_serial_number(line6, &toneport->serial_number);
+        line6_read_data(line6, 0x80c2, &toneport->firmware_version, 1);
+
+        if (toneport_has_led(toneport)) {
+                err = toneport_init_leds(toneport);
+                if (err < 0)
+                        return err;
+        }
+
+        toneport_setup(toneport);
+
+        /* register audio system: */
+        return snd_card_register(line6->card);
+}
+
+#ifdef CONFIG_PM
+/*
+        Resume Toneport device after reset.
+*/
+static int toneport_reset_resume(struct usb_interface *interface)
+{
+        toneport_setup(usb_get_intfdata(interface));
+        return line6_resume(interface);
+}
+#endif
+
+#define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod)
+#define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n)
+
+/* table of devices that work with this driver */
+static const struct usb_device_id toneport_id_table[] = {
+        { LINE6_DEVICE(0x4750),    .driver_info = LINE6_GUITARPORT },
+        { LINE6_DEVICE(0x4153),    .driver_info = LINE6_PODSTUDIO_GX },
+        { LINE6_DEVICE(0x4150),    .driver_info = LINE6_PODSTUDIO_UX1 },
+        { LINE6_IF_NUM(0x4151, 0), .driver_info = LINE6_PODSTUDIO_UX2 },
+        { LINE6_DEVICE(0x4147),    .driver_info = LINE6_TONEPORT_GX },
+        { LINE6_DEVICE(0x4141),    .driver_info = LINE6_TONEPORT_UX1 },
+        { LINE6_IF_NUM(0x4142, 0), .driver_info = LINE6_TONEPORT_UX2 },
+        {}
+};
+
+MODULE_DEVICE_TABLE(usb, toneport_id_table);
+
+static const struct line6_properties toneport_properties_table[] = {
+        [LINE6_GUITARPORT] = {
+                .id = "GuitarPort",
+                .name = "GuitarPort",
+                .capabilities   = LINE6_CAP_PCM,
+                .altsetting = 2,  /* 1..4 seem to be ok */
+                /* no control channel */
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_PODSTUDIO_GX] = {
+                .id = "PODStudioGX",
+                .name = "POD Studio GX",
+                .capabilities   = LINE6_CAP_PCM,
+                .altsetting = 2,  /* 1..4 seem to be ok */
+                /* no control channel */
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_PODSTUDIO_UX1] = {
+                .id = "PODStudioUX1",
+                .name = "POD Studio UX1",
+                .capabilities   = LINE6_CAP_PCM,
+                .altsetting = 2,  /* 1..4 seem to be ok */
+                /* no control channel */
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_PODSTUDIO_UX2] = {
+                .id = "PODStudioUX2",
+                .name = "POD Studio UX2",
+                .capabilities   = LINE6_CAP_PCM,
+                .altsetting = 2,  /* defaults to 44.1kHz, 16-bit */
+                /* no control channel */
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_TONEPORT_GX] = {
+                .id = "TonePortGX",
+                .name = "TonePort GX",
+                .capabilities   = LINE6_CAP_PCM,
+                .altsetting = 2,  /* 1..4 seem to be ok */
+                /* no control channel */
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_TONEPORT_UX1] = {
+                .id = "TonePortUX1",
+                .name = "TonePort UX1",
+                .capabilities   = LINE6_CAP_PCM,
+                .altsetting = 2,  /* 1..4 seem to be ok */
+                /* no control channel */
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_TONEPORT_UX2] = {
+                .id = "TonePortUX2",
+                .name = "TonePort UX2",
+                .capabilities   = LINE6_CAP_PCM,
+                .altsetting = 2,  /* defaults to 44.1kHz, 16-bit */
+                /* no control channel */
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+};
+
+/*
+        Probe USB device.
+*/
+static int toneport_probe(struct usb_interface *interface,
+                          const struct usb_device_id *id)
+{
+        return line6_probe(interface, id, "Line6-TonePort",
+                           &toneport_properties_table[id->driver_info],
+                           toneport_init, sizeof(struct usb_line6_toneport));
+}
+
+static struct usb_driver toneport_driver = {
+        .name = KBUILD_MODNAME,
+        .probe = toneport_probe,
+        .disconnect = line6_disconnect,
+#ifdef CONFIG_PM
+        .suspend = line6_suspend,
+        .resume = line6_resume,
+        .reset_resume = toneport_reset_resume,
+#endif
+        .id_table = toneport_id_table,
+};
+
+module_usb_driver(toneport_driver);
+
+MODULE_DESCRIPTION("TonePort USB driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/usb/line6/variax.c b/sound/usb/line6/variax.c
new file mode 100644
index 000000000000..ddc23ddf0750
--- /dev/null
+++ b/sound/usb/line6/variax.c
@@ -0,0 +1,306 @@
+/*
+ * Line 6 Linux USB driver
+ *
+ * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
+ *
+ *      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, version 2.
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/usb.h>
+#include <linux/wait.h>
+#include <linux/module.h>
+#include <sound/core.h>
+
+#include "driver.h"
+
+#define VARIAX_STARTUP_DELAY1 1000
+#define VARIAX_STARTUP_DELAY3 100
+#define VARIAX_STARTUP_DELAY4 100
+
+/*
+        Stages of Variax startup procedure
+*/
+enum {
+        VARIAX_STARTUP_INIT = 1,
+        VARIAX_STARTUP_VERSIONREQ,
+        VARIAX_STARTUP_WAIT,
+        VARIAX_STARTUP_ACTIVATE,
+        VARIAX_STARTUP_WORKQUEUE,
+        VARIAX_STARTUP_SETUP,
+        VARIAX_STARTUP_LAST = VARIAX_STARTUP_SETUP - 1
+};
+
+enum {
+        LINE6_PODXTLIVE_VARIAX,
+        LINE6_VARIAX
+};
+
+struct usb_line6_variax {
+        /* Generic Line 6 USB data */
+        struct usb_line6 line6;
+
+        /* Buffer for activation code */
+        unsigned char *buffer_activate;
+
+        /* Handler for device initialization */
+        struct work_struct startup_work;
+
+        /* Timers for device initialization */
+        struct timer_list startup_timer1;
+        struct timer_list startup_timer2;
+
+        /* Current progress in startup procedure */
+        int startup_progress;
+};
+
+#define VARIAX_OFFSET_ACTIVATE 7
+
+/*
+        This message is sent by the device during initialization and identifies
+        the connected guitar version.
+*/
+static const char variax_init_version[] = {
+        0xf0, 0x7e, 0x7f, 0x06, 0x02, 0x00, 0x01, 0x0c,
+        0x07, 0x00, 0x00, 0x00
+};
+
+/*
+        This message is the last one sent by the device during initialization.
+*/
+static const char variax_init_done[] = {
+        0xf0, 0x00, 0x01, 0x0c, 0x07, 0x00, 0x6b
+};
+
+static const char variax_activate[] = {
+        0xf0, 0x00, 0x01, 0x0c, 0x07, 0x00, 0x2a, 0x01,
+        0xf7
+};
+
+/* forward declarations: */
+static void variax_startup2(unsigned long data);
+static void variax_startup4(unsigned long data);
+static void variax_startup5(unsigned long data);
+
+static void variax_activate_async(struct usb_line6_variax *variax, int a)
+{
+        variax->buffer_activate[VARIAX_OFFSET_ACTIVATE] = a;
+        line6_send_raw_message_async(&variax->line6, variax->buffer_activate,
+                                     sizeof(variax_activate));
+}
+
+/*
+        Variax startup procedure.
+        This is a sequence of functions with special requirements (e.g., must
+        not run immediately after initialization, must not run in interrupt
+        context). After the last one has finished, the device is ready to use.
+*/
+
+static void variax_startup1(struct usb_line6_variax *variax)
+{
+        CHECK_STARTUP_PROGRESS(variax->startup_progress, VARIAX_STARTUP_INIT);
+
+        /* delay startup procedure: */
+        line6_start_timer(&variax->startup_timer1, VARIAX_STARTUP_DELAY1,
+                          variax_startup2, (unsigned long)variax);
+}
+
+static void variax_startup2(unsigned long data)
+{
+        struct usb_line6_variax *variax = (struct usb_line6_variax *)data;
+        struct usb_line6 *line6 = &variax->line6;
+
+        /* schedule another startup procedure until startup is complete: */
+        if (variax->startup_progress >= VARIAX_STARTUP_LAST)
+                return;
+
+        variax->startup_progress = VARIAX_STARTUP_VERSIONREQ;
+        line6_start_timer(&variax->startup_timer1, VARIAX_STARTUP_DELAY1,
+                          variax_startup2, (unsigned long)variax);
+
+        /* request firmware version: */
+        line6_version_request_async(line6);
+}
+
+static void variax_startup3(struct usb_line6_variax *variax)
+{
+        CHECK_STARTUP_PROGRESS(variax->startup_progress, VARIAX_STARTUP_WAIT);
+
+        /* delay startup procedure: */
+        line6_start_timer(&variax->startup_timer2, VARIAX_STARTUP_DELAY3,
+                          variax_startup4, (unsigned long)variax);
+}
+
+static void variax_startup4(unsigned long data)
+{
+        struct usb_line6_variax *variax = (struct usb_line6_variax *)data;
+
+        CHECK_STARTUP_PROGRESS(variax->startup_progress,
+                               VARIAX_STARTUP_ACTIVATE);
+
+        /* activate device: */
+        variax_activate_async(variax, 1);
+        line6_start_timer(&variax->startup_timer2, VARIAX_STARTUP_DELAY4,
+                          variax_startup5, (unsigned long)variax);
+}
+
+static void variax_startup5(unsigned long data)
+{
+        struct usb_line6_variax *variax = (struct usb_line6_variax *)data;
+
+        CHECK_STARTUP_PROGRESS(variax->startup_progress,
+                               VARIAX_STARTUP_WORKQUEUE);
+
+        /* schedule work for global work queue: */
+        schedule_work(&variax->startup_work);
+}
+
+static void variax_startup6(struct work_struct *work)
+{
+        struct usb_line6_variax *variax =
+            container_of(work, struct usb_line6_variax, startup_work);
+
+        CHECK_STARTUP_PROGRESS(variax->startup_progress, VARIAX_STARTUP_SETUP);
+
+        /* ALSA audio interface: */
+        snd_card_register(variax->line6.card);
+}
+
+/*
+        Process a completely received message.
+*/
+static void line6_variax_process_message(struct usb_line6 *line6)
+{
+        struct usb_line6_variax *variax = (struct usb_line6_variax *) line6;
+        const unsigned char *buf = variax->line6.buffer_message;
+
+        switch (buf[0]) {
+        case LINE6_RESET:
+                dev_info(variax->line6.ifcdev, "VARIAX reset\n");
+                break;
+
+        case LINE6_SYSEX_BEGIN:
+                if (memcmp(buf + 1, variax_init_version + 1,
+                           sizeof(variax_init_version) - 1) == 0) {
+                        variax_startup3(variax);
+                } else if (memcmp(buf + 1, variax_init_done + 1,
+                                  sizeof(variax_init_done) - 1) == 0) {
+                        /* notify of complete initialization: */
+                        variax_startup4((unsigned long)variax);
+                }
+                break;
+        }
+}
+
+/*
+        Variax destructor.
+*/
+static void line6_variax_disconnect(struct usb_line6 *line6)
+{
+        struct usb_line6_variax *variax = (struct usb_line6_variax *)line6;
+
+        del_timer(&variax->startup_timer1);
+        del_timer(&variax->startup_timer2);
+        cancel_work_sync(&variax->startup_work);
+
+        kfree(variax->buffer_activate);
+}
+
+/*
+         Try to init workbench device.
+*/
+static int variax_init(struct usb_line6 *line6,
+                       const struct usb_device_id *id)
+{
+        struct usb_line6_variax *variax = (struct usb_line6_variax *) line6;
+        int err;
+
+        line6->process_message = line6_variax_process_message;
+        line6->disconnect = line6_variax_disconnect;
+
+        init_timer(&variax->startup_timer1);
+        init_timer(&variax->startup_timer2);
+        INIT_WORK(&variax->startup_work, variax_startup6);
+
+        /* initialize USB buffers: */
+        variax->buffer_activate = kmemdup(variax_activate,
+                                          sizeof(variax_activate), GFP_KERNEL);
+
+        if (variax->buffer_activate == NULL)
+                return -ENOMEM;
+
+        /* initialize MIDI subsystem: */
+        err = line6_init_midi(&variax->line6);
+        if (err < 0)
+                return err;
+
+        /* initiate startup procedure: */
+        variax_startup1(variax);
+        return 0;
+}
+
+#define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod)
+#define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n)
+
+/* table of devices that work with this driver */
+static const struct usb_device_id variax_id_table[] = {
+        { LINE6_IF_NUM(0x4650, 1), .driver_info = LINE6_PODXTLIVE_VARIAX },
+        { LINE6_DEVICE(0x534d),    .driver_info = LINE6_VARIAX },
+        {}
+};
+
+MODULE_DEVICE_TABLE(usb, variax_id_table);
+
+static const struct line6_properties variax_properties_table[] = {
+        [LINE6_PODXTLIVE_VARIAX] = {
+                .id = "PODxtLive",
+                .name = "PODxt Live",
+                .capabilities   = LINE6_CAP_CONTROL,
+                .altsetting = 1,
+                .ep_ctrl_r = 0x86,
+                .ep_ctrl_w = 0x05,
+                .ep_audio_r = 0x82,
+                .ep_audio_w = 0x01,
+        },
+        [LINE6_VARIAX] = {
+                .id = "Variax",
+                .name = "Variax Workbench",
+                .capabilities   = LINE6_CAP_CONTROL,
+                .altsetting = 1,
+                .ep_ctrl_r = 0x82,
+                .ep_ctrl_w = 0x01,
+                /* no audio channel */
+        }
+};
+
+/*
+        Probe USB device.
+*/
+static int variax_probe(struct usb_interface *interface,
+                        const struct usb_device_id *id)
+{
+        return line6_probe(interface, id, "Line6-Variax",
+                           &variax_properties_table[id->driver_info],
+                           variax_init, sizeof(struct usb_line6_variax));
+}
+
+static struct usb_driver variax_driver = {
+        .name = KBUILD_MODNAME,
+        .probe = variax_probe,
+        .disconnect = line6_disconnect,
+#ifdef CONFIG_PM
+        .suspend = line6_suspend,
+        .resume = line6_resume,
+        .reset_resume = line6_resume,
+#endif
+        .id_table = variax_id_table,
+};
+
+module_usb_driver(variax_driver);
+
+MODULE_DESCRIPTION("Vairax Workbench USB driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/usb/midi.c b/sound/usb/midi.c
index 5bfb695547f8..417ebb11cf48 100644
--- a/sound/usb/midi.c
+++ b/sound/usb/midi.c
@@ -2292,14 +2292,13 @@ int snd_usbmidi_create(struct snd_card *card,
         umidi->iface = iface;
         umidi->quirk = quirk;
         umidi->usb_protocol_ops = &snd_usbmidi_standard_ops;
-        init_timer(&umidi->error_timer);
         spin_lock_init(&umidi->disc_lock);
         init_rwsem(&umidi->disc_rwsem);
         mutex_init(&umidi->mutex);
         umidi->usb_id = USB_ID(le16_to_cpu(umidi->dev->descriptor.idVendor),
                                le16_to_cpu(umidi->dev->descriptor.idProduct));
-        umidi->error_timer.function = snd_usbmidi_error_timer;
-        umidi->error_timer.data = (unsigned long)umidi;
+        setup_timer(&umidi->error_timer, snd_usbmidi_error_timer,
+                    (unsigned long)umidi);
 
         /* detect the endpoint(s) to use */
         memset(endpoints, 0, sizeof(endpoints));
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index 0d8aba5fe1a8..b4ef410e5a98 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -1464,6 +1464,14 @@ static void prepare_playback_urb(struct snd_usb_substream *subs,
         subs->last_frame_number = usb_get_current_frame_number(subs->dev);
         subs->last_frame_number &= 0xFF; /* keep 8 LSBs */
 
+        if (subs->trigger_tstamp_pending_update) {
+                /* this is the first actual URB submitted,
+                 * update trigger timestamp to reflect actual start time
+                 */
+                snd_pcm_gettime(runtime, &runtime->trigger_tstamp);
+                subs->trigger_tstamp_pending_update = false;
+        }
+
         spin_unlock_irqrestore(&subs->lock, flags);
         urb->transfer_buffer_length = bytes;
         if (period_elapsed)
@@ -1550,6 +1558,7 @@ static int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substrea
 
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
+                subs->trigger_tstamp_pending_update = true;
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
                 subs->data_endpoint->prepare_data_urb = prepare_playback_urb;
                 subs->data_endpoint->retire_data_urb = retire_playback_urb;
diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h
index 0a598af9b38b..67d476548dcf 100644
--- a/sound/usb/quirks-table.h
+++ b/sound/usb/quirks-table.h
@@ -2486,6 +2486,28 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 
+{
+        /* Akai MPC Element */
+        USB_DEVICE(0x09e8, 0x0021),
+        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_COMPOSITE,
+                .data = & (const struct snd_usb_audio_quirk[]) {
+                        {
+                                .ifnum = 0,
+                                .type = QUIRK_IGNORE_INTERFACE
+                        },
+                        {
+                                .ifnum = 1,
+                                .type = QUIRK_MIDI_STANDARD_INTERFACE
+                        },
+                        {
+                                .ifnum = -1
+                        }
+                }
+        }
+},
+
 /* TerraTec devices */
 {
         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
index a7398412310b..753a47de8459 100644
--- a/sound/usb/quirks.c
+++ b/sound/usb/quirks.c
@@ -1111,6 +1111,11 @@ void snd_usb_set_format_quirk(struct snd_usb_substream *subs,
         }
 }
 
+bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip)
+{
+        /* MS Lifecam HD-5000 doesn't support reading the sample rate. */
+        return chip->usb_id == USB_ID(0x045E, 0x076D);
+}
 
 /* Marantz/Denon USB DACs need a vendor cmd to switch
  * between PCM and native DSD mode
@@ -1122,6 +1127,7 @@ int snd_usb_select_mode_quirk(struct snd_usb_substream *subs,
         int err;
 
         switch (subs->stream->chip->usb_id) {
+        case USB_ID(0x154e, 0x1003): /* Denon DA-300USB */
         case USB_ID(0x154e, 0x3005): /* Marantz HD-DAC1 */
         case USB_ID(0x154e, 0x3006): /* Marantz SA-14S1 */
 
@@ -1201,6 +1207,7 @@ void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe,
             (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS) {
 
                 switch (le16_to_cpu(dev->descriptor.idProduct)) {
+                case 0x1003: /* Denon DA300-USB */
                 case 0x3005: /* Marantz HD-DAC1 */
                 case 0x3006: /* Marantz SA-14S1 */
                         mdelay(20);
@@ -1262,6 +1269,7 @@ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip,
 
         /* Denon/Marantz devices with USB DAC functionality */
         switch (chip->usb_id) {
+        case USB_ID(0x154e, 0x1003): /* Denon DA300-USB */
         case USB_ID(0x154e, 0x3005): /* Marantz HD-DAC1 */
         case USB_ID(0x154e, 0x3006): /* Marantz SA-14S1 */
                 if (fp->altsetting == 2)
diff --git a/sound/usb/quirks.h b/sound/usb/quirks.h
index 1b862386577d..2cd71ed1201f 100644
--- a/sound/usb/quirks.h
+++ b/sound/usb/quirks.h
@@ -21,6 +21,8 @@ int snd_usb_apply_boot_quirk(struct usb_device *dev,
 void snd_usb_set_format_quirk(struct snd_usb_substream *subs,
                               struct audioformat *fmt);
 
+bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip);
+
 int snd_usb_is_big_endian_format(struct snd_usb_audio *chip,
                                  struct audioformat *fp);
 
diff --git a/sound/usb/usx2y/usb_stream.h b/sound/usb/usx2y/usb_stream.h
index 4dd74ab1e9cc..90369001eab6 100644
--- a/sound/usb/usx2y/usb_stream.h
+++ b/sound/usb/usx2y/usb_stream.h
@@ -1,76 +1,7 @@
-/*
- * Copyright (C) 2007, 2008 Karsten Wiese <fzu@wemgehoertderstaat.de>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.
- *
- * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
+#ifndef __USB_STREAM_H
+#define __USB_STREAM_H
 
-#define USB_STREAM_INTERFACE_VERSION 2
-
-#define SNDRV_USB_STREAM_IOCTL_SET_PARAMS \
-        _IOW('H', 0x90, struct usb_stream_config)
-
-struct usb_stream_packet {
-        unsigned offset;
-        unsigned length;
-};
-
-
-struct usb_stream_config {
-        unsigned version;
-        unsigned sample_rate;
-        unsigned period_frames;
-        unsigned frame_size;
-};
-
-struct usb_stream {
-        struct usb_stream_config cfg;
-        unsigned read_size;
-        unsigned write_size;
-
-        int period_size;
-
-        unsigned state;
-
-        int idle_insize;
-        int idle_outsize;
-        int sync_packet;
-        unsigned insize_done;
-        unsigned periods_done;
-        unsigned periods_polled;
-
-        struct usb_stream_packet outpacket[2];
-        unsigned                 inpackets;
-        unsigned                 inpacket_head;
-        unsigned                 inpacket_split;
-        unsigned                 inpacket_split_at;
-        unsigned                 next_inpacket_split;
-        unsigned                 next_inpacket_split_at;
-        struct usb_stream_packet inpacket[0];
-};
-
-enum usb_stream_state {
-        usb_stream_invalid,
-        usb_stream_stopped,
-        usb_stream_sync0,
-        usb_stream_sync1,
-        usb_stream_ready,
-        usb_stream_running,
-        usb_stream_xrun,
-};
-
-#if __KERNEL__
+#include <uapi/sound/usb_stream.h>
 
 #define USB_STREAM_NURBS 4
 #define USB_STREAM_URBDEPTH 4
@@ -108,5 +39,4 @@ void usb_stream_free(struct usb_stream_kernel *);
 int usb_stream_start(struct usb_stream_kernel *);
 void usb_stream_stop(struct usb_stream_kernel *);
 
-
-#endif
+#endif /* __USB_STREAM_H */