239 files changed, 13160 insertions, 2335 deletions

diff --git a/sound/aoa/soundbus/core.c b/sound/aoa/soundbus/core.c
index 99ca7120e269..7487eb76e034 100644
--- a/sound/aoa/soundbus/core.c
+++ b/sound/aoa/soundbus/core.c
@@ -59,7 +59,7 @@ static int soundbus_probe(struct device *dev)
 static int soundbus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct soundbus_dev * soundbus_dev;
-        struct of_device * of;
+        struct platform_device * of;
         const char *compat;
         int retval = 0;
         int cplen, seen = 0;
diff --git a/sound/aoa/soundbus/soundbus.h b/sound/aoa/soundbus/soundbus.h
index a0f223c13f66..adecbf36f4f6 100644
--- a/sound/aoa/soundbus/soundbus.h
+++ b/sound/aoa/soundbus/soundbus.h
@@ -141,7 +141,7 @@ struct soundbus_dev {
         struct list_head onbuslist;
 
         /* the of device it represents */
-        struct of_device ofdev;
+        struct platform_device ofdev;
 
         /* what modules go by */
         char modalias[32];
diff --git a/sound/aoa/soundbus/sysfs.c b/sound/aoa/soundbus/sysfs.c
index 6496e754f00a..e0980b5c2cd8 100644
--- a/sound/aoa/soundbus/sysfs.c
+++ b/sound/aoa/soundbus/sysfs.c
@@ -16,7 +16,7 @@ static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
                              char *buf)
 {
         struct soundbus_dev *sdev = to_soundbus_device(dev);
-        struct of_device *of = &sdev->ofdev;
+        struct platform_device *of = &sdev->ofdev;
         int length;
 
         if (*sdev->modalias) {
diff --git a/sound/core/init.c b/sound/core/init.c
index ec4a50ce5656..2de45fbd70fb 100644
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -607,11 +607,16 @@ card_id_store_attr(struct device *dev, struct device_attribute *attr,
                 return -EEXIST;
         }
         for (idx = 0; idx < snd_ecards_limit; idx++) {
-                if (snd_cards[idx] && !strcmp(snd_cards[idx]->id, buf1))
-                        goto __exist;
+                if (snd_cards[idx] && !strcmp(snd_cards[idx]->id, buf1)) {
+                        if (card == snd_cards[idx])
+                                goto __ok;
+                        else
+                                goto __exist;
+                }
         }
         strcpy(card->id, buf1);
         snd_info_card_id_change(card);
+__ok:
         mutex_unlock(&snd_card_mutex);
 
         return count;
diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index f50ebf20df96..86afb13cd240 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -77,7 +77,7 @@ static int snd_mixer_oss_release(struct inode *inode, struct file *file)
         struct snd_mixer_oss_file *fmixer;
 
         if (file->private_data) {
-                fmixer = (struct snd_mixer_oss_file *) file->private_data;
+                fmixer = file->private_data;
                 module_put(fmixer->card->module);
                 snd_card_file_remove(fmixer->card, file);
                 kfree(fmixer);
@@ -368,7 +368,7 @@ static int snd_mixer_oss_ioctl1(struct snd_mixer_oss_file *fmixer, unsigned int
 
 static long snd_mixer_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        return snd_mixer_oss_ioctl1((struct snd_mixer_oss_file *) file->private_data, cmd, arg);
+        return snd_mixer_oss_ioctl1(file->private_data, cmd, arg);
 }
 
 int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg)
@@ -582,7 +582,7 @@ static int snd_mixer_oss_get_volume1(struct snd_mixer_oss_file *fmixer,
                                      struct snd_mixer_oss_slot *pslot,
                                      int *left, int *right)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         
         *left = *right = 100;
         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) {
@@ -691,7 +691,7 @@ static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file *fmixer,
                                      struct snd_mixer_oss_slot *pslot,
                                      int left, int right)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         
         if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) {
                 snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PVOLUME], left, right);
@@ -740,7 +740,7 @@ static int snd_mixer_oss_get_recsrc1_sw(struct snd_mixer_oss_file *fmixer,
                                         struct snd_mixer_oss_slot *pslot,
                                         int *active)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         int left, right;
         
         left = right = 1;
@@ -753,7 +753,7 @@ static int snd_mixer_oss_get_recsrc1_route(struct snd_mixer_oss_file *fmixer,
                                            struct snd_mixer_oss_slot *pslot,
                                            int *active)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         int left, right;
         
         left = right = 1;
@@ -766,7 +766,7 @@ static int snd_mixer_oss_put_recsrc1_sw(struct snd_mixer_oss_file *fmixer,
                                         struct snd_mixer_oss_slot *pslot,
                                         int active)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         
         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], active, active, 0);
         return 0;
@@ -776,7 +776,7 @@ static int snd_mixer_oss_put_recsrc1_route(struct snd_mixer_oss_file *fmixer,
                                            struct snd_mixer_oss_slot *pslot,
                                            int active)
 {
-        struct slot *slot = (struct slot *)pslot->private_data;
+        struct slot *slot = pslot->private_data;
         
         snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], active, active, 1);
         return 0;
@@ -813,7 +813,7 @@ static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned
                 if (!(mixer->mask_recsrc & (1 << idx)))
                         continue;
                 pslot = &mixer->slots[idx];
-                slot = (struct slot *)pslot->private_data;
+                slot = pslot->private_data;
                 if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE)
                         continue;
                 if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE))
@@ -861,7 +861,7 @@ static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned
                 if (!(mixer->mask_recsrc & (1 << idx)))
                         continue;
                 pslot = &mixer->slots[idx];
-                slot = (struct slot *)pslot->private_data;
+                slot = pslot->private_data;
                 if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE)
                         continue;
                 if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE))
@@ -925,7 +925,7 @@ static int snd_mixer_oss_build_test(struct snd_mixer_oss *mixer, struct slot *sl
 
 static void snd_mixer_oss_slot_free(struct snd_mixer_oss_slot *chn)
 {
-        struct slot *p = (struct slot *)chn->private_data;
+        struct slot *p = chn->private_data;
         if (p) {
                 if (p->allocated && p->assigned) {
                         kfree(p->assigned->name);
diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index cbe815dfbdc8..88525a958291 100644
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -203,10 +203,16 @@ static char *snd_pcm_format_names[] = {
         FORMAT(S18_3BE),
         FORMAT(U18_3LE),
         FORMAT(U18_3BE),
+        FORMAT(G723_24),
+        FORMAT(G723_24_1B),
+        FORMAT(G723_40),
+        FORMAT(G723_40_1B),
 };
 
 const char *snd_pcm_format_name(snd_pcm_format_t format)
 {
+        if (format >= ARRAY_SIZE(snd_pcm_format_names))
+                return "Unknown";
         return snd_pcm_format_names[format];
 }
 EXPORT_SYMBOL_GPL(snd_pcm_format_name);
@@ -358,8 +364,7 @@ static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry,
 static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry,
                                              struct snd_info_buffer *buffer)
 {
-        snd_pcm_proc_info_read((struct snd_pcm_substream *)entry->private_data,
-                               buffer);
+        snd_pcm_proc_info_read(entry->private_data, buffer);
 }
 
 static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index d6ecca27bb68..a1707cca9c66 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -67,6 +67,8 @@ void snd_pcm_playback_silence(struct snd_pcm_substream *substream, snd_pcm_ufram
         } else {
                 if (new_hw_ptr == ULONG_MAX) {  /* initialization */
                         snd_pcm_sframes_t avail = snd_pcm_playback_hw_avail(runtime);
+                        if (avail > runtime->buffer_size)
+                                avail = runtime->buffer_size;
                         runtime->silence_filled = avail > 0 ? avail : 0;
                         runtime->silence_start = (runtime->status->hw_ptr +
                                                   runtime->silence_filled) %
@@ -287,8 +289,11 @@ int snd_pcm_update_state(struct snd_pcm_substream *substream,
                         return -EPIPE;
                 }
         }
-        if (avail >= runtime->control->avail_min)
-                wake_up(runtime->twake ? &runtime->tsleep : &runtime->sleep);
+        if (runtime->twake) {
+                if (avail >= runtime->twake)
+                        wake_up(&runtime->tsleep);
+        } else if (avail >= runtime->control->avail_min)
+                wake_up(&runtime->sleep);
         return 0;
 }
 
@@ -1711,7 +1716,7 @@ EXPORT_SYMBOL(snd_pcm_period_elapsed);
  * The available space is stored on availp.  When err = 0 and avail = 0
  * on the capture stream, it indicates the stream is in DRAINING state.
  */
-static int wait_for_avail_min(struct snd_pcm_substream *substream,
+static int wait_for_avail(struct snd_pcm_substream *substream,
                               snd_pcm_uframes_t *availp)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
@@ -1761,7 +1766,7 @@ static int wait_for_avail_min(struct snd_pcm_substream *substream,
                         avail = snd_pcm_playback_avail(runtime);
                 else
                         avail = snd_pcm_capture_avail(runtime);
-                if (avail >= runtime->control->avail_min)
+                if (avail >= runtime->twake)
                         break;
         }
  _endloop:
@@ -1824,7 +1829,7 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
                 goto _end_unlock;
         }
 
-        runtime->twake = 1;
+        runtime->twake = runtime->control->avail_min ? : 1;
         while (size > 0) {
                 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
                 snd_pcm_uframes_t avail;
@@ -1837,7 +1842,9 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
                                 err = -EAGAIN;
                                 goto _end_unlock;
                         }
-                        err = wait_for_avail_min(substream, &avail);
+                        runtime->twake = min_t(snd_pcm_uframes_t, size,
+                                        runtime->control->avail_min ? : 1);
+                        err = wait_for_avail(substream, &avail);
                         if (err < 0)
                                 goto _end_unlock;
                 }
@@ -2046,7 +2053,7 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                 goto _end_unlock;
         }
 
-        runtime->twake = 1;
+        runtime->twake = runtime->control->avail_min ? : 1;
         while (size > 0) {
                 snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
                 snd_pcm_uframes_t avail;
@@ -2064,7 +2071,9 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                                 err = -EAGAIN;
                                 goto _end_unlock;
                         }
-                        err = wait_for_avail_min(substream, &avail);
+                        runtime->twake = min_t(snd_pcm_uframes_t, size,
+                                        runtime->control->avail_min ? : 1);
+                        err = wait_for_avail(substream, &avail);
                         if (err < 0)
                                 goto _end_unlock;
                         if (!avail)
diff --git a/sound/core/pcm_misc.c b/sound/core/pcm_misc.c
index ea2bf82c9373..434af3c56d52 100644
--- a/sound/core/pcm_misc.c
+++ b/sound/core/pcm_misc.c
@@ -128,6 +128,14 @@ static struct pcm_format_data pcm_formats[SNDRV_PCM_FORMAT_LAST+1] = {
                 .width = 4, .phys = 4, .le = -1, .signd = -1,
                 .silence = {},
         },
+        [SNDRV_PCM_FORMAT_G723_24] = {
+                .width = 3, .phys = 3, .le = -1, .signd = -1,
+                .silence = {},
+        },
+        [SNDRV_PCM_FORMAT_G723_40] = {
+                .width = 5, .phys = 5, .le = -1, .signd = -1,
+                .silence = {},
+        },
         /* FIXME: the following three formats are not defined properly yet */
         [SNDRV_PCM_FORMAT_MPEG] = {
                 .le = -1, .signd = -1,
@@ -186,6 +194,14 @@ static struct pcm_format_data pcm_formats[SNDRV_PCM_FORMAT_LAST+1] = {
                 .width = 18, .phys = 24, .le = 0, .signd = 0,
                 .silence = { 0x02, 0x00, 0x00 },
         },
+        [SNDRV_PCM_FORMAT_G723_24_1B] = {
+                .width = 3, .phys = 8, .le = -1, .signd = -1,
+                .silence = {},
+        },
+        [SNDRV_PCM_FORMAT_G723_40_1B] = {
+                .width = 5, .phys = 8, .le = -1, .signd = -1,
+                .silence = {},
+        },
 };
 
 
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 2d2e1b65ee9a..eb4094270a4f 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -142,7 +142,7 @@ int snd_pcm_info_user(struct snd_pcm_substream *substream,
 
 #ifdef RULES_DEBUG
 #define HW_PARAM(v) [SNDRV_PCM_HW_PARAM_##v] = #v
-char *snd_pcm_hw_param_names[] = {
+static const char * const snd_pcm_hw_param_names[] = {
         HW_PARAM(ACCESS),
         HW_PARAM(FORMAT),
         HW_PARAM(SUBFORMAT),
@@ -451,13 +451,11 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
         snd_pcm_timer_resolution_change(substream);
         runtime->status->state = SNDRV_PCM_STATE_SETUP;
 
-        if (substream->latency_pm_qos_req) {
-                pm_qos_remove_request(substream->latency_pm_qos_req);
-                substream->latency_pm_qos_req = NULL;
-        }
+        if (pm_qos_request_active(&substream->latency_pm_qos_req))
+                pm_qos_remove_request(&substream->latency_pm_qos_req);
         if ((usecs = period_to_usecs(runtime)) >= 0)
-                substream->latency_pm_qos_req = pm_qos_add_request(
-                                        PM_QOS_CPU_DMA_LATENCY, usecs);
+                pm_qos_add_request(&substream->latency_pm_qos_req,
+                                   PM_QOS_CPU_DMA_LATENCY, usecs);
         return 0;
  _error:
         /* hardware might be unuseable from this time,
@@ -512,8 +510,7 @@ static int snd_pcm_hw_free(struct snd_pcm_substream *substream)
         if (substream->ops->hw_free)
                 result = substream->ops->hw_free(substream);
         runtime->status->state = SNDRV_PCM_STATE_OPEN;
-        pm_qos_remove_request(substream->latency_pm_qos_req);
-        substream->latency_pm_qos_req = NULL;
+        pm_qos_remove_request(&substream->latency_pm_qos_req);
         return result;
 }
 
@@ -983,6 +980,10 @@ static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push)
 {
         if (substream->runtime->trigger_master != substream)
                 return 0;
+        /* some drivers might use hw_ptr to recover from the pause -
+           update the hw_ptr now */
+        if (push)
+                snd_pcm_update_hw_ptr(substream);
         /* The jiffies check in snd_pcm_update_hw_ptr*() is done by
          * a delta betwen the current jiffies, this gives a large enough
          * delta, effectively to skip the check once.
diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c
index eb68326c37d4..a7868ad4d530 100644
--- a/sound/core/rawmidi.c
+++ b/sound/core/rawmidi.c
@@ -829,6 +829,8 @@ static int snd_rawmidi_control_ioctl(struct snd_card *card,
                 
                 if (get_user(device, (int __user *)argp))
                         return -EFAULT;
+                if (device >= SNDRV_RAWMIDI_DEVICES) /* next device is -1 */
+                        device = SNDRV_RAWMIDI_DEVICES - 1;
                 mutex_lock(&register_mutex);
                 device = device < 0 ? 0 : device + 1;
                 while (device < SNDRV_RAWMIDI_DEVICES) {
diff --git a/sound/core/seq/oss/seq_oss_init.c b/sound/core/seq/oss/seq_oss_init.c
index 685712276ac9..69cd7b3c362d 100644
--- a/sound/core/seq/oss/seq_oss_init.c
+++ b/sound/core/seq/oss/seq_oss_init.c
@@ -281,13 +281,10 @@ snd_seq_oss_open(struct file *file, int level)
         return 0;
 
  _error:
-        snd_seq_oss_writeq_delete(dp->writeq);
-        snd_seq_oss_readq_delete(dp->readq);
         snd_seq_oss_synth_cleanup(dp);
         snd_seq_oss_midi_cleanup(dp);
-        delete_port(dp);
         delete_seq_queue(dp->queue);
-        kfree(dp);
+        delete_port(dp);
 
         return rc;
 }
@@ -350,8 +347,10 @@ create_port(struct seq_oss_devinfo *dp)
 static int
 delete_port(struct seq_oss_devinfo *dp)
 {
-        if (dp->port < 0)
+        if (dp->port < 0) {
+                kfree(dp);
                 return 0;
+        }
 
         debug_printk(("delete_port %i\n", dp->port));
         return snd_seq_event_port_detach(dp->cseq, dp->port);
diff --git a/sound/drivers/Kconfig b/sound/drivers/Kconfig
index b6ae76285255..c8961165277c 100644
--- a/sound/drivers/Kconfig
+++ b/sound/drivers/Kconfig
@@ -174,7 +174,7 @@ config SND_ML403_AC97CR
         select SND_AC97_CODEC
         help
           Say Y here to include support for the
-          opb_ac97_controller_ref_v1_00_a ip core found in Xilinx' ML403
+          opb_ac97_controller_ref_v1_00_a ip core found in Xilinx's ML403
           reference design.
 
           To compile this driver as a module, choose M here: the module
@@ -189,9 +189,25 @@ config SND_AC97_POWER_SAVE
           AC97 codecs.  In this mode, the power-mode is dynamically
           controlled at each open/close.
 
-          The mode is activated by passing power_save=1 option to
-          snd-ac97-codec driver.  You can toggle it dynamically over
-          sysfs, too.
+          The mode is activated by passing 'power_save=X' to the
+          snd-ac97-codec driver module, where 'X' is the time-out
+          value, a nonnegative integer that specifies how many
+          seconds of idle time the driver must count before it may
+          put the AC97 into power-save mode;  a value of 0 (zero)
+          disables the use of this power-save mode.
+
+          After the snd-ac97-codec driver module has been loaded,
+          the 'power_save' parameter can be set via sysfs as follows:
+
+            echo 10 > /sys/module/snd_ac97_codec/parameters/power_save
+
+          In this case, the time-out is set to 10 seconds; setting
+          the time-out to 1 second (the minimum activation value)
+          isn't recommended because many applications try to reopen
+          the device frequently.  A value of 10 seconds would be a
+          good choice for normal operations.
+
+          See Documentation/sound/alsa/powersave.txt for more details.
 
 config SND_AC97_POWER_SAVE_DEFAULT
         int "Default time-out for AC97 power-save mode"
@@ -201,4 +217,6 @@ config SND_AC97_POWER_SAVE_DEFAULT
           The default time-out value in seconds for AC97 automatic
           power-save mode.  0 means to disable the power-save mode.
 
+          See SND_AC97_POWER_SAVE for more details.
+
 endif   # SND_DRIVERS
diff --git a/sound/drivers/virmidi.c b/sound/drivers/virmidi.c
index 0e631c3221e3..f4cd49336f33 100644
--- a/sound/drivers/virmidi.c
+++ b/sound/drivers/virmidi.c
@@ -94,7 +94,7 @@ static int __devinit snd_virmidi_probe(struct platform_device *devptr)
                               sizeof(struct snd_card_virmidi), &card);
         if (err < 0)
                 return err;
-        vmidi = (struct snd_card_virmidi *)card->private_data;
+        vmidi = card->private_data;
         vmidi->card = card;
 
         if (midi_devs[dev] > MAX_MIDI_DEVICES) {
diff --git a/sound/i2c/other/ak4xxx-adda.c b/sound/i2c/other/ak4xxx-adda.c
index 1adb8a3c2b62..ebab6c7aaa81 100644
--- a/sound/i2c/other/ak4xxx-adda.c
+++ b/sound/i2c/other/ak4xxx-adda.c
@@ -878,7 +878,7 @@ static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs)
 static void proc_regs_read(struct snd_info_entry *entry,
                 struct snd_info_buffer *buffer)
 {
-        struct snd_akm4xxx *ak = (struct snd_akm4xxx *)entry->private_data;
+        struct snd_akm4xxx *ak = entry->private_data;
         int reg, val, chip;
         for (chip = 0; chip < ak->num_chips; chip++) {
                 for (reg = 0; reg < ak->total_regs; reg++) {
diff --git a/sound/isa/Kconfig b/sound/isa/Kconfig
index c6990c680796..52064cfa91f3 100644
--- a/sound/isa/Kconfig
+++ b/sound/isa/Kconfig
@@ -77,6 +77,32 @@ config SND_ALS100
           To compile this driver as a module, choose M here: the module
           will be called snd-als100.
 
+config SND_AZT1605
+        tristate "Aztech AZT1605 Driver"
+        depends on SND
+        select SND_WSS_LIB
+        select SND_MPU401_UART
+        select SND_OPL3_LIB
+        help
+          Say Y here to include support for Aztech Sound Galaxy cards
+          based on the AZT1605 chipset.
+
+          To compile this driver as a module, choose M here: the module
+          will be called snd-azt1605.
+
+config SND_AZT2316
+        tristate "Aztech AZT2316 Driver"
+        depends on SND
+        select SND_WSS_LIB
+        select SND_MPU401_UART
+        select SND_OPL3_LIB
+        help
+          Say Y here to include support for Aztech Sound Galaxy cards
+          based on the AZT2316 chipset.
+
+          To compile this driver as a module, choose M here: the module
+          will be called snd-azt2316.
+
 config SND_AZT2320
         tristate "Aztech Systems AZT2320"
         depends on PNP
@@ -351,16 +377,6 @@ config SND_SB16_CSP
           coprocessor can do variable tasks like various compression and
           decompression algorithms.
 
-config SND_SGALAXY
-        tristate "Aztech Sound Galaxy"
-        select SND_WSS_LIB
-        help
-          Say Y here to include support for Aztech Sound Galaxy
-          soundcards.
-
-          To compile this driver as a module, choose M here: the module
-          will be called snd-sgalaxy.
-
 config SND_SSCAPE
         tristate "Ensoniq SoundScape driver"
         select SND_MPU401_UART
diff --git a/sound/isa/Makefile b/sound/isa/Makefile
index c73d30c4f462..8d781e419e2e 100644
--- a/sound/isa/Makefile
+++ b/sound/isa/Makefile
@@ -10,7 +10,6 @@ snd-cmi8330-objs := cmi8330.o
 snd-es18xx-objs := es18xx.o
 snd-opl3sa2-objs := opl3sa2.o
 snd-sc6000-objs := sc6000.o
-snd-sgalaxy-objs := sgalaxy.o
 snd-sscape-objs := sscape.o
 
 # Toplevel Module Dependency
@@ -21,8 +20,7 @@ obj-$(CONFIG_SND_CMI8330) += snd-cmi8330.o
 obj-$(CONFIG_SND_ES18XX) += snd-es18xx.o
 obj-$(CONFIG_SND_OPL3SA2) += snd-opl3sa2.o
 obj-$(CONFIG_SND_SC6000) += snd-sc6000.o
-obj-$(CONFIG_SND_SGALAXY) += snd-sgalaxy.o
 obj-$(CONFIG_SND_SSCAPE) += snd-sscape.o
 
-obj-$(CONFIG_SND) += ad1816a/ ad1848/ cs423x/ es1688/ gus/ msnd/ opti9xx/ \
+obj-$(CONFIG_SND) += ad1816a/ ad1848/ cs423x/ es1688/ galaxy/ gus/ msnd/ opti9xx/ \
                      sb/ wavefront/ wss/
diff --git a/sound/isa/ad1816a/ad1816a.c b/sound/isa/ad1816a/ad1816a.c
index bbcbf92a8ebe..3cb75bc97699 100644
--- a/sound/isa/ad1816a/ad1816a.c
+++ b/sound/isa/ad1816a/ad1816a.c
@@ -162,7 +162,7 @@ static int __devinit snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard
                                 sizeof(struct snd_card_ad1816a), &card);
         if (error < 0)
                 return error;
-        acard = (struct snd_card_ad1816a *)card->private_data;
+        acard = card->private_data;
 
         if ((error = snd_card_ad1816a_pnp(dev, acard, pcard, pid))) {
                 snd_card_free(card);
diff --git a/sound/isa/azt2320.c b/sound/isa/azt2320.c
index f7aa637b0d18..aac8dc15c2fe 100644
--- a/sound/isa/azt2320.c
+++ b/sound/isa/azt2320.c
@@ -188,7 +188,7 @@ static int __devinit snd_card_azt2320_probe(int dev,
                                 sizeof(struct snd_card_azt2320), &card);
         if (error < 0)
                 return error;
-        acard = (struct snd_card_azt2320 *)card->private_data;
+        acard = card->private_data;
 
         if ((error = snd_card_azt2320_pnp(dev, acard, pcard, pid))) {
                 snd_card_free(card);
diff --git a/sound/isa/galaxy/Makefile b/sound/isa/galaxy/Makefile
new file mode 100644
index 000000000000..e307066d4315
--- /dev/null
+++ b/sound/isa/galaxy/Makefile
@@ -0,0 +1,10 @@
+#
+# Makefile for ALSA
+# Copyright (c) 2001 by Jaroslav Kysela <perex@suse.cz>
+#
+
+snd-azt1605-objs := azt1605.o
+snd-azt2316-objs := azt2316.o
+
+obj-$(CONFIG_SND_AZT1605) += snd-azt1605.o
+obj-$(CONFIG_SND_AZT2316) += snd-azt2316.o
diff --git a/sound/isa/galaxy/azt1605.c b/sound/isa/galaxy/azt1605.c
new file mode 100644
index 000000000000..9a97643cb713
--- /dev/null
+++ b/sound/isa/galaxy/azt1605.c
@@ -0,0 +1,91 @@
+/*
+ * Aztech AZT1605 Driver
+ * Copyright (C) 2007,2010  Rene Herman
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#define AZT1605
+
+#define CRD_NAME "Aztech AZT1605"
+#define DRV_NAME "AZT1605"
+#define DEV_NAME "azt1605"
+
+#define GALAXY_DSP_MAJOR                2
+#define GALAXY_DSP_MINOR                1
+
+#define GALAXY_CONFIG_SIZE              3
+
+/*
+ * 24-bit config register
+ */
+
+#define GALAXY_CONFIG_SBA_220           (0 << 0)
+#define GALAXY_CONFIG_SBA_240           (1 << 0)
+#define GALAXY_CONFIG_SBA_260           (2 << 0)
+#define GALAXY_CONFIG_SBA_280           (3 << 0)
+#define GALAXY_CONFIG_SBA_MASK          GALAXY_CONFIG_SBA_280
+
+#define GALAXY_CONFIG_MPUA_300          (0 << 2)
+#define GALAXY_CONFIG_MPUA_330          (1 << 2)
+
+#define GALAXY_CONFIG_MPU_ENABLE        (1 << 3)
+
+#define GALAXY_CONFIG_GAME_ENABLE       (1 << 4)
+
+#define GALAXY_CONFIG_CD_PANASONIC      (1 << 5)
+#define GALAXY_CONFIG_CD_MITSUMI        (1 << 6)
+#define GALAXY_CONFIG_CD_MASK           (\
+        GALAXY_CONFIG_CD_PANASONIC | GALAXY_CONFIG_CD_MITSUMI)
+
+#define GALAXY_CONFIG_UNUSED            (1 << 7)
+#define GALAXY_CONFIG_UNUSED_MASK       GALAXY_CONFIG_UNUSED
+
+#define GALAXY_CONFIG_SBIRQ_2           (1 << 8)
+#define GALAXY_CONFIG_SBIRQ_3           (1 << 9)
+#define GALAXY_CONFIG_SBIRQ_5           (1 << 10)
+#define GALAXY_CONFIG_SBIRQ_7           (1 << 11)
+
+#define GALAXY_CONFIG_MPUIRQ_2          (1 << 12)
+#define GALAXY_CONFIG_MPUIRQ_3          (1 << 13)
+#define GALAXY_CONFIG_MPUIRQ_5          (1 << 14)
+#define GALAXY_CONFIG_MPUIRQ_7          (1 << 15)
+
+#define GALAXY_CONFIG_WSSA_530          (0 << 16)
+#define GALAXY_CONFIG_WSSA_604          (1 << 16)
+#define GALAXY_CONFIG_WSSA_E80          (2 << 16)
+#define GALAXY_CONFIG_WSSA_F40          (3 << 16)
+
+#define GALAXY_CONFIG_WSS_ENABLE        (1 << 18)
+
+#define GALAXY_CONFIG_CDIRQ_11          (1 << 19)
+#define GALAXY_CONFIG_CDIRQ_12          (1 << 20)
+#define GALAXY_CONFIG_CDIRQ_15          (1 << 21)
+#define GALAXY_CONFIG_CDIRQ_MASK        (\
+        GALAXY_CONFIG_CDIRQ_11 | GALAXY_CONFIG_CDIRQ_12 |\
+        GALAXY_CONFIG_CDIRQ_15)
+
+#define GALAXY_CONFIG_CDDMA_DISABLE     (0 << 22)
+#define GALAXY_CONFIG_CDDMA_0           (1 << 22)
+#define GALAXY_CONFIG_CDDMA_1           (2 << 22)
+#define GALAXY_CONFIG_CDDMA_3           (3 << 22)
+#define GALAXY_CONFIG_CDDMA_MASK        GALAXY_CONFIG_CDDMA_3
+
+#define GALAXY_CONFIG_MASK              (\
+        GALAXY_CONFIG_SBA_MASK | GALAXY_CONFIG_CD_MASK |\
+        GALAXY_CONFIG_UNUSED_MASK | GALAXY_CONFIG_CDIRQ_MASK |\
+        GALAXY_CONFIG_CDDMA_MASK)
+
+#include "galaxy.c"
diff --git a/sound/isa/galaxy/azt2316.c b/sound/isa/galaxy/azt2316.c
new file mode 100644
index 000000000000..189441141df6
--- /dev/null
+++ b/sound/isa/galaxy/azt2316.c
@@ -0,0 +1,111 @@
+/*
+ * Aztech AZT2316 Driver
+ * Copyright (C) 2007,2010  Rene Herman
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#define AZT2316
+
+#define CRD_NAME "Aztech AZT2316"
+#define DRV_NAME "AZT2316"
+#define DEV_NAME "azt2316"
+
+#define GALAXY_DSP_MAJOR                3
+#define GALAXY_DSP_MINOR                1
+
+#define GALAXY_CONFIG_SIZE              4
+
+/*
+ * 32-bit config register
+ */
+
+#define GALAXY_CONFIG_SBA_220           (0 << 0)
+#define GALAXY_CONFIG_SBA_240           (1 << 0)
+#define GALAXY_CONFIG_SBA_260           (2 << 0)
+#define GALAXY_CONFIG_SBA_280           (3 << 0)
+#define GALAXY_CONFIG_SBA_MASK          GALAXY_CONFIG_SBA_280
+
+#define GALAXY_CONFIG_SBIRQ_2           (1 << 2)
+#define GALAXY_CONFIG_SBIRQ_5           (1 << 3)
+#define GALAXY_CONFIG_SBIRQ_7           (1 << 4)
+#define GALAXY_CONFIG_SBIRQ_10          (1 << 5)
+
+#define GALAXY_CONFIG_SBDMA_DISABLE     (0 << 6)
+#define GALAXY_CONFIG_SBDMA_0           (1 << 6)
+#define GALAXY_CONFIG_SBDMA_1           (2 << 6)
+#define GALAXY_CONFIG_SBDMA_3           (3 << 6)
+
+#define GALAXY_CONFIG_WSSA_530          (0 << 8)
+#define GALAXY_CONFIG_WSSA_604          (1 << 8)
+#define GALAXY_CONFIG_WSSA_E80          (2 << 8)
+#define GALAXY_CONFIG_WSSA_F40          (3 << 8)
+
+#define GALAXY_CONFIG_WSS_ENABLE        (1 << 10)
+
+#define GALAXY_CONFIG_GAME_ENABLE       (1 << 11)
+
+#define GALAXY_CONFIG_MPUA_300          (0 << 12)
+#define GALAXY_CONFIG_MPUA_330          (1 << 12)
+
+#define GALAXY_CONFIG_MPU_ENABLE        (1 << 13)
+
+#define GALAXY_CONFIG_CDA_310           (0 << 14)
+#define GALAXY_CONFIG_CDA_320           (1 << 14)
+#define GALAXY_CONFIG_CDA_340           (2 << 14)
+#define GALAXY_CONFIG_CDA_350           (3 << 14)
+#define GALAXY_CONFIG_CDA_MASK          GALAXY_CONFIG_CDA_350
+
+#define GALAXY_CONFIG_CD_DISABLE        (0 << 16)
+#define GALAXY_CONFIG_CD_PANASONIC      (1 << 16)
+#define GALAXY_CONFIG_CD_SONY           (2 << 16)
+#define GALAXY_CONFIG_CD_MITSUMI        (3 << 16)
+#define GALAXY_CONFIG_CD_AZTECH         (4 << 16)
+#define GALAXY_CONFIG_CD_UNUSED_5       (5 << 16)
+#define GALAXY_CONFIG_CD_UNUSED_6       (6 << 16)
+#define GALAXY_CONFIG_CD_UNUSED_7       (7 << 16)
+#define GALAXY_CONFIG_CD_MASK           GALAXY_CONFIG_CD_UNUSED_7
+
+#define GALAXY_CONFIG_CDDMA8_DISABLE    (0 << 20)
+#define GALAXY_CONFIG_CDDMA8_0          (1 << 20)
+#define GALAXY_CONFIG_CDDMA8_1          (2 << 20)
+#define GALAXY_CONFIG_CDDMA8_3          (3 << 20)
+#define GALAXY_CONFIG_CDDMA8_MASK       GALAXY_CONFIG_CDDMA8_3
+
+#define GALAXY_CONFIG_CDDMA16_DISABLE   (0 << 22)
+#define GALAXY_CONFIG_CDDMA16_5         (1 << 22)
+#define GALAXY_CONFIG_CDDMA16_6         (2 << 22)
+#define GALAXY_CONFIG_CDDMA16_7         (3 << 22)
+#define GALAXY_CONFIG_CDDMA16_MASK      GALAXY_CONFIG_CDDMA16_7
+
+#define GALAXY_CONFIG_MPUIRQ_2          (1 << 24)
+#define GALAXY_CONFIG_MPUIRQ_5          (1 << 25)
+#define GALAXY_CONFIG_MPUIRQ_7          (1 << 26)
+#define GALAXY_CONFIG_MPUIRQ_10         (1 << 27)
+
+#define GALAXY_CONFIG_CDIRQ_5           (1 << 28)
+#define GALAXY_CONFIG_CDIRQ_11          (1 << 29)
+#define GALAXY_CONFIG_CDIRQ_12          (1 << 30)
+#define GALAXY_CONFIG_CDIRQ_15          (1 << 31)
+#define GALAXY_CONFIG_CDIRQ_MASK        (\
+        GALAXY_CONFIG_CDIRQ_5 | GALAXY_CONFIG_CDIRQ_11 |\
+        GALAXY_CONFIG_CDIRQ_12 | GALAXY_CONFIG_CDIRQ_15)
+
+#define GALAXY_CONFIG_MASK              (\
+        GALAXY_CONFIG_SBA_MASK | GALAXY_CONFIG_CDA_MASK |\
+        GALAXY_CONFIG_CD_MASK | GALAXY_CONFIG_CDDMA16_MASK |\
+        GALAXY_CONFIG_CDDMA8_MASK | GALAXY_CONFIG_CDIRQ_MASK)
+
+#include "galaxy.c"
diff --git a/sound/isa/galaxy/galaxy.c b/sound/isa/galaxy/galaxy.c
new file mode 100644
index 000000000000..ee54df082b9c
--- /dev/null
+++ b/sound/isa/galaxy/galaxy.c
@@ -0,0 +1,652 @@
+/*
+ * Aztech AZT1605/AZT2316 Driver
+ * Copyright (C) 2007,2010  Rene Herman
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/isa.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <asm/processor.h>
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/wss.h>
+#include <sound/mpu401.h>
+#include <sound/opl3.h>
+
+MODULE_DESCRIPTION(CRD_NAME);
+MODULE_AUTHOR("Rene Herman");
+MODULE_LICENSE("GPL");
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
+static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
+static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;
+
+module_param_array(index, int, NULL, 0444);
+MODULE_PARM_DESC(index, "Index value for " CRD_NAME " soundcard.");
+module_param_array(id, charp, NULL, 0444);
+MODULE_PARM_DESC(id, "ID string for " CRD_NAME " soundcard.");
+module_param_array(enable, bool, NULL, 0444);
+MODULE_PARM_DESC(enable, "Enable " CRD_NAME " soundcard.");
+
+static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static long wss_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
+static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
+static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
+static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
+static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
+
+module_param_array(port, long, NULL, 0444);
+MODULE_PARM_DESC(port, "Port # for " CRD_NAME " driver.");
+module_param_array(wss_port, long, NULL, 0444);
+MODULE_PARM_DESC(wss_port, "WSS port # for " CRD_NAME " driver.");
+module_param_array(mpu_port, long, NULL, 0444);
+MODULE_PARM_DESC(mpu_port, "MPU-401 port # for " CRD_NAME " driver.");
+module_param_array(fm_port, long, NULL, 0444);
+MODULE_PARM_DESC(fm_port, "FM port # for " CRD_NAME " driver.");
+module_param_array(irq, int, NULL, 0444);
+MODULE_PARM_DESC(irq, "IRQ # for " CRD_NAME " driver.");
+module_param_array(mpu_irq, int, NULL, 0444);
+MODULE_PARM_DESC(mpu_irq, "MPU-401 IRQ # for " CRD_NAME " driver.");
+module_param_array(dma1, int, NULL, 0444);
+MODULE_PARM_DESC(dma1, "Playback DMA # for " CRD_NAME " driver.");
+module_param_array(dma2, int, NULL, 0444);
+MODULE_PARM_DESC(dma2, "Capture DMA # for " CRD_NAME " driver.");
+
+/*
+ * Generic SB DSP support routines
+ */
+
+#define DSP_PORT_RESET          0x6
+#define DSP_PORT_READ           0xa
+#define DSP_PORT_COMMAND        0xc
+#define DSP_PORT_STATUS         0xc
+#define DSP_PORT_DATA_AVAIL     0xe
+
+#define DSP_SIGNATURE           0xaa
+
+#define DSP_COMMAND_GET_VERSION 0xe1
+
+static int __devinit dsp_get_byte(void __iomem *port, u8 *val)
+{
+        int loops = 1000;
+
+        while (!(ioread8(port + DSP_PORT_DATA_AVAIL) & 0x80)) {
+                if (!loops--)
+                        return -EIO;
+                cpu_relax();
+        }
+        *val = ioread8(port + DSP_PORT_READ);
+        return 0;
+}
+
+static int __devinit dsp_reset(void __iomem *port)
+{
+        u8 val;
+
+        iowrite8(1, port + DSP_PORT_RESET);
+        udelay(10);
+        iowrite8(0, port + DSP_PORT_RESET);
+
+        if (dsp_get_byte(port, &val) < 0 || val != DSP_SIGNATURE)
+                return -ENODEV;
+
+        return 0;
+}
+
+static int __devinit dsp_command(void __iomem *port, u8 cmd)
+{
+        int loops = 1000;
+
+        while (ioread8(port + DSP_PORT_STATUS) & 0x80) {
+                if (!loops--)
+                        return -EIO;
+                cpu_relax();
+        }
+        iowrite8(cmd, port + DSP_PORT_COMMAND);
+        return 0;
+}
+
+static int __devinit dsp_get_version(void __iomem *port, u8 *major, u8 *minor)
+{
+        int err;
+
+        err = dsp_command(port, DSP_COMMAND_GET_VERSION);
+        if (err < 0)
+                return err;
+
+        err = dsp_get_byte(port, major);
+        if (err < 0)
+                return err;
+
+        err = dsp_get_byte(port, minor);
+        if (err < 0)
+                return err;
+
+        return 0;
+}
+
+/*
+ * Generic WSS support routines
+ */
+
+#define WSS_CONFIG_DMA_0        (1 << 0)
+#define WSS_CONFIG_DMA_1        (2 << 0)
+#define WSS_CONFIG_DMA_3        (3 << 0)
+#define WSS_CONFIG_DUPLEX       (1 << 2)
+#define WSS_CONFIG_IRQ_7        (1 << 3)
+#define WSS_CONFIG_IRQ_9        (2 << 3)
+#define WSS_CONFIG_IRQ_10       (3 << 3)
+#define WSS_CONFIG_IRQ_11       (4 << 3)
+
+#define WSS_PORT_CONFIG         0
+#define WSS_PORT_SIGNATURE      3
+
+#define WSS_SIGNATURE           4
+
+static int __devinit wss_detect(void __iomem *wss_port)
+{
+        if ((ioread8(wss_port + WSS_PORT_SIGNATURE) & 0x3f) != WSS_SIGNATURE)
+                return -ENODEV;
+
+        return 0;
+}
+
+static void wss_set_config(void __iomem *wss_port, u8 wss_config)
+{
+        iowrite8(wss_config, wss_port + WSS_PORT_CONFIG);
+}
+
+/*
+ * Aztech Sound Galaxy specifics
+ */
+
+#define GALAXY_PORT_CONFIG      1024
+#define CONFIG_PORT_SET         4
+
+#define DSP_COMMAND_GALAXY_8    8
+#define GALAXY_COMMAND_GET_TYPE 5
+
+#define DSP_COMMAND_GALAXY_9    9
+#define GALAXY_COMMAND_WSSMODE  0
+#define GALAXY_COMMAND_SB8MODE  1
+
+#define GALAXY_MODE_WSS         GALAXY_COMMAND_WSSMODE
+#define GALAXY_MODE_SB8         GALAXY_COMMAND_SB8MODE
+
+struct snd_galaxy {
+        void __iomem *port;
+        void __iomem *config_port;
+        void __iomem *wss_port;
+        u32 config;
+        struct resource *res_port;
+        struct resource *res_config_port;
+        struct resource *res_wss_port;
+};
+
+static u32 config[SNDRV_CARDS];
+static u8 wss_config[SNDRV_CARDS];
+
+static int __devinit snd_galaxy_match(struct device *dev, unsigned int n)
+{
+        if (!enable[n])
+                return 0;
+
+        switch (port[n]) {
+        case SNDRV_AUTO_PORT:
+                dev_err(dev, "please specify port\n");
+                return 0;
+        case 0x220:
+                config[n] |= GALAXY_CONFIG_SBA_220;
+                break;
+        case 0x240:
+                config[n] |= GALAXY_CONFIG_SBA_240;
+                break;
+        case 0x260:
+                config[n] |= GALAXY_CONFIG_SBA_260;
+                break;
+        case 0x280:
+                config[n] |= GALAXY_CONFIG_SBA_280;
+                break;
+        default:
+                dev_err(dev, "invalid port %#lx\n", port[n]);
+                return 0;
+        }
+
+        switch (wss_port[n]) {
+        case SNDRV_AUTO_PORT:
+                dev_err(dev,  "please specify wss_port\n");
+                return 0;
+        case 0x530:
+                config[n] |= GALAXY_CONFIG_WSS_ENABLE | GALAXY_CONFIG_WSSA_530;
+                break;
+        case 0x604:
+                config[n] |= GALAXY_CONFIG_WSS_ENABLE | GALAXY_CONFIG_WSSA_604;
+                break;
+        case 0xe80:
+                config[n] |= GALAXY_CONFIG_WSS_ENABLE | GALAXY_CONFIG_WSSA_E80;
+                break;
+        case 0xf40:
+                config[n] |= GALAXY_CONFIG_WSS_ENABLE | GALAXY_CONFIG_WSSA_F40;
+                break;
+        default:
+                dev_err(dev, "invalid WSS port %#lx\n", wss_port[n]);
+                return 0;
+        }
+
+        switch (irq[n]) {
+        case SNDRV_AUTO_IRQ:
+                dev_err(dev,  "please specify irq\n");
+                return 0;
+        case 7:
+                wss_config[n] |= WSS_CONFIG_IRQ_7;
+                break;
+        case 2:
+                irq[n] = 9;
+        case 9:
+                wss_config[n] |= WSS_CONFIG_IRQ_9;
+                break;
+        case 10:
+                wss_config[n] |= WSS_CONFIG_IRQ_10;
+                break;
+        case 11:
+                wss_config[n] |= WSS_CONFIG_IRQ_11;
+                break;
+        default:
+                dev_err(dev, "invalid IRQ %d\n", irq[n]);
+                return 0;
+        }
+
+        switch (dma1[n]) {
+        case SNDRV_AUTO_DMA:
+                dev_err(dev,  "please specify dma1\n");
+                return 0;
+        case 0:
+                wss_config[n] |= WSS_CONFIG_DMA_0;
+                break;
+        case 1:
+                wss_config[n] |= WSS_CONFIG_DMA_1;
+                break;
+        case 3:
+                wss_config[n] |= WSS_CONFIG_DMA_3;
+                break;
+        default:
+                dev_err(dev, "invalid playback DMA %d\n", dma1[n]);
+                return 0;
+        }
+
+        if (dma2[n] == SNDRV_AUTO_DMA || dma2[n] == dma1[n]) {
+                dma2[n] = -1;
+                goto mpu;
+        }
+
+        wss_config[n] |= WSS_CONFIG_DUPLEX;
+        switch (dma2[n]) {
+        case 0:
+                break;
+        case 1:
+                if (dma1[n] == 0)
+                        break;
+        default:
+                dev_err(dev, "invalid capture DMA %d\n", dma2[n]);
+                return 0;
+        }
+
+mpu:
+        switch (mpu_port[n]) {
+        case SNDRV_AUTO_PORT:
+                dev_warn(dev, "mpu_port not specified; not using MPU-401\n");
+                mpu_port[n] = -1;
+                goto fm;
+        case 0x300:
+                config[n] |= GALAXY_CONFIG_MPU_ENABLE | GALAXY_CONFIG_MPUA_300;
+                break;
+        case 0x330:
+                config[n] |= GALAXY_CONFIG_MPU_ENABLE | GALAXY_CONFIG_MPUA_330;
+                break;
+        default:
+                dev_err(dev, "invalid MPU port %#lx\n", mpu_port[n]);
+                return 0;
+        }
+
+        switch (mpu_irq[n]) {
+        case SNDRV_AUTO_IRQ:
+                dev_warn(dev, "mpu_irq not specified: using polling mode\n");
+                mpu_irq[n] = -1;
+                break;
+        case 2:
+                mpu_irq[n] = 9;
+        case 9:
+                config[n] |= GALAXY_CONFIG_MPUIRQ_2;
+                break;
+#ifdef AZT1605
+        case 3:
+                config[n] |= GALAXY_CONFIG_MPUIRQ_3;
+                break;
+#endif
+        case 5:
+                config[n] |= GALAXY_CONFIG_MPUIRQ_5;
+                break;
+        case 7:
+                config[n] |= GALAXY_CONFIG_MPUIRQ_7;
+                break;
+#ifdef AZT2316
+        case 10:
+                config[n] |= GALAXY_CONFIG_MPUIRQ_10;
+                break;
+#endif
+        default:
+                dev_err(dev, "invalid MPU IRQ %d\n", mpu_irq[n]);
+                return 0;
+        }
+
+        if (mpu_irq[n] == irq[n]) {
+                dev_err(dev, "cannot share IRQ between WSS and MPU-401\n");
+                return 0;
+        }
+
+fm:
+        switch (fm_port[n]) {
+        case SNDRV_AUTO_PORT:
+                dev_warn(dev, "fm_port not specified: not using OPL3\n");
+                fm_port[n] = -1;
+                break;
+        case 0x388:
+                break;
+        default:
+                dev_err(dev, "illegal FM port %#lx\n", fm_port[n]);
+                return 0;
+        }
+
+        config[n] |= GALAXY_CONFIG_GAME_ENABLE;
+        return 1;
+}
+
+static int __devinit galaxy_init(struct snd_galaxy *galaxy, u8 *type)
+{
+        u8 major;
+        u8 minor;
+        int err;
+
+        err = dsp_reset(galaxy->port);
+        if (err < 0)
+                return err;
+
+        err = dsp_get_version(galaxy->port, &major, &minor);
+        if (err < 0)
+                return err;
+
+        if (major != GALAXY_DSP_MAJOR || minor != GALAXY_DSP_MINOR)
+                return -ENODEV;
+
+        err = dsp_command(galaxy->port, DSP_COMMAND_GALAXY_8);
+        if (err < 0)
+                return err;
+
+        err = dsp_command(galaxy->port, GALAXY_COMMAND_GET_TYPE);
+        if (err < 0)
+                return err;
+
+        err = dsp_get_byte(galaxy->port, type);
+        if (err < 0)
+                return err;
+
+        return 0;
+}
+
+static int __devinit galaxy_set_mode(struct snd_galaxy *galaxy, u8 mode)
+{
+        int err;
+
+        err = dsp_command(galaxy->port, DSP_COMMAND_GALAXY_9);
+        if (err < 0)
+                return err;
+
+        err = dsp_command(galaxy->port, mode);
+        if (err < 0)
+                return err;
+
+#ifdef AZT1605
+        /*
+         * Needed for MPU IRQ on AZT1605, but AZT2316 loses WSS again
+         */
+        err = dsp_reset(galaxy->port);
+        if (err < 0)
+                return err;
+#endif
+
+        return 0;
+}
+
+static void galaxy_set_config(struct snd_galaxy *galaxy, u32 config)
+{
+        u8 tmp = ioread8(galaxy->config_port + CONFIG_PORT_SET);
+        int i;
+
+        iowrite8(tmp | 0x80, galaxy->config_port + CONFIG_PORT_SET);
+        for (i = 0; i < GALAXY_CONFIG_SIZE; i++) {
+                iowrite8(config, galaxy->config_port + i);
+                config >>= 8;
+        }
+        iowrite8(tmp & 0x7f, galaxy->config_port + CONFIG_PORT_SET);
+        msleep(10);
+}
+
+static void __devinit galaxy_config(struct snd_galaxy *galaxy, u32 config)
+{
+        int i;
+
+        for (i = GALAXY_CONFIG_SIZE; i; i--) {
+                u8 tmp = ioread8(galaxy->config_port + i - 1);
+                galaxy->config = (galaxy->config << 8) | tmp;
+        }
+        config |= galaxy->config & GALAXY_CONFIG_MASK;
+        galaxy_set_config(galaxy, config);
+}
+
+static int __devinit galaxy_wss_config(struct snd_galaxy *galaxy, u8 wss_config)
+{
+        int err;
+
+        err = wss_detect(galaxy->wss_port);
+        if (err < 0)
+                return err;
+
+        wss_set_config(galaxy->wss_port, wss_config);
+
+        err = galaxy_set_mode(galaxy, GALAXY_MODE_WSS);
+        if (err < 0)
+                return err;
+
+        return 0;
+}
+
+static void snd_galaxy_free(struct snd_card *card)
+{
+        struct snd_galaxy *galaxy = card->private_data;
+
+        if (galaxy->wss_port) {
+                wss_set_config(galaxy->wss_port, 0);
+                ioport_unmap(galaxy->wss_port);
+                release_and_free_resource(galaxy->res_wss_port);
+        }
+        if (galaxy->config_port) {
+                galaxy_set_config(galaxy, galaxy->config);
+                ioport_unmap(galaxy->config_port);
+                release_and_free_resource(galaxy->res_config_port);
+        }
+        if (galaxy->port) {
+                ioport_unmap(galaxy->port);
+                release_and_free_resource(galaxy->res_port);
+        }
+}
+
+static int __devinit snd_galaxy_probe(struct device *dev, unsigned int n)
+{
+        struct snd_galaxy *galaxy;
+        struct snd_wss *chip;
+        struct snd_card *card;
+        u8 type;
+        int err;
+
+        err = snd_card_create(index[n], id[n], THIS_MODULE, sizeof *galaxy,
+                              &card);
+        if (err < 0)
+                return err;
+
+        snd_card_set_dev(card, dev);
+
+        card->private_free = snd_galaxy_free;
+        galaxy = card->private_data;
+
+        galaxy->res_port = request_region(port[n], 16, DRV_NAME);
+        if (!galaxy->res_port) {
+                dev_err(dev, "could not grab ports %#lx-%#lx\n", port[n],
+                        port[n] + 15);
+                err = -EBUSY;
+                goto error;
+        }
+        galaxy->port = ioport_map(port[n], 16);
+
+        err = galaxy_init(galaxy, &type);
+        if (err < 0) {
+                dev_err(dev, "did not find a Sound Galaxy at %#lx\n", port[n]);
+                goto error;
+        }
+        dev_info(dev, "Sound Galaxy (type %d) found at %#lx\n", type, port[n]);
+
+        galaxy->res_config_port = request_region(port[n] + GALAXY_PORT_CONFIG,
+                                                 16, DRV_NAME);
+        if (!galaxy->res_config_port) {
+                dev_err(dev, "could not grab ports %#lx-%#lx\n",
+                        port[n] + GALAXY_PORT_CONFIG,
+                        port[n] + GALAXY_PORT_CONFIG + 15);
+                err = -EBUSY;
+                goto error;
+        }
+        galaxy->config_port = ioport_map(port[n] + GALAXY_PORT_CONFIG, 16);
+
+        galaxy_config(galaxy, config[n]);
+
+        galaxy->res_wss_port = request_region(wss_port[n], 4, DRV_NAME);
+        if (!galaxy->res_wss_port)  {
+                dev_err(dev, "could not grab ports %#lx-%#lx\n", wss_port[n],
+                        wss_port[n] + 3);
+                err = -EBUSY;
+                goto error;
+        }
+        galaxy->wss_port = ioport_map(wss_port[n], 4);
+
+        err = galaxy_wss_config(galaxy, wss_config[n]);
+        if (err < 0) {
+                dev_err(dev, "could not configure WSS\n");
+                goto error;
+        }
+
+        strcpy(card->driver, DRV_NAME);
+        strcpy(card->shortname, DRV_NAME);
+        sprintf(card->longname, "%s at %#lx/%#lx, irq %d, dma %d/%d",
+                card->shortname, port[n], wss_port[n], irq[n], dma1[n],
+                dma2[n]);
+
+        err = snd_wss_create(card, wss_port[n] + 4, -1, irq[n], dma1[n],
+                             dma2[n], WSS_HW_DETECT, 0, &chip);
+        if (err < 0)
+                goto error;
+
+        err = snd_wss_pcm(chip, 0, NULL);
+        if (err < 0)
+                goto error;
+
+        err = snd_wss_mixer(chip);
+        if (err < 0)
+                goto error;
+
+        err = snd_wss_timer(chip, 0, NULL);
+        if (err < 0)
+                goto error;
+
+        if (mpu_port[n] >= 0) {
+                err = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
+                                          mpu_port[n], 0, mpu_irq[n],
+                                          IRQF_DISABLED, NULL);
+                if (err < 0)
+                        goto error;
+        }
+
+        if (fm_port[n] >= 0) {
+                struct snd_opl3 *opl3;
+
+                err = snd_opl3_create(card, fm_port[n], fm_port[n] + 2,
+                                      OPL3_HW_AUTO, 0, &opl3);
+                if (err < 0) {
+                        dev_err(dev, "no OPL device at %#lx\n", fm_port[n]);
+                        goto error;
+                }
+                err = snd_opl3_timer_new(opl3, 1, 2);
+                if (err < 0)
+                        goto error;
+
+                err = snd_opl3_hwdep_new(opl3, 0, 1, NULL);
+                if (err < 0)
+                        goto error;
+        }
+
+        err = snd_card_register(card);
+        if (err < 0)
+                goto error;
+
+        dev_set_drvdata(dev, card);
+        return 0;
+
+error:
+        snd_card_free(card);
+        return err;
+}
+
+static int __devexit snd_galaxy_remove(struct device *dev, unsigned int n)
+{
+        snd_card_free(dev_get_drvdata(dev));
+        dev_set_drvdata(dev, NULL);
+        return 0;
+}
+
+static struct isa_driver snd_galaxy_driver = {
+        .match          = snd_galaxy_match,
+        .probe          = snd_galaxy_probe,
+        .remove         = __devexit_p(snd_galaxy_remove),
+
+        .driver         = {
+                .name   = DEV_NAME
+        }
+};
+
+static int __init alsa_card_galaxy_init(void)
+{
+        return isa_register_driver(&snd_galaxy_driver, SNDRV_CARDS);
+}
+
+static void __exit alsa_card_galaxy_exit(void)
+{
+        isa_unregister_driver(&snd_galaxy_driver);
+}
+
+module_init(alsa_card_galaxy_init);
+module_exit(alsa_card_galaxy_exit);
diff --git a/sound/isa/gus/gusmax.c b/sound/isa/gus/gusmax.c
index f26eac8d8110..3e4a58b72913 100644
--- a/sound/isa/gus/gusmax.c
+++ b/sound/isa/gus/gusmax.c
@@ -191,7 +191,7 @@ static int __devinit snd_gusmax_mixer(struct snd_wss *chip)
 
 static void snd_gusmax_free(struct snd_card *card)
 {
-        struct snd_gusmax *maxcard = (struct snd_gusmax *)card->private_data;
+        struct snd_gusmax *maxcard = card->private_data;
         
         if (maxcard == NULL)
                 return;
@@ -219,7 +219,7 @@ static int __devinit snd_gusmax_probe(struct device *pdev, unsigned int dev)
         if (err < 0)
                 return err;
         card->private_free = snd_gusmax_free;
-        maxcard = (struct snd_gusmax *)card->private_data;
+        maxcard = card->private_data;
         maxcard->card = card;
         maxcard->irq = -1;
         
diff --git a/sound/isa/msnd/msnd_pinnacle.c b/sound/isa/msnd/msnd_pinnacle.c
index 60b6abd71612..91d6023a63e5 100644
--- a/sound/isa/msnd/msnd_pinnacle.c
+++ b/sound/isa/msnd/msnd_pinnacle.c
@@ -549,7 +549,10 @@ static int __devinit snd_msnd_attach(struct snd_card *card)
                 printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", chip->irq);
                 return err;
         }
-        request_region(chip->io, DSP_NUMIO, card->shortname);
+        if (request_region(chip->io, DSP_NUMIO, card->shortname) == NULL) {
+                free_irq(chip->irq, chip);
+                return -EBUSY;
+        }
 
         if (!request_mem_region(chip->base, BUFFSIZE, card->shortname)) {
                 printk(KERN_ERR LOGNAME
@@ -761,9 +764,9 @@ static long io[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
 static long mem[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 
+#ifndef MSND_CLASSIC
 static long cfg[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 
-#ifndef MSND_CLASSIC
 /* Extra Peripheral Configuration (Default: Disable) */
 static long ide_io0[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
 static long ide_io1[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
@@ -891,7 +894,11 @@ static int __devinit snd_msnd_isa_probe(struct device *pdev, unsigned int idx)
         struct snd_card *card;
         struct snd_msnd *chip;
 
-        if (has_isapnp(idx) || cfg[idx] == SNDRV_AUTO_PORT) {
+        if (has_isapnp(idx)
+#ifndef MSND_CLASSIC
+            || cfg[idx] == SNDRV_AUTO_PORT
+#endif
+            ) {
                 printk(KERN_INFO LOGNAME ": Assuming PnP mode\n");
                 return -ENODEV;
         }
diff --git a/sound/isa/sb/emu8000_pcm.c b/sound/isa/sb/emu8000_pcm.c
index ccedbfed061a..2f85c66f8e38 100644
--- a/sound/isa/sb/emu8000_pcm.c
+++ b/sound/isa/sb/emu8000_pcm.c
@@ -433,7 +433,8 @@ static int emu8k_transfer_block(struct snd_emu8000 *emu, int offset, unsigned sh
         while (count > 0) {
                 unsigned short sval;
                 CHECK_SCHEDULER();
-                get_user(sval, buf);
+                if (get_user(sval, buf))
+                        return -EFAULT;
                 EMU8000_SMLD_WRITE(emu, sval);
                 buf++;
                 count--;
@@ -525,12 +526,14 @@ static int emu8k_pcm_copy(struct snd_pcm_substream *subs,
         while (count-- > 0) {
                 unsigned short sval;
                 CHECK_SCHEDULER();
-                get_user(sval, buf);
+                if (get_user(sval, buf))
+                        return -EFAULT;
                 EMU8000_SMLD_WRITE(emu, sval);
                 buf++;
                 if (rec->voices > 1) {
                         CHECK_SCHEDULER();
-                        get_user(sval, buf);
+                        if (get_user(sval, buf))
+                                return -EFAULT;
                         EMU8000_SMRD_WRITE(emu, sval);
                         buf++;
                 }
diff --git a/sound/isa/sb/sb8.c b/sound/isa/sb/sb8.c
index 81284a8fa0ce..2259e3f726a7 100644
--- a/sound/isa/sb/sb8.c
+++ b/sound/isa/sb/sb8.c
@@ -72,7 +72,7 @@ static irqreturn_t snd_sb8_interrupt(int irq, void *dev_id)
 
 static void snd_sb8_free(struct snd_card *card)
 {
-        struct snd_sb8 *acard = (struct snd_sb8 *)card->private_data;
+        struct snd_sb8 *acard = card->private_data;
 
         if (acard == NULL)
                 return;
diff --git a/sound/isa/sgalaxy.c b/sound/isa/sgalaxy.c
deleted file mode 100644
index 6fe27b9d9440..000000000000
--- a/sound/isa/sgalaxy.c
+++ /dev/null
@@ -1,369 +0,0 @@
-/*
- *  Driver for Aztech Sound Galaxy cards
- *  Copyright (c) by Christopher Butler <chrisb@sandy.force9.co.uk.
- *
- *  I don't have documentation for this card, I based this driver on the
- *  driver for OSS/Free included in the kernel source (drivers/sound/sgalaxy.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; 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/init.h>
-#include <linux/err.h>
-#include <linux/isa.h>
-#include <linux/delay.h>
-#include <linux/time.h>
-#include <linux/interrupt.h>
-#include <linux/moduleparam.h>
-#include <asm/dma.h>
-#include <sound/core.h>
-#include <sound/sb.h>
-#include <sound/wss.h>
-#include <sound/control.h>
-#define SNDRV_LEGACY_FIND_FREE_IRQ
-#define SNDRV_LEGACY_FIND_FREE_DMA
-#include <sound/initval.h>
-
-MODULE_AUTHOR("Christopher Butler <chrisb@sandy.force9.co.uk>");
-MODULE_DESCRIPTION("Aztech Sound Galaxy");
-MODULE_LICENSE("GPL");
-MODULE_SUPPORTED_DEVICE("{{Aztech Systems,Sound Galaxy}}");
-
-static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
-static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
-static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;  /* Enable this card */
-static long sbport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;   /* 0x220,0x240 */
-static long wssport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;  /* 0x530,0xe80,0xf40,0x604 */
-static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;        /* 7,9,10,11 */
-static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;       /* 0,1,3 */
-
-module_param_array(index, int, NULL, 0444);
-MODULE_PARM_DESC(index, "Index value for Sound Galaxy soundcard.");
-module_param_array(id, charp, NULL, 0444);
-MODULE_PARM_DESC(id, "ID string for Sound Galaxy soundcard.");
-module_param_array(sbport, long, NULL, 0444);
-MODULE_PARM_DESC(sbport, "Port # for Sound Galaxy SB driver.");
-module_param_array(wssport, long, NULL, 0444);
-MODULE_PARM_DESC(wssport, "Port # for Sound Galaxy WSS driver.");
-module_param_array(irq, int, NULL, 0444);
-MODULE_PARM_DESC(irq, "IRQ # for Sound Galaxy driver.");
-module_param_array(dma1, int, NULL, 0444);
-MODULE_PARM_DESC(dma1, "DMA1 # for Sound Galaxy driver.");
-
-#define SGALAXY_AUXC_LEFT 18
-#define SGALAXY_AUXC_RIGHT 19
-
-#define PFX     "sgalaxy: "
-
-/*
-
- */
-
-#define AD1848P1( port, x ) ( port + c_d_c_AD1848##x )
-
-/* from lowlevel/sb/sb.c - to avoid having to allocate a struct snd_sb for the */
-/* short time we actually need it.. */
-
-static int snd_sgalaxy_sbdsp_reset(unsigned long port)
-{
-        int i;
-
-        outb(1, SBP1(port, RESET));
-        udelay(10);
-        outb(0, SBP1(port, RESET));
-        udelay(30);
-        for (i = 0; i < 1000 && !(inb(SBP1(port, DATA_AVAIL)) & 0x80); i++);
-        if (inb(SBP1(port, READ)) != 0xaa) {
-                snd_printd("sb_reset: failed at 0x%lx!!!\n", port);
-                return -ENODEV;
-        }
-        return 0;
-}
-
-static int __devinit snd_sgalaxy_sbdsp_command(unsigned long port,
-                                               unsigned char val)
-{
-        int i;
-        
-        for (i = 10000; i; i--)
-                if ((inb(SBP1(port, STATUS)) & 0x80) == 0) {
-                        outb(val, SBP1(port, COMMAND));
-                        return 1;
-                }
-
-        return 0;
-}
-
-static irqreturn_t snd_sgalaxy_dummy_interrupt(int irq, void *dev_id)
-{
-        return IRQ_NONE;
-}
-
-static int __devinit snd_sgalaxy_setup_wss(unsigned long port, int irq, int dma)
-{
-        static int interrupt_bits[] = {-1, -1, -1, -1, -1, -1, -1, 0x08, -1, 
-                                       0x10, 0x18, 0x20, -1, -1, -1, -1};
-        static int dma_bits[] = {1, 2, 0, 3};
-        int tmp, tmp1;
-
-        if ((tmp = inb(port + 3)) == 0xff)
-        {
-                snd_printdd("I/O address dead (0x%lx)\n", port);
-                return 0;
-        }
-#if 0
-        snd_printdd("WSS signature = 0x%x\n", tmp);
-#endif
-
-        if ((tmp & 0x3f) != 0x04 &&
-            (tmp & 0x3f) != 0x0f &&
-            (tmp & 0x3f) != 0x00) {
-                snd_printdd("No WSS signature detected on port 0x%lx\n",
-                            port + 3);
-                return 0;
-        }
-
-#if 0
-        snd_printdd(PFX "setting up IRQ/DMA for WSS\n");
-#endif
-
-        /* initialize IRQ for WSS codec */
-        tmp = interrupt_bits[irq % 16];
-        if (tmp < 0)
-                return -EINVAL;
-
-        if (request_irq(irq, snd_sgalaxy_dummy_interrupt, IRQF_DISABLED, "sgalaxy", NULL)) {
-                snd_printk(KERN_ERR "sgalaxy: can't grab irq %d\n", irq);
-                return -EIO;
-        }
-
-        outb(tmp | 0x40, port);
-        tmp1 = dma_bits[dma % 4];
-        outb(tmp | tmp1, port);
-
-        free_irq(irq, NULL);
-
-        return 0;
-}
-
-static int __devinit snd_sgalaxy_detect(int dev, int irq, int dma)
-{
-#if 0
-        snd_printdd(PFX "switching to WSS mode\n");
-#endif
-
-        /* switch to WSS mode */
-        snd_sgalaxy_sbdsp_reset(sbport[dev]);
-
-        snd_sgalaxy_sbdsp_command(sbport[dev], 9);
-        snd_sgalaxy_sbdsp_command(sbport[dev], 0);
-
-        udelay(400);
-        return snd_sgalaxy_setup_wss(wssport[dev], irq, dma);
-}
-
-static struct snd_kcontrol_new snd_sgalaxy_controls[] = {
-WSS_DOUBLE("Aux Playback Switch", 0,
-                SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 7, 7, 1, 1),
-WSS_DOUBLE("Aux Playback Volume", 0,
-                SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 0, 0, 31, 0)
-};
-
-static int __devinit snd_sgalaxy_mixer(struct snd_wss *chip)
-{
-        struct snd_card *card = chip->card;
-        struct snd_ctl_elem_id id1, id2;
-        unsigned int idx;
-        int err;
-
-        memset(&id1, 0, sizeof(id1));
-        memset(&id2, 0, sizeof(id2));
-        id1.iface = id2.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-        /* reassign AUX0 to LINE */
-        strcpy(id1.name, "Aux Playback Switch");
-        strcpy(id2.name, "Line Playback Switch");
-        if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0)
-                return err;
-        strcpy(id1.name, "Aux Playback Volume");
-        strcpy(id2.name, "Line Playback Volume");
-        if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0)
-                return err;
-        /* reassign AUX1 to FM */
-        strcpy(id1.name, "Aux Playback Switch"); id1.index = 1;
-        strcpy(id2.name, "FM Playback Switch");
-        if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0)
-                return err;
-        strcpy(id1.name, "Aux Playback Volume");
-        strcpy(id2.name, "FM Playback Volume");
-        if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0)
-                return err;
-        /* build AUX2 input */
-        for (idx = 0; idx < ARRAY_SIZE(snd_sgalaxy_controls); idx++) {
-                err = snd_ctl_add(card,
-                                snd_ctl_new1(&snd_sgalaxy_controls[idx], chip));
-                if (err < 0)
-                        return err;
-        }
-        return 0;
-}
-
-static int __devinit snd_sgalaxy_match(struct device *devptr, unsigned int dev)
-{
-        if (!enable[dev])
-                return 0;
-        if (sbport[dev] == SNDRV_AUTO_PORT) {
-                snd_printk(KERN_ERR PFX "specify SB port\n");
-                return 0;
-        }
-        if (wssport[dev] == SNDRV_AUTO_PORT) {
-                snd_printk(KERN_ERR PFX "specify WSS port\n");
-                return 0;
-        }
-        return 1;
-}
-
-static int __devinit snd_sgalaxy_probe(struct device *devptr, unsigned int dev)
-{
-        static int possible_irqs[] = {7, 9, 10, 11, -1};
-        static int possible_dmas[] = {1, 3, 0, -1};
-        int err, xirq, xdma1;
-        struct snd_card *card;
-        struct snd_wss *chip;
-
-        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
-        if (err < 0)
-                return err;
-
-        xirq = irq[dev];
-        if (xirq == SNDRV_AUTO_IRQ) {
-                if ((xirq = snd_legacy_find_free_irq(possible_irqs)) < 0) {
-                        snd_printk(KERN_ERR PFX "unable to find a free IRQ\n");
-                        err = -EBUSY;
-                        goto _err;
-                }
-        }
-        xdma1 = dma1[dev];
-        if (xdma1 == SNDRV_AUTO_DMA) {
-                if ((xdma1 = snd_legacy_find_free_dma(possible_dmas)) < 0) {
-                        snd_printk(KERN_ERR PFX "unable to find a free DMA\n");
-                        err = -EBUSY;
-                        goto _err;
-                }
-        }
-
-        if ((err = snd_sgalaxy_detect(dev, xirq, xdma1)) < 0)
-                goto _err;
-
-        err = snd_wss_create(card, wssport[dev] + 4, -1,
-                             xirq, xdma1, -1,
-                             WSS_HW_DETECT, 0, &chip);
-        if (err < 0)
-                goto _err;
-        card->private_data = chip;
-
-        err = snd_wss_pcm(chip, 0, NULL);
-        if (err < 0) {
-                snd_printdd(PFX "error creating new WSS PCM device\n");
-                goto _err;
-        }
-        err = snd_wss_mixer(chip);
-        if (err < 0) {
-                snd_printdd(PFX "error creating new WSS mixer\n");
-                goto _err;
-        }
-        if ((err = snd_sgalaxy_mixer(chip)) < 0) {
-                snd_printdd(PFX "the mixer rewrite failed\n");
-                goto _err;
-        }
-
-        strcpy(card->driver, "Sound Galaxy");
-        strcpy(card->shortname, "Sound Galaxy");
-        sprintf(card->longname, "Sound Galaxy at 0x%lx, irq %d, dma %d",
-                wssport[dev], xirq, xdma1);
-
-        snd_card_set_dev(card, devptr);
-
-        if ((err = snd_card_register(card)) < 0)
-                goto _err;
-
-        dev_set_drvdata(devptr, card);
-        return 0;
-
- _err:
-        snd_card_free(card);
-        return err;
-}
-
-static int __devexit snd_sgalaxy_remove(struct device *devptr, unsigned int dev)
-{
-        snd_card_free(dev_get_drvdata(devptr));
-        dev_set_drvdata(devptr, NULL);
-        return 0;
-}
-
-#ifdef CONFIG_PM
-static int snd_sgalaxy_suspend(struct device *pdev, unsigned int n,
-                               pm_message_t state)
-{
-        struct snd_card *card = dev_get_drvdata(pdev);
-        struct snd_wss *chip = card->private_data;
-
-        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        chip->suspend(chip);
-        return 0;
-}
-
-static int snd_sgalaxy_resume(struct device *pdev, unsigned int n)
-{
-        struct snd_card *card = dev_get_drvdata(pdev);
-        struct snd_wss *chip = card->private_data;
-
-        chip->resume(chip);
-        snd_wss_out(chip, SGALAXY_AUXC_LEFT, chip->image[SGALAXY_AUXC_LEFT]);
-        snd_wss_out(chip, SGALAXY_AUXC_RIGHT, chip->image[SGALAXY_AUXC_RIGHT]);
-
-        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
-        return 0;
-}
-#endif
-
-#define DEV_NAME "sgalaxy"
-
-static struct isa_driver snd_sgalaxy_driver = {
-        .match          = snd_sgalaxy_match,
-        .probe          = snd_sgalaxy_probe,
-        .remove         = __devexit_p(snd_sgalaxy_remove),
-#ifdef CONFIG_PM
-        .suspend        = snd_sgalaxy_suspend,
-        .resume         = snd_sgalaxy_resume,
-#endif
-        .driver         = {
-                .name   = DEV_NAME
-        },
-};
-
-static int __init alsa_card_sgalaxy_init(void)
-{
-        return isa_register_driver(&snd_sgalaxy_driver, SNDRV_CARDS);
-}
-
-static void __exit alsa_card_sgalaxy_exit(void)
-{
-        isa_unregister_driver(&snd_sgalaxy_driver);
-}
-
-module_init(alsa_card_sgalaxy_init)
-module_exit(alsa_card_sgalaxy_exit)
diff --git a/sound/oss/Kconfig b/sound/oss/Kconfig
index a513651fa149..76c090218073 100644
--- a/sound/oss/Kconfig
+++ b/sound/oss/Kconfig
@@ -545,11 +545,3 @@ config SOUND_KAHLUA
 
 endif   # SOUND_OSS
 
-config SOUND_SH_DAC_AUDIO
-        tristate "SuperH DAC audio support"
-        depends on CPU_SH3 && HIGH_RES_TIMERS
-
-config SOUND_SH_DAC_AUDIO_CHANNEL
-        int "DAC channel"
-        default "1"
-        depends on SOUND_SH_DAC_AUDIO
diff --git a/sound/oss/Makefile b/sound/oss/Makefile
index 567b8a74178a..96f14dcd0cd1 100644
--- a/sound/oss/Makefile
+++ b/sound/oss/Makefile
@@ -9,7 +9,6 @@ obj-$(CONFIG_SOUND_OSS)		+= sound.o
 
 # Please leave it as is, cause the link order is significant !
 
-obj-$(CONFIG_SOUND_SH_DAC_AUDIO)        += sh_dac_audio.o
 obj-$(CONFIG_SOUND_AEDSP16)     += aedsp16.o
 obj-$(CONFIG_SOUND_PSS)         += pss.o ad1848.o mpu401.o
 obj-$(CONFIG_SOUND_TRIX)        += trix.o ad1848.o sb_lib.o uart401.o
diff --git a/sound/oss/ad1848.c b/sound/oss/ad1848.c
index 24793c5b65ac..4d2a6ae978f7 100644
--- a/sound/oss/ad1848.c
+++ b/sound/oss/ad1848.c
@@ -716,7 +716,7 @@ static int ad1848_mixer_ioctl(int dev, unsigned int cmd, void __user *arg)
                                 
                                 default:
                                         if (get_user(val, (int __user *)arg))
-                                        return -EFAULT;
+                                                return -EFAULT;
                                         val = ad1848_mixer_set(devc, cmd & 0xff, val);
                                         break;
                         } 
diff --git a/sound/oss/au1550_ac97.c b/sound/oss/au1550_ac97.c
index c1070e33b32f..a8f626d99c5b 100644
--- a/sound/oss/au1550_ac97.c
+++ b/sound/oss/au1550_ac97.c
@@ -49,7 +49,6 @@
 #include <linux/poll.h>
 #include <linux/bitops.h>
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
 #include <linux/ac97_codec.h>
 #include <linux/mutex.h>
 
@@ -77,6 +76,7 @@
 /* Boot options
  * 0 = no VRA, 1 = use VRA if codec supports it
  */
+static DEFINE_MUTEX(au1550_ac97_mutex);
 static int      vra = 1;
 module_param(vra, bool, 0);
 MODULE_PARM_DESC(vra, "if 1 use VRA if codec supports it");
@@ -162,25 +162,16 @@ ld2(unsigned int x)
 static void
 au1550_delay(int msec)
 {
-        unsigned long   tmo;
-        signed long     tmo2;
-
         if (in_interrupt())
                 return;
 
-        tmo = jiffies + (msec * HZ) / 1000;
-        for (;;) {
-                tmo2 = tmo - jiffies;
-                if (tmo2 <= 0)
-                        break;
-                schedule_timeout(tmo2);
-        }
+        schedule_timeout_uninterruptible(msecs_to_jiffies(msec));
 }
 
 static u16
 rdcodec(struct ac97_codec *codec, u8 addr)
 {
-        struct au1550_state *s = (struct au1550_state *)codec->private_data;
+        struct au1550_state *s = codec->private_data;
         unsigned long   flags;
         u32             cmd, val;
         u16             data;
@@ -248,7 +239,7 @@ rdcodec(struct ac97_codec *codec, u8 addr)
 static void
 wrcodec(struct ac97_codec *codec, u8 addr, u16 data)
 {
-        struct au1550_state *s = (struct au1550_state *)codec->private_data;
+        struct au1550_state *s = codec->private_data;
         unsigned long   flags;
         u32             cmd, val;
         int             i;
@@ -807,7 +798,9 @@ au1550_llseek(struct file *file, loff_t offset, int origin)
 static int
 au1550_open_mixdev(struct inode *inode, struct file *file)
 {
+        mutex_lock(&au1550_ac97_mutex);
         file->private_data = &au1550_state;
+        mutex_unlock(&au1550_ac97_mutex);
         return 0;
 }
 
@@ -824,22 +817,26 @@ mixdev_ioctl(struct ac97_codec *codec, unsigned int cmd,
         return codec->mixer_ioctl(codec, cmd, arg);
 }
 
-static int
-au1550_ioctl_mixdev(struct inode *inode, struct file *file,
-                               unsigned int cmd, unsigned long arg)
+static long
+au1550_ioctl_mixdev(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct au1550_state *s = (struct au1550_state *)file->private_data;
+        struct au1550_state *s = file->private_data;
         struct ac97_codec *codec = s->codec;
+        int ret;
+
+        mutex_lock(&au1550_ac97_mutex);
+        ret = mixdev_ioctl(codec, cmd, arg);
+        mutex_unlock(&au1550_ac97_mutex);
 
-        return mixdev_ioctl(codec, cmd, arg);
+        return ret;
 }
 
 static /*const */ struct file_operations au1550_mixer_fops = {
-        owner:THIS_MODULE,
-        llseek:au1550_llseek,
-        ioctl:au1550_ioctl_mixdev,
-        open:au1550_open_mixdev,
-        release:au1550_release_mixdev,
+        .owner          = THIS_MODULE,
+        .llseek         = au1550_llseek,
+        .unlocked_ioctl = au1550_ioctl_mixdev,
+        .open           = au1550_open_mixdev,
+        .release        = au1550_release_mixdev,
 };
 
 static int
@@ -1034,7 +1031,7 @@ copy_dmabuf_user(struct dmabuf *db, char* userbuf, int count, int to_user)
 static ssize_t
 au1550_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
 {
-        struct au1550_state *s = (struct au1550_state *)file->private_data;
+        struct au1550_state *s = file->private_data;
         struct dmabuf  *db = &s->dma_adc;
         DECLARE_WAITQUEUE(wait, current);
         ssize_t         ret;
@@ -1114,7 +1111,7 @@ out2:
 static ssize_t
 au1550_write(struct file *file, const char *buffer, size_t count, loff_t * ppos)
 {
-        struct au1550_state *s = (struct au1550_state *)file->private_data;
+        struct au1550_state *s = file->private_data;
         struct dmabuf  *db = &s->dma_dac;
         DECLARE_WAITQUEUE(wait, current);
         ssize_t         ret = 0;
@@ -1214,7 +1211,7 @@ out2:
 static unsigned int
 au1550_poll(struct file *file, struct poll_table_struct *wait)
 {
-        struct au1550_state *s = (struct au1550_state *)file->private_data;
+        struct au1550_state *s = file->private_data;
         unsigned long   flags;
         unsigned int    mask = 0;
 
@@ -1253,12 +1250,12 @@ au1550_poll(struct file *file, struct poll_table_struct *wait)
 static int
 au1550_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct au1550_state *s = (struct au1550_state *)file->private_data;
+        struct au1550_state *s = file->private_data;
         struct dmabuf  *db;
         unsigned long   size;
         int ret = 0;
 
-        lock_kernel();
+        mutex_lock(&au1550_ac97_mutex);
         mutex_lock(&s->sem);
         if (vma->vm_flags & VM_WRITE)
                 db = &s->dma_dac;
@@ -1286,7 +1283,7 @@ au1550_mmap(struct file *file, struct vm_area_struct *vma)
         db->mapped = 1;
 out:
         mutex_unlock(&s->sem);
-        unlock_kernel();
+        mutex_unlock(&au1550_ac97_mutex);
         return ret;
 }
 
@@ -1343,10 +1340,9 @@ dma_count_done(struct dmabuf *db)
 
 
 static int
-au1550_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                                                        unsigned long arg)
+au1550_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct au1550_state *s = (struct au1550_state *)file->private_data;
+        struct au1550_state *s = file->private_data;
         unsigned long   flags;
         audio_buf_info  abinfo;
         count_info      cinfo;
@@ -1780,6 +1776,17 @@ au1550_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         return mixdev_ioctl(s->codec, cmd, arg);
 }
 
+static long
+au1550_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        int ret;
+
+        mutex_lock(&au1550_ac97_mutex);
+        ret = au1550_ioctl(file, cmd, arg);
+        mutex_unlock(&au1550_ac97_mutex);
+
+        return ret;
+}
 
 static int
 au1550_open(struct inode *inode, struct file *file)
@@ -1797,21 +1804,22 @@ au1550_open(struct inode *inode, struct file *file)
 #endif
 
         file->private_data = s;
+        mutex_lock(&au1550_ac97_mutex);
         /* wait for device to become free */
         mutex_lock(&s->open_mutex);
         while (s->open_mode & file->f_mode) {
-                if (file->f_flags & O_NONBLOCK) {
-                        mutex_unlock(&s->open_mutex);
-                        return -EBUSY;
-                }
+                ret = -EBUSY;
+                if (file->f_flags & O_NONBLOCK)
+                        goto out;
                 add_wait_queue(&s->open_wait, &wait);
                 __set_current_state(TASK_INTERRUPTIBLE);
                 mutex_unlock(&s->open_mutex);
                 schedule();
                 remove_wait_queue(&s->open_wait, &wait);
                 set_current_state(TASK_RUNNING);
+                ret = -ERESTARTSYS;
                 if (signal_pending(current))
-                        return -ERESTARTSYS;
+                        goto out2;
                 mutex_lock(&s->open_mutex);
         }
 
@@ -1840,30 +1848,34 @@ au1550_open(struct inode *inode, struct file *file)
 
         if (file->f_mode & FMODE_READ) {
                 if ((ret = prog_dmabuf_adc(s)))
-                        return ret;
+                        goto out;
         }
         if (file->f_mode & FMODE_WRITE) {
                 if ((ret = prog_dmabuf_dac(s)))
-                        return ret;
+                        goto out;
         }
 
         s->open_mode |= file->f_mode & (FMODE_READ | FMODE_WRITE);
-        mutex_unlock(&s->open_mutex);
         mutex_init(&s->sem);
-        return 0;
+        ret = 0;
+out:
+        mutex_unlock(&s->open_mutex);
+out2:
+        mutex_unlock(&au1550_ac97_mutex);
+        return ret;
 }
 
 static int
 au1550_release(struct inode *inode, struct file *file)
 {
-        struct au1550_state *s = (struct au1550_state *)file->private_data;
+        struct au1550_state *s = file->private_data;
 
-        lock_kernel();
+        mutex_lock(&au1550_ac97_mutex);
 
         if (file->f_mode & FMODE_WRITE) {
-                unlock_kernel();
+                mutex_unlock(&au1550_ac97_mutex);
                 drain_dac(s, file->f_flags & O_NONBLOCK);
-                lock_kernel();
+                mutex_lock(&au1550_ac97_mutex);
         }
 
         mutex_lock(&s->open_mutex);
@@ -1880,20 +1892,20 @@ au1550_release(struct inode *inode, struct file *file)
         s->open_mode &= ((~file->f_mode) & (FMODE_READ|FMODE_WRITE));
         mutex_unlock(&s->open_mutex);
         wake_up(&s->open_wait);
-        unlock_kernel();
+        mutex_unlock(&au1550_ac97_mutex);
         return 0;
 }
 
 static /*const */ struct file_operations au1550_audio_fops = {
-        owner:          THIS_MODULE,
-        llseek:         au1550_llseek,
-        read:           au1550_read,
-        write:          au1550_write,
-        poll:           au1550_poll,
-        ioctl:          au1550_ioctl,
-        mmap:           au1550_mmap,
-        open:           au1550_open,
-        release:        au1550_release,
+        .owner          = THIS_MODULE,
+        .llseek         = au1550_llseek,
+        .read           = au1550_read,
+        .write          = au1550_write,
+        .poll           = au1550_poll,
+        .unlocked_ioctl = au1550_unlocked_ioctl,
+        .mmap           = au1550_mmap,
+        .open           = au1550_open,
+        .release        = au1550_release,
 };
 
 MODULE_AUTHOR("Advanced Micro Devices (AMD), dan@embeddededge.com");
diff --git a/sound/oss/dmasound/dmasound_core.c b/sound/oss/dmasound/dmasound_core.c
index 3f3c3f71db4b..87e2c72651f5 100644
--- a/sound/oss/dmasound/dmasound_core.c
+++ b/sound/oss/dmasound/dmasound_core.c
@@ -181,7 +181,7 @@
 #include <linux/init.h>
 #include <linux/soundcard.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
+#include <linux/mutex.h>
 
 #include <asm/uaccess.h>
 
@@ -194,6 +194,7 @@
      *  Declarations
      */
 
+static DEFINE_MUTEX(dmasound_core_mutex);
 int dmasound_catchRadius = 0;
 module_param(dmasound_catchRadius, int, 0);
 
@@ -323,22 +324,26 @@ static struct {
 
 static int mixer_open(struct inode *inode, struct file *file)
 {
-        if (!try_module_get(dmasound.mach.owner))
+        mutex_lock(&dmasound_core_mutex);
+        if (!try_module_get(dmasound.mach.owner)) {
+                mutex_unlock(&dmasound_core_mutex);
                 return -ENODEV;
+        }
         mixer.busy = 1;
+        mutex_unlock(&dmasound_core_mutex);
         return 0;
 }
 
 static int mixer_release(struct inode *inode, struct file *file)
 {
-        lock_kernel();
+        mutex_lock(&dmasound_core_mutex);
         mixer.busy = 0;
         module_put(dmasound.mach.owner);
-        unlock_kernel();
+        mutex_unlock(&dmasound_core_mutex);
         return 0;
 }
-static int mixer_ioctl(struct inode *inode, struct file *file, u_int cmd,
-                       u_long arg)
+
+static int mixer_ioctl(struct file *file, u_int cmd, u_long arg)
 {
         if (_SIOC_DIR(cmd) & _SIOC_WRITE)
             mixer.modify_counter++;
@@ -362,11 +367,22 @@ static int mixer_ioctl(struct inode *inode, struct file *file, u_int cmd,
         return -EINVAL;
 }
 
+static long mixer_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
+{
+        int ret;
+
+        mutex_lock(&dmasound_core_mutex);
+        ret = mixer_ioctl(file, cmd, arg);
+        mutex_unlock(&dmasound_core_mutex);
+
+        return ret;
+}
+
 static const struct file_operations mixer_fops =
 {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
-        .ioctl          = mixer_ioctl,
+        .unlocked_ioctl = mixer_unlocked_ioctl,
         .open           = mixer_open,
         .release        = mixer_release,
 };
@@ -737,8 +753,11 @@ static int sq_open(struct inode *inode, struct file *file)
 {
         int rc;
 
-        if (!try_module_get(dmasound.mach.owner))
+        mutex_lock(&dmasound_core_mutex);
+        if (!try_module_get(dmasound.mach.owner)) {
+                mutex_unlock(&dmasound_core_mutex);
                 return -ENODEV;
+        }
 
         rc = write_sq_open(file); /* checks the f_mode */
         if (rc)
@@ -781,10 +800,11 @@ static int sq_open(struct inode *inode, struct file *file)
                 sound_set_format(AFMT_MU_LAW);
         }
 #endif
-
+        mutex_unlock(&dmasound_core_mutex);
         return 0;
  out:
         module_put(dmasound.mach.owner);
+        mutex_unlock(&dmasound_core_mutex);
         return rc;
 }
 
@@ -850,7 +870,7 @@ static int sq_release(struct inode *inode, struct file *file)
 {
         int rc = 0;
 
-        lock_kernel();
+        mutex_lock(&dmasound_core_mutex);
 
         if (file->f_mode & FMODE_WRITE) {
                 if (write_sq.busy)
@@ -881,7 +901,7 @@ static int sq_release(struct inode *inode, struct file *file)
         write_sq_wake_up(file); /* checks f_mode */
 #endif /* blocking open() */
 
-        unlock_kernel();
+        mutex_unlock(&dmasound_core_mutex);
 
         return rc;
 }
@@ -955,8 +975,7 @@ printk("dmasound_core: tried to set_queue_frags on a locked queue\n") ;
         return 0 ;
 }
 
-static int sq_ioctl(struct inode *inode, struct file *file, u_int cmd,
-                    u_long arg)
+static int sq_ioctl(struct file *file, u_int cmd, u_long arg)
 {
         int val, result;
         u_long fmt;
@@ -1114,18 +1133,29 @@ static int sq_ioctl(struct inode *inode, struct file *file, u_int cmd,
                 return IOCTL_OUT(arg,val);
 
         default:
-                return mixer_ioctl(inode, file, cmd, arg);
+                return mixer_ioctl(file, cmd, arg);
         }
         return -EINVAL;
 }
 
+static long sq_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
+{
+        int ret;
+
+        mutex_lock(&dmasound_core_mutex);
+        ret = sq_ioctl(file, cmd, arg);
+        mutex_unlock(&dmasound_core_mutex);
+
+        return ret;
+}
+
 static const struct file_operations sq_fops =
 {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = sq_write,
         .poll           = sq_poll,
-        .ioctl          = sq_ioctl,
+        .unlocked_ioctl = sq_unlocked_ioctl,
         .open           = sq_open,
         .release        = sq_release,
 };
@@ -1226,12 +1256,17 @@ static int state_open(struct inode *inode, struct file *file)
 {
         char *buffer = state.buf;
         int len = 0;
+        int ret;
 
+        mutex_lock(&dmasound_core_mutex);
+        ret = -EBUSY;
         if (state.busy)
-                return -EBUSY;
+                goto out;
 
+        ret = -ENODEV;
         if (!try_module_get(dmasound.mach.owner))
-                return -ENODEV;
+                goto out;
+
         state.ptr = 0;
         state.busy = 1;
 
@@ -1293,15 +1328,18 @@ printk("dmasound: stat buffer used %d bytes\n", len) ;
                 printk(KERN_ERR "dmasound_core: stat buffer overflowed!\n");
 
         state.len = len;
-        return 0;
+        ret = 0;
+out:
+        mutex_unlock(&dmasound_core_mutex);
+        return ret;
 }
 
 static int state_release(struct inode *inode, struct file *file)
 {
-        lock_kernel();
+        mutex_lock(&dmasound_core_mutex);
         state.busy = 0;
         module_put(dmasound.mach.owner);
-        unlock_kernel();
+        mutex_unlock(&dmasound_core_mutex);
         return 0;
 }
 
diff --git a/sound/oss/midi_synth.c b/sound/oss/midi_synth.c
index 3bc7104c5379..3c09374ea5bf 100644
--- a/sound/oss/midi_synth.c
+++ b/sound/oss/midi_synth.c
@@ -523,7 +523,9 @@ midi_synth_load_patch(int dev, int format, const char __user *addr,
         {
                 unsigned char   data;
 
-                get_user(*(unsigned char *) &data, (unsigned char __user *) &((addr)[hdr_size + i]));
+                if (get_user(data,
+                    (unsigned char __user *)(addr + hdr_size + i)))
+                        return -EFAULT;
 
                 eox_seen = (i > 0 && data & 0x80);      /* End of sysex */
 
diff --git a/sound/oss/msnd_pinnacle.c b/sound/oss/msnd_pinnacle.c
index a1e3f9671bea..b4c1eb504c22 100644
--- a/sound/oss/msnd_pinnacle.c
+++ b/sound/oss/msnd_pinnacle.c
@@ -39,7 +39,7 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/smp_lock.h>
+#include <linux/mutex.h>
 #include <linux/gfp.h>
 #include <asm/irq.h>
 #include <asm/io.h>
@@ -79,6 +79,7 @@
                                          dev.rec_sample_rate /          \
                                          dev.rec_channels)
 
+static DEFINE_MUTEX(msnd_pinnacle_mutex);
 static multisound_dev_t                 dev;
 
 #ifndef HAVE_DSPCODEH
@@ -639,21 +640,26 @@ static int mixer_ioctl(unsigned int cmd, unsigned long arg)
         return -EINVAL;
 }
 
-static int dev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static long dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        int minor = iminor(inode);
+        int minor = iminor(file->f_path.dentry->d_inode);
+        int ret;
 
         if (cmd == OSS_GETVERSION) {
                 int sound_version = SOUND_VERSION;
                 return put_user(sound_version, (int __user *)arg);
         }
 
+        ret = -EINVAL;
+
+        mutex_lock(&msnd_pinnacle_mutex);
         if (minor == dev.dsp_minor)
-                return dsp_ioctl(file, cmd, arg);
+                ret = dsp_ioctl(file, cmd, arg);
         else if (minor == dev.mixer_minor)
-                return mixer_ioctl(cmd, arg);
+                ret = mixer_ioctl(cmd, arg);
+        mutex_unlock(&msnd_pinnacle_mutex);
 
-        return -EINVAL;
+        return ret;
 }
 
 static void dsp_write_flush(void)
@@ -756,12 +762,15 @@ static int dev_open(struct inode *inode, struct file *file)
         int minor = iminor(inode);
         int err = 0;
 
+        mutex_lock(&msnd_pinnacle_mutex);
         if (minor == dev.dsp_minor) {
                 if ((file->f_mode & FMODE_WRITE &&
                      test_bit(F_AUDIO_WRITE_INUSE, &dev.flags)) ||
                     (file->f_mode & FMODE_READ &&
-                     test_bit(F_AUDIO_READ_INUSE, &dev.flags)))
-                        return -EBUSY;
+                     test_bit(F_AUDIO_READ_INUSE, &dev.flags))) {
+                        err = -EBUSY;
+                        goto out;
+                }
 
                 if ((err = dsp_open(file)) >= 0) {
                         dev.nresets = 0;
@@ -782,7 +791,8 @@ static int dev_open(struct inode *inode, struct file *file)
                 /* nothing */
         } else
                 err = -EINVAL;
-
+out:
+        mutex_unlock(&msnd_pinnacle_mutex);
         return err;
 }
 
@@ -791,14 +801,14 @@ static int dev_release(struct inode *inode, struct file *file)
         int minor = iminor(inode);
         int err = 0;
 
-        lock_kernel();
+        mutex_lock(&msnd_pinnacle_mutex);
         if (minor == dev.dsp_minor)
                 err = dsp_release(file);
         else if (minor == dev.mixer_minor) {
                 /* nothing */
         } else
                 err = -EINVAL;
-        unlock_kernel();
+        mutex_unlock(&msnd_pinnacle_mutex);
         return err;
 }
 
@@ -1105,7 +1115,7 @@ static const struct file_operations dev_fileops = {
         .owner          = THIS_MODULE,
         .read           = dev_read,
         .write          = dev_write,
-        .ioctl          = dev_ioctl,
+        .unlocked_ioctl = dev_ioctl,
         .open           = dev_open,
         .release        = dev_release,
 };
@@ -1391,9 +1401,13 @@ static int __init attach_multisound(void)
                 printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", dev.irq);
                 return err;
         }
-        request_region(dev.io, dev.numio, dev.name);
+        if (request_region(dev.io, dev.numio, dev.name) == NULL) {
+                free_irq(dev.irq, &dev);
+                return -EBUSY;
+        }
 
-        if ((err = dsp_full_reset()) < 0) {
+        err = dsp_full_reset();
+        if (err < 0) {
                 release_region(dev.io, dev.numio);
                 free_irq(dev.irq, &dev);
                 return err;
diff --git a/sound/oss/sh_dac_audio.c b/sound/oss/sh_dac_audio.c
deleted file mode 100644
index 4153752507e3..000000000000
--- a/sound/oss/sh_dac_audio.c
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
- * sound/oss/sh_dac_audio.c
- *
- * SH DAC based sound :(
- *
- *  Copyright (C) 2004,2005  Andriy Skulysh
- *
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file "COPYING" in the main directory of this archive
- * for more details.
- */
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/linkage.h>
-#include <linux/slab.h>
-#include <linux/fs.h>
-#include <linux/sound.h>
-#include <linux/soundcard.h>
-#include <linux/interrupt.h>
-#include <linux/hrtimer.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
-#include <asm/irq.h>
-#include <asm/delay.h>
-#include <asm/clock.h>
-#include <cpu/dac.h>
-#include <asm/machvec.h>
-#include <mach/hp6xx.h>
-#include <asm/hd64461.h>
-
-#define MODNAME "sh_dac_audio"
-
-#define BUFFER_SIZE 48000
-
-static int rate;
-static int empty;
-static char *data_buffer, *buffer_begin, *buffer_end;
-static int in_use, device_major;
-static struct hrtimer hrtimer;
-static ktime_t wakeups_per_second;
-
-static void dac_audio_start_timer(void)
-{
-        hrtimer_start(&hrtimer, wakeups_per_second, HRTIMER_MODE_REL);
-}
-
-static void dac_audio_stop_timer(void)
-{
-        hrtimer_cancel(&hrtimer);
-}
-
-static void dac_audio_reset(void)
-{
-        dac_audio_stop_timer();
-        buffer_begin = buffer_end = data_buffer;
-        empty = 1;
-}
-
-static void dac_audio_sync(void)
-{
-        while (!empty)
-                schedule();
-}
-
-static void dac_audio_start(void)
-{
-        if (mach_is_hp6xx()) {
-                u16 v = __raw_readw(HD64461_GPADR);
-                v &= ~HD64461_GPADR_SPEAKER;
-                __raw_writew(v, HD64461_GPADR);
-        }
-
-        sh_dac_enable(CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL);
-}
-static void dac_audio_stop(void)
-{
-        dac_audio_stop_timer();
-
-        if (mach_is_hp6xx()) {
-                u16 v = __raw_readw(HD64461_GPADR);
-                v |= HD64461_GPADR_SPEAKER;
-                __raw_writew(v, HD64461_GPADR);
-        }
-
-        sh_dac_output(0, CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL);
-        sh_dac_disable(CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL);
-}
-
-static void dac_audio_set_rate(void)
-{
-        wakeups_per_second = ktime_set(0, 1000000000 / rate);
-}
-
-static int dac_audio_ioctl(struct inode *inode, struct file *file,
-                           unsigned int cmd, unsigned long arg)
-{
-        int val;
-
-        switch (cmd) {
-        case OSS_GETVERSION:
-                return put_user(SOUND_VERSION, (int *)arg);
-
-        case SNDCTL_DSP_SYNC:
-                dac_audio_sync();
-                return 0;
-
-        case SNDCTL_DSP_RESET:
-                dac_audio_reset();
-                return 0;
-
-        case SNDCTL_DSP_GETFMTS:
-                return put_user(AFMT_U8, (int *)arg);
-
-        case SNDCTL_DSP_SETFMT:
-                return put_user(AFMT_U8, (int *)arg);
-
-        case SNDCTL_DSP_NONBLOCK:
-                spin_lock(&file->f_lock);
-                file->f_flags |= O_NONBLOCK;
-                spin_unlock(&file->f_lock);
-                return 0;
-
-        case SNDCTL_DSP_GETCAPS:
-                return 0;
-
-        case SOUND_PCM_WRITE_RATE:
-                val = *(int *)arg;
-                if (val > 0) {
-                        rate = val;
-                        dac_audio_set_rate();
-                }
-                return put_user(rate, (int *)arg);
-
-        case SNDCTL_DSP_STEREO:
-                return put_user(0, (int *)arg);
-
-        case SOUND_PCM_WRITE_CHANNELS:
-                return put_user(1, (int *)arg);
-
-        case SNDCTL_DSP_SETDUPLEX:
-                return -EINVAL;
-
-        case SNDCTL_DSP_PROFILE:
-                return -EINVAL;
-
-        case SNDCTL_DSP_GETBLKSIZE:
-                return put_user(BUFFER_SIZE, (int *)arg);
-
-        case SNDCTL_DSP_SETFRAGMENT:
-                return 0;
-
-        default:
-                printk(KERN_ERR "sh_dac_audio: unimplemented ioctl=0x%x\n",
-                       cmd);
-                return -EINVAL;
-        }
-        return -EINVAL;
-}
-
-static ssize_t dac_audio_write(struct file *file, const char *buf, size_t count,
-                               loff_t * ppos)
-{
-        int free;
-        int nbytes;
-
-        if (!count) {
-                dac_audio_sync();
-                return 0;
-        }
-
-        free = buffer_begin - buffer_end;
-
-        if (free < 0)
-                free += BUFFER_SIZE;
-        if ((free == 0) && (empty))
-                free = BUFFER_SIZE;
-        if (count > free)
-                count = free;
-        if (buffer_begin > buffer_end) {
-                if (copy_from_user((void *)buffer_end, buf, count))
-                        return -EFAULT;
-
-                buffer_end += count;
-        } else {
-                nbytes = data_buffer + BUFFER_SIZE - buffer_end;
-                if (nbytes > count) {
-                        if (copy_from_user((void *)buffer_end, buf, count))
-                                return -EFAULT;
-                        buffer_end += count;
-                } else {
-                        if (copy_from_user((void *)buffer_end, buf, nbytes))
-                                return -EFAULT;
-                        if (copy_from_user
-                            ((void *)data_buffer, buf + nbytes, count - nbytes))
-                                return -EFAULT;
-                        buffer_end = data_buffer + count - nbytes;
-                }
-        }
-
-        if (empty) {
-                empty = 0;
-                dac_audio_start_timer();
-        }
-
-        return count;
-}
-
-static ssize_t dac_audio_read(struct file *file, char *buf, size_t count,
-                              loff_t * ppos)
-{
-        return -EINVAL;
-}
-
-static int dac_audio_open(struct inode *inode, struct file *file)
-{
-        if (file->f_mode & FMODE_READ)
-                return -ENODEV;
-        if (in_use)
-                return -EBUSY;
-
-        in_use = 1;
-
-        dac_audio_start();
-
-        return 0;
-}
-
-static int dac_audio_release(struct inode *inode, struct file *file)
-{
-        dac_audio_sync();
-        dac_audio_stop();
-        in_use = 0;
-
-        return 0;
-}
-
-const struct file_operations dac_audio_fops = {
-      .read =           dac_audio_read,
-      .write =  dac_audio_write,
-      .ioctl =  dac_audio_ioctl,
-      .open =           dac_audio_open,
-      .release =        dac_audio_release,
-};
-
-static enum hrtimer_restart sh_dac_audio_timer(struct hrtimer *handle)
-{
-        if (!empty) {
-                sh_dac_output(*buffer_begin, CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL);
-                buffer_begin++;
-
-                if (buffer_begin == data_buffer + BUFFER_SIZE)
-                        buffer_begin = data_buffer;
-                if (buffer_begin == buffer_end)
-                        empty = 1;
-        }
-
-        if (!empty)
-                hrtimer_start(&hrtimer, wakeups_per_second, HRTIMER_MODE_REL);
-
-        return HRTIMER_NORESTART;
-}
-
-static int __init dac_audio_init(void)
-{
-        if ((device_major = register_sound_dsp(&dac_audio_fops, -1)) < 0) {
-                printk(KERN_ERR "Cannot register dsp device");
-                return device_major;
-        }
-
-        in_use = 0;
-
-        data_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
-        if (data_buffer == NULL)
-                return -ENOMEM;
-
-        dac_audio_reset();
-        rate = 8000;
-        dac_audio_set_rate();
-
-        /* Today: High Resolution Timer driven DAC playback.
-         * The timer callback gets called once per sample. Ouch.
-         *
-         * Future: A much better approach would be to use the
-         * SH7720 CMT+DMAC+DAC hardware combination like this:
-         * - Program sample rate using CMT0 or CMT1
-         * - Program DMAC to use CMT for timing and output to DAC
-         * - Play sound using DMAC, let CPU sleep.
-         * - While at it, rewrite this driver to use ALSA.
-         */
-
-        hrtimer_init(&hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
-        hrtimer.function = sh_dac_audio_timer;
-
-        return 0;
-}
-
-static void __exit dac_audio_exit(void)
-{
-        unregister_sound_dsp(device_major);
-        kfree((void *)data_buffer);
-}
-
-module_init(dac_audio_init);
-module_exit(dac_audio_exit);
-
-MODULE_AUTHOR("Andriy Skulysh, askulysh@image.kiev.ua");
-MODULE_DESCRIPTION("SH DAC sound driver");
-MODULE_LICENSE("GPL");
diff --git a/sound/oss/sound_timer.c b/sound/oss/sound_timer.c
index f0f0c19fbff7..48cda6c4c257 100644
--- a/sound/oss/sound_timer.c
+++ b/sound/oss/sound_timer.c
@@ -26,7 +26,7 @@ static unsigned long prev_event_time;
 static volatile unsigned long usecs_per_tmr;    /* Length of the current interval */
 
 static struct sound_lowlev_timer *tmr;
-static spinlock_t lock;
+static DEFINE_SPINLOCK(lock);
 
 static unsigned long tmr2ticks(int tmr_value)
 {
diff --git a/sound/oss/soundcard.c b/sound/oss/soundcard.c
index 2d9c51312622..938ed94f904f 100644
--- a/sound/oss/soundcard.c
+++ b/sound/oss/soundcard.c
@@ -40,7 +40,7 @@
 #include <linux/major.h>
 #include <linux/delay.h>
 #include <linux/proc_fs.h>
-#include <linux/smp_lock.h>
+#include <linux/mutex.h>
 #include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/device.h>
@@ -56,6 +56,7 @@
  * Table for permanently allocated memory (used when unloading the module)
  */
 void *          sound_mem_blocks[MAX_MEM_BLOCKS];
+static DEFINE_MUTEX(soundcard_mutex);
 int             sound_nblocks = 0;
 
 /* Persistent DMA buffers */
@@ -151,7 +152,7 @@ static ssize_t sound_read(struct file *file, char __user *buf, size_t count, lof
          *      big one anyway, we might as well bandage here..
          */
          
-        lock_kernel();
+        mutex_lock(&soundcard_mutex);
         
         DEB(printk("sound_read(dev=%d, count=%d)\n", dev, count));
         switch (dev & 0x0f) {
@@ -169,7 +170,7 @@ static ssize_t sound_read(struct file *file, char __user *buf, size_t count, lof
         case SND_DEV_MIDIN:
                 ret = MIDIbuf_read(dev, file, buf, count);
         }
-        unlock_kernel();
+        mutex_unlock(&soundcard_mutex);
         return ret;
 }
 
@@ -178,7 +179,7 @@ static ssize_t sound_write(struct file *file, const char __user *buf, size_t cou
         int dev = iminor(file->f_path.dentry->d_inode);
         int ret = -EINVAL;
         
-        lock_kernel();
+        mutex_lock(&soundcard_mutex);
         DEB(printk("sound_write(dev=%d, count=%d)\n", dev, count));
         switch (dev & 0x0f) {
         case SND_DEV_SEQ:
@@ -196,7 +197,7 @@ static ssize_t sound_write(struct file *file, const char __user *buf, size_t cou
                 ret =  MIDIbuf_write(dev, file, buf, count);
                 break;
         }
-        unlock_kernel();
+        mutex_unlock(&soundcard_mutex);
         return ret;
 }
 
@@ -210,42 +211,44 @@ static int sound_open(struct inode *inode, struct file *file)
                 printk(KERN_ERR "Invalid minor device %d\n", dev);
                 return -ENXIO;
         }
+        mutex_lock(&soundcard_mutex);
         switch (dev & 0x0f) {
         case SND_DEV_CTL:
                 dev >>= 4;
                 if (dev >= 0 && dev < MAX_MIXER_DEV && mixer_devs[dev] == NULL) {
                         request_module("mixer%d", dev);
                 }
+                retval = -ENXIO;
                 if (dev && (dev >= num_mixers || mixer_devs[dev] == NULL))
-                        return -ENXIO;
+                        break;
         
                 if (!try_module_get(mixer_devs[dev]->owner))
-                        return -ENXIO;
+                        break;
+
+                retval = 0;
                 break;
 
         case SND_DEV_SEQ:
         case SND_DEV_SEQ2:
-                if ((retval = sequencer_open(dev, file)) < 0)
-                        return retval;
+                retval = sequencer_open(dev, file);
                 break;
 
         case SND_DEV_MIDIN:
-                if ((retval = MIDIbuf_open(dev, file)) < 0)
-                        return retval;
+                retval = MIDIbuf_open(dev, file);
                 break;
 
         case SND_DEV_DSP:
         case SND_DEV_DSP16:
         case SND_DEV_AUDIO:
-                if ((retval = audio_open(dev, file)) < 0)
-                        return retval;
+                retval = audio_open(dev, file);
                 break;
 
         default:
                 printk(KERN_ERR "Invalid minor device %d\n", dev);
-                return -ENXIO;
+                retval = -ENXIO;
         }
 
+        mutex_unlock(&soundcard_mutex);
         return 0;
 }
 
@@ -253,7 +256,7 @@ static int sound_release(struct inode *inode, struct file *file)
 {
         int dev = iminor(inode);
 
-        lock_kernel();
+        mutex_lock(&soundcard_mutex);
         DEB(printk("sound_release(dev=%d)\n", dev));
         switch (dev & 0x0f) {
         case SND_DEV_CTL:
@@ -278,7 +281,7 @@ static int sound_release(struct inode *inode, struct file *file)
         default:
                 printk(KERN_ERR "Sound error: Releasing unknown device 0x%02x\n", dev);
         }
-        unlock_kernel();
+        mutex_unlock(&soundcard_mutex);
 
         return 0;
 }
@@ -352,7 +355,7 @@ static long sound_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         if (cmd == OSS_GETVERSION)
                 return __put_user(SOUND_VERSION, (int __user *)p);
         
-        lock_kernel();
+        mutex_lock(&soundcard_mutex);
         if (_IOC_TYPE(cmd) == 'M' && num_mixers > 0 &&   /* Mixer ioctl */
             (dev & 0x0f) != SND_DEV_CTL) {              
                 dtype = dev & 0x0f;
@@ -367,7 +370,7 @@ static long sound_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                         ret = sound_mixer_ioctl(dev >> 4, cmd, p);
                         break;
                 }
-                unlock_kernel();
+                mutex_unlock(&soundcard_mutex);
                 return ret;
         }
 
@@ -397,7 +400,7 @@ static long sound_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 break;
 
         }
-        unlock_kernel();
+        mutex_unlock(&soundcard_mutex);
         return ret;
 }
 
@@ -437,35 +440,35 @@ static int sound_mmap(struct file *file, struct vm_area_struct *vma)
                 printk(KERN_ERR "Sound: mmap() not supported for other than audio devices\n");
                 return -EINVAL;
         }
-        lock_kernel();
+        mutex_lock(&soundcard_mutex);
         if (vma->vm_flags & VM_WRITE)   /* Map write and read/write to the output buf */
                 dmap = audio_devs[dev]->dmap_out;
         else if (vma->vm_flags & VM_READ)
                 dmap = audio_devs[dev]->dmap_in;
         else {
                 printk(KERN_ERR "Sound: Undefined mmap() access\n");
-                unlock_kernel();
+                mutex_unlock(&soundcard_mutex);
                 return -EINVAL;
         }
 
         if (dmap == NULL) {
                 printk(KERN_ERR "Sound: mmap() error. dmap == NULL\n");
-                unlock_kernel();
+                mutex_unlock(&soundcard_mutex);
                 return -EIO;
         }
         if (dmap->raw_buf == NULL) {
                 printk(KERN_ERR "Sound: mmap() called when raw_buf == NULL\n");
-                unlock_kernel();
+                mutex_unlock(&soundcard_mutex);
                 return -EIO;
         }
         if (dmap->mapping_flags) {
                 printk(KERN_ERR "Sound: mmap() called twice for the same DMA buffer\n");
-                unlock_kernel();
+                mutex_unlock(&soundcard_mutex);
                 return -EIO;
         }
         if (vma->vm_pgoff != 0) {
                 printk(KERN_ERR "Sound: mmap() offset must be 0.\n");
-                unlock_kernel();
+                mutex_unlock(&soundcard_mutex);
                 return -EINVAL;
         }
         size = vma->vm_end - vma->vm_start;
@@ -476,7 +479,7 @@ static int sound_mmap(struct file *file, struct vm_area_struct *vma)
         if (remap_pfn_range(vma, vma->vm_start,
                         virt_to_phys(dmap->raw_buf) >> PAGE_SHIFT,
                         vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
-                unlock_kernel();
+                mutex_unlock(&soundcard_mutex);
                 return -EAGAIN;
         }
 
@@ -488,7 +491,7 @@ static int sound_mmap(struct file *file, struct vm_area_struct *vma)
         memset(dmap->raw_buf,
                dmap->neutral_byte,
                dmap->bytes_in_use);
-        unlock_kernel();
+        mutex_unlock(&soundcard_mutex);
         return 0;
 }
 
diff --git a/sound/oss/swarm_cs4297a.c b/sound/oss/swarm_cs4297a.c
index 3136c88eacdf..44357d877a27 100644
--- a/sound/oss/swarm_cs4297a.c
+++ b/sound/oss/swarm_cs4297a.c
@@ -93,6 +93,7 @@
 
 struct cs4297a_state;
 
+static DEFINE_MUTEX(swarm_cs4297a_mutex);
 static void stop_dac(struct cs4297a_state *s);
 static void stop_adc(struct cs4297a_state *s);
 static void start_dac(struct cs4297a_state *s);
@@ -1534,6 +1535,7 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file)
         CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
                   printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()+\n"));
 
+        mutex_lock(&swarm_cs4297a_mutex);
         list_for_each(entry, &cs4297a_devs)
         {
                 s = list_entry(entry, struct cs4297a_state, list);
@@ -1544,6 +1546,8 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file)
         {
                 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
                         printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()- -ENODEV\n"));
+
+                mutex_unlock(&swarm_cs4297a_mutex);
                 return -ENODEV;
         }
         VALIDATE_STATE(s);
@@ -1551,6 +1555,7 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file)
 
         CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
                   printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()- 0\n"));
+        mutex_unlock(&swarm_cs4297a_mutex);
 
         return nonseekable_open(inode, file);
 }
@@ -1566,11 +1571,15 @@ static int cs4297a_release_mixdev(struct inode *inode, struct file *file)
 }
 
 
-static int cs4297a_ioctl_mixdev(struct inode *inode, struct file *file,
+static int cs4297a_ioctl_mixdev(struct file *file,
                                unsigned int cmd, unsigned long arg)
 {
-        return mixer_ioctl((struct cs4297a_state *) file->private_data, cmd,
+        int ret;
+        mutex_lock(&swarm_cs4297a_mutex);
+        ret = mixer_ioctl((struct cs4297a_state *) file->private_data, cmd,
                            arg);
+        mutex_unlock(&swarm_cs4297a_mutex);
+        return ret;
 }
 
 
@@ -1580,7 +1589,7 @@ static int cs4297a_ioctl_mixdev(struct inode *inode, struct file *file,
 static const struct file_operations cs4297a_mixer_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
-        .ioctl          = cs4297a_ioctl_mixdev,
+        .unlocked_ioctl = cs4297a_ioctl_mixdev,
         .open           = cs4297a_open_mixdev,
         .release        = cs4297a_release_mixdev,
 };
@@ -1944,7 +1953,7 @@ static int cs4297a_mmap(struct file *file, struct vm_area_struct *vma)
 }
 
 
-static int cs4297a_ioctl(struct inode *inode, struct file *file,
+static int cs4297a_ioctl(struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
         struct cs4297a_state *s =
@@ -2337,6 +2346,16 @@ static int cs4297a_ioctl(struct inode *inode, struct file *file,
         return mixer_ioctl(s, cmd, arg);
 }
 
+static long cs4297a_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
+{
+        int ret;
+
+        mutex_lock(&swarm_cs4297a_mutex);
+        ret = cs4297a_ioctl(file, cmd, arg);
+        mutex_unlock(&swarm_cs4297a_mutex);
+
+        return ret;
+}
 
 static int cs4297a_release(struct inode *inode, struct file *file)
 {
@@ -2369,7 +2388,7 @@ static int cs4297a_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int cs4297a_open(struct inode *inode, struct file *file)
+static int cs4297a_locked_open(struct inode *inode, struct file *file)
 {
         int minor = iminor(inode);
         struct cs4297a_state *s=NULL;
@@ -2486,6 +2505,16 @@ static int cs4297a_open(struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
+static int cs4297a_open(struct inode *inode, struct file *file)
+{
+        int ret;
+
+        mutex_lock(&swarm_cs4297a_mutex);
+        ret = cs4297a_open(inode, file);
+        mutex_unlock(&swarm_cs4297a_mutex);
+
+        return ret;
+}
 
 // ******************************************************************************************
 //   Wave (audio) file operations struct.
@@ -2496,7 +2525,7 @@ static const struct file_operations cs4297a_audio_fops = {
         .read           = cs4297a_read,
         .write          = cs4297a_write,
         .poll           = cs4297a_poll,
-        .ioctl          = cs4297a_ioctl,
+        .unlocked_ioctl = cs4297a_unlocked_ioctl,
         .mmap           = cs4297a_mmap,
         .open           = cs4297a_open,
         .release        = cs4297a_release,
diff --git a/sound/oss/vidc.c b/sound/oss/vidc.c
index ac39a531df19..f0e0caa53200 100644
--- a/sound/oss/vidc.c
+++ b/sound/oss/vidc.c
@@ -491,9 +491,6 @@ static void __init attach_vidc(struct address_info *hw_config)
         vidc_adev = adev;
         vidc_mixer_set(SOUND_MIXER_VOLUME, (85 | 85 << 8));
 
-#if defined(CONFIG_SOUND_SOFTOSS) || defined(CONFIG_SOUND_SOFTOSS_MODULE)
-        softoss_dev = adev;
-#endif
         return;
 
 irq_failed:
diff --git a/sound/oss/vwsnd.c b/sound/oss/vwsnd.c
index 20b3b325aa80..643f1113b1d8 100644
--- a/sound/oss/vwsnd.c
+++ b/sound/oss/vwsnd.c
@@ -145,7 +145,6 @@
 #include <linux/init.h>
 
 #include <linux/spinlock.h>
-#include <linux/smp_lock.h>
 #include <linux/wait.h>
 #include <linux/interrupt.h>
 #include <linux/mutex.h>
@@ -160,6 +159,7 @@
 
 #ifdef VWSND_DEBUG
 
+static DEFINE_MUTEX(vwsnd_mutex);
 static int shut_up = 1;
 
 /*
@@ -2429,8 +2429,7 @@ static unsigned int vwsnd_audio_poll(struct file *file,
         return mask;
 }
 
-static int vwsnd_audio_do_ioctl(struct inode *inode,
-                                struct file *file,
+static int vwsnd_audio_do_ioctl(struct file *file,
                                 unsigned int cmd,
                                 unsigned long arg)
 {
@@ -2446,8 +2445,8 @@ static int vwsnd_audio_do_ioctl(struct inode *inode,
         int ival;
 
         
-        DBGEV("(inode=0x%p, file=0x%p, cmd=0x%x, arg=0x%lx)\n",
-              inode, file, cmd, arg);
+        DBGEV("(file=0x%p, cmd=0x%x, arg=0x%lx)\n",
+              file, cmd, arg);
         switch (cmd) {
         case OSS_GETVERSION:            /* _SIOR ('M', 118, int) */
                 DBGX("OSS_GETVERSION\n");
@@ -2885,17 +2884,19 @@ static int vwsnd_audio_do_ioctl(struct inode *inode,
         return -EINVAL;
 }
 
-static int vwsnd_audio_ioctl(struct inode *inode,
-                                struct file *file,
+static long vwsnd_audio_ioctl(struct file *file,
                                 unsigned int cmd,
                                 unsigned long arg)
 {
         vwsnd_dev_t *devc = (vwsnd_dev_t *) file->private_data;
         int ret;
 
+        mutex_lock(&vwsnd_mutex);
         mutex_lock(&devc->io_mutex);
-        ret = vwsnd_audio_do_ioctl(inode, file, cmd, arg);
+        ret = vwsnd_audio_do_ioctl(file, cmd, arg);
         mutex_unlock(&devc->io_mutex);
+        mutex_unlock(&vwsnd_mutex);
+
         return ret;
 }
 
@@ -2921,6 +2922,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
 
         DBGE("(inode=0x%p, file=0x%p)\n", inode, file);
 
+        mutex_lock(&vwsnd_mutex);
         INC_USE_COUNT;
         for (devc = vwsnd_dev_list; devc; devc = devc->next_dev)
                 if ((devc->audio_minor & ~0x0F) == (minor & ~0x0F))
@@ -2928,6 +2930,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
 
         if (devc == NULL) {
                 DEC_USE_COUNT;
+                mutex_unlock(&vwsnd_mutex);
                 return -ENODEV;
         }
 
@@ -2936,11 +2939,13 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
                 mutex_unlock(&devc->open_mutex);
                 if (file->f_flags & O_NONBLOCK) {
                         DEC_USE_COUNT;
+                        mutex_unlock(&vwsnd_mutex);
                         return -EBUSY;
                 }
                 interruptible_sleep_on(&devc->open_wait);
                 if (signal_pending(current)) {
                         DEC_USE_COUNT;
+                        mutex_unlock(&vwsnd_mutex);
                         return -ERESTARTSYS;
                 }
                 mutex_lock(&devc->open_mutex);
@@ -2993,6 +2998,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file)
 
         file->private_data = devc;
         DBGRV();
+        mutex_unlock(&vwsnd_mutex);
         return 0;
 }
 
@@ -3006,7 +3012,7 @@ static int vwsnd_audio_release(struct inode *inode, struct file *file)
         vwsnd_port_t *wport = NULL, *rport = NULL;
         int err = 0;
 
-        lock_kernel();
+        mutex_lock(&vwsnd_mutex);
         mutex_lock(&devc->io_mutex);
         {
                 DBGEV("(inode=0x%p, file=0x%p)\n", inode, file);
@@ -3034,7 +3040,7 @@ static int vwsnd_audio_release(struct inode *inode, struct file *file)
         wake_up(&devc->open_wait);
         DEC_USE_COUNT;
         DBGR();
-        unlock_kernel();
+        mutex_unlock(&vwsnd_mutex);
         return err;
 }
 
@@ -3044,7 +3050,7 @@ static const struct file_operations vwsnd_audio_fops = {
         .read =         vwsnd_audio_read,
         .write =        vwsnd_audio_write,
         .poll =         vwsnd_audio_poll,
-        .ioctl =        vwsnd_audio_ioctl,
+        .unlocked_ioctl = vwsnd_audio_ioctl,
         .mmap =         vwsnd_audio_mmap,
         .open =         vwsnd_audio_open,
         .release =      vwsnd_audio_release,
@@ -3062,15 +3068,18 @@ static int vwsnd_mixer_open(struct inode *inode, struct file *file)
         DBGEV("(inode=0x%p, file=0x%p)\n", inode, file);
 
         INC_USE_COUNT;
+        mutex_lock(&vwsnd_mutex);
         for (devc = vwsnd_dev_list; devc; devc = devc->next_dev)
                 if (devc->mixer_minor == iminor(inode))
                         break;
 
         if (devc == NULL) {
                 DEC_USE_COUNT;
+                mutex_unlock(&vwsnd_mutex);
                 return -ENODEV;
         }
         file->private_data = devc;
+        mutex_unlock(&vwsnd_mutex);
         return 0;
 }
 
@@ -3203,8 +3212,7 @@ static int mixer_write_ioctl(vwsnd_dev_t *devc, unsigned int nr, void __user *ar
 
 /* This is the ioctl entry to the mixer driver. */
 
-static int vwsnd_mixer_ioctl(struct inode *ioctl,
-                              struct file *file,
+static long vwsnd_mixer_ioctl(struct file *file,
                               unsigned int cmd,
                               unsigned long arg)
 {
@@ -3215,6 +3223,7 @@ static int vwsnd_mixer_ioctl(struct inode *ioctl,
 
         DBGEV("(devc=0x%p, cmd=0x%x, arg=0x%lx)\n", devc, cmd, arg);
 
+        mutex_lock(&vwsnd_mutex);
         mutex_lock(&devc->mix_mutex);
         {
                 if ((cmd & ~nrmask) == MIXER_READ(0))
@@ -3225,13 +3234,14 @@ static int vwsnd_mixer_ioctl(struct inode *ioctl,
                         retval = -EINVAL;
         }
         mutex_unlock(&devc->mix_mutex);
+        mutex_unlock(&vwsnd_mutex);
         return retval;
 }
 
 static const struct file_operations vwsnd_mixer_fops = {
         .owner =        THIS_MODULE,
         .llseek =       no_llseek,
-        .ioctl =        vwsnd_mixer_ioctl,
+        .unlocked_ioctl = vwsnd_mixer_ioctl,
         .open =         vwsnd_mixer_open,
         .release =      vwsnd_mixer_release,
 };
diff --git a/sound/oss/waveartist.c b/sound/oss/waveartist.c
index e688dde6bbde..52468742d9f2 100644
--- a/sound/oss/waveartist.c
+++ b/sound/oss/waveartist.c
@@ -184,14 +184,8 @@ waveartist_iack(wavnc_info *devc)
 static inline int
 waveartist_sleep(int timeout_ms)
 {
-        unsigned int timeout = timeout_ms * 10 * HZ / 100;
-
-        do {
-                set_current_state(TASK_INTERRUPTIBLE);
-                timeout = schedule_timeout(timeout);
-        } while (timeout);
-
-        return 0;
+        unsigned int timeout = msecs_to_jiffies(timeout_ms*100);
+        return schedule_timeout_interruptible(timeout);
 }
 
 static int
diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig
index e7a8cd058efb..12e34653b8a8 100644
--- a/sound/pci/Kconfig
+++ b/sound/pci/Kconfig
@@ -207,12 +207,12 @@ config SND_CMIPCI
 
 config SND_OXYGEN_LIB
         tristate
-        select SND_PCM
-        select SND_MPU401_UART
 
 config SND_OXYGEN
         tristate "C-Media 8788 (Oxygen)"
         select SND_OXYGEN_LIB
+        select SND_PCM
+        select SND_MPU401_UART
         help
           Say Y here to include support for sound cards based on the
           C-Media CMI8788 (Oxygen HD Audio) chip:
@@ -581,6 +581,8 @@ config SND_HDSPM
 config SND_HIFIER
         tristate "TempoTec HiFier Fantasia"
         select SND_OXYGEN_LIB
+        select SND_PCM
+        select SND_MPU401_UART
         help
           Say Y here to include support for the MediaTek/TempoTec HiFier
           Fantasia sound card.
@@ -815,14 +817,17 @@ config SND_VIA82XX_MODEM
           will be called snd-via82xx-modem.
 
 config SND_VIRTUOSO
-        tristate "Asus Virtuoso 100/200 (Xonar)"
+        tristate "Asus Virtuoso 66/100/200 (Xonar)"
         select SND_OXYGEN_LIB
+        select SND_PCM
+        select SND_MPU401_UART
+        select SND_JACK if INPUT=y || INPUT=SND
         help
           Say Y here to include support for sound cards based on the
-          Asus AV100/AV200 chips, i.e., Xonar D1, DX, D2, D2X,
+          Asus AV66/AV100/AV200 chips, i.e., Xonar D1, DX, D2, D2X, DS,
           Essence ST (Deluxe), and Essence STX.
-          Support for the DS is experimental.
-          Support for the HDAV1.3 (Deluxe) is very experimental.
+          Support for the HDAV1.3 (Deluxe) is incomplete; for the
+          HDAV1.3 Slim and Xense, missing.
 
           To compile this driver as a module, choose M here: the module
           will be called snd-virtuoso.
diff --git a/sound/pci/als4000.c b/sound/pci/als4000.c
index 6cf1de8042e8..0e247cb90ecc 100644
--- a/sound/pci/als4000.c
+++ b/sound/pci/als4000.c
@@ -763,9 +763,9 @@ static void snd_als4000_configure(struct snd_sb *chip)
         /* SPECS_PAGE: 39 */
         for (i = ALS4K_GCR91_DMA0_ADDR; i <= ALS4K_GCR96_DMA3_MODE_COUNT; ++i)
                 snd_als4k_gcr_write(chip, i, 0);
-        
+        /* enable burst mode to prevent dropouts during high PCI bus usage */
         snd_als4k_gcr_write(chip, ALS4K_GCR99_DMA_EMULATION_CTRL,
-                snd_als4k_gcr_read(chip, ALS4K_GCR99_DMA_EMULATION_CTRL));
+                (snd_als4k_gcr_read(chip, ALS4K_GCR99_DMA_EMULATION_CTRL) & ~0x07) | 0x04);
         spin_unlock_irq(&chip->reg_lock);
 }
 
diff --git a/sound/pci/asihpi/asihpi.c b/sound/pci/asihpi/asihpi.c
index 1db586af4f9c..c80b0b863c54 100644
--- a/sound/pci/asihpi/asihpi.c
+++ b/sound/pci/asihpi/asihpi.c
@@ -460,6 +460,7 @@ static int snd_card_asihpi_pcm_hw_params(struct snd_pcm_substream *substream,
         struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
         int err;
         u16 format;
+        int width;
         unsigned int bytes_per_sec;
 
         print_hwparams(params);
@@ -512,9 +513,10 @@ static int snd_card_asihpi_pcm_hw_params(struct snd_pcm_substream *substream,
                                 dpcm->hpi_buffer_attached);
         }
         bytes_per_sec = params_rate(params) * params_channels(params);
-        bytes_per_sec *= snd_pcm_format_width(params_format(params));
+        width = snd_pcm_format_width(params_format(params));
+        bytes_per_sec *= width;
         bytes_per_sec /= 8;
-        if (bytes_per_sec <= 0)
+        if (width < 0 || bytes_per_sec == 0)
                 return -EINVAL;
 
         dpcm->bytes_per_sec = bytes_per_sec;
@@ -1383,7 +1385,7 @@ static char *asihpi_src_names[] =
 
 compile_time_assert(
         (ARRAY_SIZE(asihpi_src_names) ==
-                (HPI_SOURCENODE_LAST_INDEX-HPI_SOURCENODE_BASE+1)),
+                (HPI_SOURCENODE_LAST_INDEX-HPI_SOURCENODE_NONE+1)),
         assert_src_names_size);
 
 #if ASI_STYLE_NAMES
@@ -1414,7 +1416,7 @@ static char *asihpi_dst_names[] =
 
 compile_time_assert(
         (ARRAY_SIZE(asihpi_dst_names) ==
-                (HPI_DESTNODE_LAST_INDEX-HPI_DESTNODE_BASE+1)),
+                (HPI_DESTNODE_LAST_INDEX-HPI_DESTNODE_NONE+1)),
         assert_dst_names_size);
 
 static inline int ctl_add(struct snd_card *card, struct snd_kcontrol_new *ctl,
@@ -2171,7 +2173,7 @@ static int snd_asihpi_mux_info(struct snd_kcontrol *kcontrol,
                                         &src_node_type, &src_node_index);
 
         sprintf(uinfo->value.enumerated.name, "%s %d",
-                asihpi_src_names[src_node_type - HPI_SOURCENODE_BASE],
+                asihpi_src_names[src_node_type - HPI_SOURCENODE_NONE],
                 src_node_index);
         return 0;
 }
@@ -2603,8 +2605,8 @@ static int __devinit snd_card_asihpi_mixer_new(struct snd_card_asihpi *asihpi)
 
                 }
 
-                hpi_ctl.src_node_type -= HPI_SOURCENODE_BASE;
-                hpi_ctl.dst_node_type -= HPI_DESTNODE_BASE;
+                hpi_ctl.src_node_type -= HPI_SOURCENODE_NONE;
+                hpi_ctl.dst_node_type -= HPI_DESTNODE_NONE;
 
                 /* ASI50xx in SSX mode has multiple meters on the same node.
                    Use subindex to create distinct ALSA controls
diff --git a/sound/pci/asihpi/hpi.h b/sound/pci/asihpi/hpi.h
index 0173bbe62b67..23399d02f666 100644
--- a/sound/pci/asihpi/hpi.h
+++ b/sound/pci/asihpi/hpi.h
@@ -50,7 +50,8 @@ i.e 3.05.02 is a development version
 #define HPI_VER_RELEASE(v) ((int)(v & 0xFF))
 
 /* Use single digits for versions less that 10 to avoid octal. */
-#define HPI_VER HPI_VERSION_CONSTRUCTOR(4L, 3, 25)
+#define HPI_VER HPI_VERSION_CONSTRUCTOR(4L, 4, 1)
+#define HPI_VER_STRING "4.04.01"
 
 /* Library version as documented in hpi-api-versions.txt */
 #define HPI_LIB_VER  HPI_VERSION_CONSTRUCTOR(9, 0, 0)
@@ -203,8 +204,6 @@ enum HPI_SOURCENODES {
         exists on a destination node can be searched for using a source
         node value of either 0, or HPI_SOURCENODE_NONE */
         HPI_SOURCENODE_NONE = 100,
-        /** \deprecated Use HPI_SOURCENODE_NONE instead. */
-        HPI_SOURCENODE_BASE = 100,
         /** Out Stream (Play) node. */
         HPI_SOURCENODE_OSTREAM = 101,
         /** Line in node - could be analog, AES/EBU or network. */
@@ -235,8 +234,6 @@ enum HPI_DESTNODES {
         exists on a source node can be searched for using a destination
         node value of either 0, or HPI_DESTNODE_NONE */
         HPI_DESTNODE_NONE = 200,
-        /** \deprecated Use HPI_DESTNODE_NONE instead. */
-        HPI_DESTNODE_BASE = 200,
         /** In Stream (Record) node. */
         HPI_DESTNODE_ISTREAM = 201,
         HPI_DESTNODE_LINEOUT = 202,         /**< line out node. */
@@ -432,7 +429,18 @@ Property 2 - adapter can do stream grouping (supports SSX2)
 Property 1 - adapter can do samplerate conversion (MRX)
 Property 2 - adapter can do timestretch (TSX)
 */
-        HPI_ADAPTER_PROPERTY_CAPS2 = 269
+        HPI_ADAPTER_PROPERTY_CAPS2 = 269,
+
+/** Readonly adapter sync header connection count.
+*/
+        HPI_ADAPTER_PROPERTY_SYNC_HEADER_CONNECTIONS = 270,
+/** Readonly supports SSX2 property.
+Indicates the adapter supports SSX2 in some mode setting. The
+return value is true (1) or false (0). If the current adapter
+mode is MONO SSX2 is disabled, even though this property will
+return true.
+*/
+        HPI_ADAPTER_PROPERTY_SUPPORTS_SSX2 = 271
 };
 
 /** Adapter mode commands
@@ -813,8 +821,6 @@ enum HPI_SAMPLECLOCK_SOURCES {
 /** The sampleclock output is derived from its local samplerate generator.
     The local samplerate may be set using HPI_SampleClock_SetLocalRate(). */
         HPI_SAMPLECLOCK_SOURCE_LOCAL = 1,
-/** \deprecated Use HPI_SAMPLECLOCK_SOURCE_LOCAL instead */
-        HPI_SAMPLECLOCK_SOURCE_ADAPTER = 1,
 /** The adapter is clocked from a dedicated AES/EBU SampleClock input.*/
         HPI_SAMPLECLOCK_SOURCE_AESEBU_SYNC = 2,
 /** From external wordclock connector */
@@ -825,10 +831,6 @@ enum HPI_SAMPLECLOCK_SOURCES {
         HPI_SAMPLECLOCK_SOURCE_SMPTE = 5,
 /** One of the aesebu inputs */
         HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT = 6,
-/** \deprecated The first aesebu input with a valid signal
-Superseded by separate Auto enable flag
-*/
-        HPI_SAMPLECLOCK_SOURCE_AESEBU_AUTO = 7,
 /** From a network interface e.g. Cobranet or Livewire at either 48 or 96kHz */
         HPI_SAMPLECLOCK_SOURCE_NETWORK = 8,
 /** From previous adjacent module (ASI2416 only)*/
@@ -1015,8 +1017,6 @@ enum HPI_ERROR_CODES {
         HPI_ERROR_CONTROL_DISABLED = 404,
         /** I2C transaction failed due to a missing ACK. */
         HPI_ERROR_CONTROL_I2C_MISSING_ACK = 405,
-        /** Control attribute is valid, but not supported by this hardware. */
-        HPI_ERROR_UNSUPPORTED_CONTROL_ATTRIBUTE = 406,
         /** Control is busy, or coming out of
         reset and cannot be accessed at this time. */
         HPI_ERROR_CONTROL_NOT_READY = 407,
@@ -1827,13 +1827,41 @@ u16 hpi_parametricEQ__get_coeffs(const struct hpi_hsubsys *ph_subsys,
   Compressor Expander control
 *******************************/
 
-u16 hpi_compander_set(const struct hpi_hsubsys *ph_subsys, u32 h_control,
-        u16 attack, u16 decay, short ratio100, short threshold0_01dB,
-        short makeup_gain0_01dB);
+u16 hpi_compander_set_enable(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 on);
+
+u16 hpi_compander_get_enable(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 *pon);
+
+u16 hpi_compander_set_makeup_gain(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, short makeup_gain0_01dB);
+
+u16 hpi_compander_get_makeup_gain(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, short *pn_makeup_gain0_01dB);
+
+u16 hpi_compander_set_attack_time_constant(const struct hpi_hsubsys
+        *ph_subsys, u32 h_control, u32 index, u32 attack);
+
+u16 hpi_compander_get_attack_time_constant(const struct hpi_hsubsys
+        *ph_subsys, u32 h_control, u32 index, u32 *pw_attack);
+
+u16 hpi_compander_set_decay_time_constant(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, u32 decay);
+
+u16 hpi_compander_get_decay_time_constant(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, u32 *pw_decay);
+
+u16 hpi_compander_set_threshold(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, short threshold0_01dB);
+
+u16 hpi_compander_get_threshold(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, short *pn_threshold0_01dB);
+
+u16 hpi_compander_set_ratio(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, u32 ratio100);
 
-u16 hpi_compander_get(const struct hpi_hsubsys *ph_subsys, u32 h_control,
-        u16 *pw_attack, u16 *pw_decay, short *pw_ratio100,
-        short *pn_threshold0_01dB, short *pn_makeup_gain0_01dB);
+u16 hpi_compander_get_ratio(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, u32 *pw_ratio100);
 
 /*******************************
   Cobranet HMI control
diff --git a/sound/pci/asihpi/hpi6000.c b/sound/pci/asihpi/hpi6000.c
index 12dab5e4892c..f7e374ec4414 100644
--- a/sound/pci/asihpi/hpi6000.c
+++ b/sound/pci/asihpi/hpi6000.c
@@ -687,6 +687,7 @@ static short hpi6000_adapter_boot_load_dsp(struct hpi_adapter_obj *pao,
         switch (pao->pci.subsys_device_id) {
         case 0x5100:
         case 0x5110:    /* ASI5100 revB or higher with C6711D */
+        case 0x5200:    /* ASI5200 PC_ie version of ASI5100 */
         case 0x6100:
         case 0x6200:
                 boot_load_family = HPI_ADAPTER_FAMILY_ASI(0x6200);
@@ -1133,6 +1134,12 @@ static short hpi6000_adapter_boot_load_dsp(struct hpi_adapter_obj *pao,
                                                 subsys_device_id) ==
                                         HPI_ADAPTER_FAMILY_ASI(0x5100))
                                         mask = 0x00000000L;
+                                /* ASI5200 uses AX6 code, */
+                                /* but has no PLD r/w register to test */
+                                if (HPI_ADAPTER_FAMILY_ASI(pao->pci.
+                                                subsys_device_id) ==
+                                        HPI_ADAPTER_FAMILY_ASI(0x5200))
+                                        mask = 0x00000000L;
                                 break;
                         case HPI_ADAPTER_FAMILY_ASI(0x8800):
                                 /* ASI8800 has 16bit path to FPGA */
diff --git a/sound/pci/asihpi/hpi6205.c b/sound/pci/asihpi/hpi6205.c
index 3b4413448226..22c5fc625533 100644
--- a/sound/pci/asihpi/hpi6205.c
+++ b/sound/pci/asihpi/hpi6205.c
@@ -941,8 +941,7 @@ static void outstream_host_buffer_free(struct hpi_adapter_obj *pao,
 
 }
 
-static u32 outstream_get_space_available(struct hpi_hostbuffer_status
-        *status)
+static u32 outstream_get_space_available(struct hpi_hostbuffer_status *status)
 {
         return status->size_in_bytes - (status->host_index -
                 status->dSP_index);
@@ -987,6 +986,10 @@ static void outstream_write(struct hpi_adapter_obj *pao,
                 /* write it */
                 phm->function = HPI_OSTREAM_WRITE;
                 hw_message(pao, phm, phr);
+
+                if (phr->error)
+                        return;
+
                 /* update status information that the DSP would typically
                  * update (and will update next time the DSP
                  * buffer update task reads data from the host BBM buffer)
diff --git a/sound/pci/asihpi/hpi_internal.h b/sound/pci/asihpi/hpi_internal.h
index fdd0ce02aa68..16f502d459de 100644
--- a/sound/pci/asihpi/hpi_internal.h
+++ b/sound/pci/asihpi/hpi_internal.h
@@ -104,9 +104,9 @@ typedef void hpi_handler_func(struct hpi_message *, struct hpi_response *);
 #define STR_ROLE_FIELD_MAX 255U
 
 struct hpi_entity_str {
-        uint16_t size;
-        uint8_t type;
-        uint8_t role;
+        u16 size;
+        u8 type;
+        u8 role;
 };
 
 #if defined(_MSC_VER)
@@ -119,11 +119,11 @@ struct hpi_entity {
 #if ! defined(HPI_OS_DSP_C6000) || (defined(HPI_OS_DSP_C6000) && (__TI_COMPILER_VERSION__ > 6000008))
         /* DSP C6000 compiler v6.0.8 and lower
            do not support  flexible array member */
-        uint8_t value[];
+        u8 value[];
 #else
         /* NOTE! Using sizeof(struct hpi_entity) will give erroneous results */
 #define HPI_INTERNAL_WARN_ABOUT_ENTITY_VALUE
-        uint8_t value[1];
+        u8 value[1];
 #endif
 };
 
@@ -142,12 +142,15 @@ enum HPI_BUSES {
 /******************************************* CONTROL ATTRIBUTES ****/
 /* (in order of control type ID */
 
-        /* This allows for 255 control types, 256 unique attributes each */
+/* This allows for 255 control types, 256 unique attributes each */
 #define HPI_CTL_ATTR(ctl, ai) (HPI_CONTROL_##ctl * 0x100 + ai)
 
 /* Get the sub-index of the attribute for a control type */
 #define HPI_CTL_ATTR_INDEX(i) (i&0xff)
 
+/* Extract the control from the control attribute */
+#define HPI_CTL_ATTR_CONTROL(i) (i>>8)
+
 /* Generic control attributes.  */
 
 /** Enable a control.
@@ -311,8 +314,7 @@ Used for HPI_ChannelModeSet/Get()
 /* Microphone control attributes */
 #define HPI_MICROPHONE_PHANTOM_POWER HPI_CTL_ATTR(MICROPHONE, 1)
 
-/** Equalizer control attributes
-*/
+/** Equalizer control attributes */
 /** Used to get number of filters in an EQ. (Can't set) */
 #define HPI_EQUALIZER_NUM_FILTERS HPI_CTL_ATTR(EQUALIZER, 1)
 /** Set/get the filter by type, freq, Q, gain */
@@ -320,13 +322,15 @@ Used for HPI_ChannelModeSet/Get()
 /** Get the biquad coefficients */
 #define HPI_EQUALIZER_COEFFICIENTS HPI_CTL_ATTR(EQUALIZER, 3)
 
-#define HPI_COMPANDER_PARAMS HPI_CTL_ATTR(COMPANDER, 1)
+/* Note compander also uses HPI_GENERIC_ENABLE */
+#define HPI_COMPANDER_PARAMS     HPI_CTL_ATTR(COMPANDER, 1)
+#define HPI_COMPANDER_MAKEUPGAIN HPI_CTL_ATTR(COMPANDER, 2)
+#define HPI_COMPANDER_THRESHOLD  HPI_CTL_ATTR(COMPANDER, 3)
+#define HPI_COMPANDER_RATIO      HPI_CTL_ATTR(COMPANDER, 4)
+#define HPI_COMPANDER_ATTACK     HPI_CTL_ATTR(COMPANDER, 5)
+#define HPI_COMPANDER_DECAY      HPI_CTL_ATTR(COMPANDER, 6)
 
-/* Cobranet control attributes.
-   MUST be distinct from all other control attributes.
-   This is so that host side processing can easily identify a Cobranet control
-   and apply additional host side operations (like copying data) as required.
-*/
+/* Cobranet control attributes. */
 #define HPI_COBRANET_SET         HPI_CTL_ATTR(COBRANET, 1)
 #define HPI_COBRANET_GET         HPI_CTL_ATTR(COBRANET, 2)
 #define HPI_COBRANET_SET_DATA    HPI_CTL_ATTR(COBRANET, 3)
@@ -1512,11 +1516,11 @@ struct hpi_control_cache_single {
         struct hpi_control_cache_info i;
         union {
                 struct {        /* volume */
-                        u16 an_log[2];
+                        short an_log[2];
                 } v;
                 struct {        /* peak meter */
-                        u16 an_log_peak[2];
-                        u16 an_logRMS[2];
+                        short an_log_peak[2];
+                        short an_logRMS[2];
                 } p;
                 struct {        /* channel mode */
                         u16 mode;
@@ -1526,7 +1530,7 @@ struct hpi_control_cache_single {
                         u16 source_node_index;
                 } x;
                 struct {        /* level/trim */
-                        u16 an_log[2];
+                        short an_log[2];
                 } l;
                 struct {        /* tuner - partial caching.
                                    some attributes go to the DSP. */
diff --git a/sound/pci/asihpi/hpicmn.c b/sound/pci/asihpi/hpicmn.c
index fcd64539d9ef..dda4f1c6f658 100644
--- a/sound/pci/asihpi/hpicmn.c
+++ b/sound/pci/asihpi/hpicmn.c
@@ -353,7 +353,12 @@ short hpi_check_control_cache(struct hpi_control_cache *p_cache,
                         phr->u.c.param1 = pC->u.t.band;
                 else if ((phm->u.c.attribute == HPI_TUNER_LEVEL)
                         && (phm->u.c.param1 == HPI_TUNER_LEVEL_AVERAGE))
-                        phr->u.c.param1 = pC->u.t.level;
+                        if (pC->u.t.level == HPI_ERROR_ILLEGAL_CACHE_VALUE) {
+                                phr->u.c.param1 = 0;
+                                phr->error =
+                                        HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
+                        } else
+                                phr->u.c.param1 = pC->u.t.level;
                 else
                         found = 0;
                 break;
@@ -397,7 +402,8 @@ short hpi_check_control_cache(struct hpi_control_cache *p_cache,
                         if (pC->u.clk.source_index ==
                                 HPI_ERROR_ILLEGAL_CACHE_VALUE) {
                                 phr->u.c.param1 = 0;
-                                phr->error = HPI_ERROR_INVALID_OPERATION;
+                                phr->error =
+                                        HPI_ERROR_INVALID_CONTROL_ATTRIBUTE;
                         } else
                                 phr->u.c.param1 = pC->u.clk.source_index;
                 } else if (phm->u.c.attribute == HPI_SAMPLECLOCK_SAMPLERATE)
diff --git a/sound/pci/asihpi/hpidebug.c b/sound/pci/asihpi/hpidebug.c
index 4cd85a401b34..949836ec913a 100644
--- a/sound/pci/asihpi/hpidebug.c
+++ b/sound/pci/asihpi/hpidebug.c
@@ -111,7 +111,7 @@ make_treenode_from_array(hpi_control_type_strings, HPI_CONTROL_TYPE_STRINGS)
   &hpi_profile_strings,\
   &hpi_control_strings, \
   &hpi_asyncevent_strings \
-};
+}
         make_treenode_from_array(hpi_function_strings, HPI_FUNCTION_STRINGS)
 
         compile_time_assert(HPI_OBJ_MAXINDEX == 14, obj_list_doesnt_match);
diff --git a/sound/pci/asihpi/hpidebug.h b/sound/pci/asihpi/hpidebug.h
index 44dccadcc25b..a2f0952a99f0 100644
--- a/sound/pci/asihpi/hpidebug.h
+++ b/sound/pci/asihpi/hpidebug.h
@@ -356,7 +356,7 @@ compile_time_assert((HPI_CONTROL_LAST_INDEX + 1 == 27),
         "HPI_SOURCENODE_ADAPTER" \
 }
 
-compile_time_assert((HPI_SOURCENODE_LAST_INDEX - HPI_SOURCENODE_BASE + 1) ==
+compile_time_assert((HPI_SOURCENODE_LAST_INDEX - HPI_SOURCENODE_NONE + 1) ==
         (12), sourcenode_strings_match_defs);
 
 #define HPI_DESTNODE_STRINGS \
@@ -370,7 +370,7 @@ compile_time_assert((HPI_SOURCENODE_LAST_INDEX - HPI_SOURCENODE_BASE + 1) ==
         "HPI_DESTNODE_COBRANET", \
         "HPI_DESTNODE_ANALOG" \
 }
-compile_time_assert((HPI_DESTNODE_LAST_INDEX - HPI_DESTNODE_BASE + 1) == (8),
+compile_time_assert((HPI_DESTNODE_LAST_INDEX - HPI_DESTNODE_NONE + 1) == (8),
         destnode_strings_match_defs);
 
 #define HPI_CONTROL_CHANNEL_MODE_STRINGS \
diff --git a/sound/pci/asihpi/hpifunc.c b/sound/pci/asihpi/hpifunc.c
index 298eef3e20e9..1e92eb6dd509 100644
--- a/sound/pci/asihpi/hpifunc.c
+++ b/sound/pci/asihpi/hpifunc.c
@@ -96,8 +96,7 @@ void hpi_stream_response_to_legacy(struct hpi_stream_res *pSR)
 
 static struct hpi_hsubsys gh_subsys;
 
-struct hpi_hsubsys *hpi_subsys_create(void
-        )
+struct hpi_hsubsys *hpi_subsys_create(void)
 {
         struct hpi_message hm;
         struct hpi_response hr;
@@ -302,6 +301,7 @@ u16 hpi_adapter_set_mode_ex(const struct hpi_hsubsys *ph_subsys,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_ADAPTER,
                 HPI_ADAPTER_SET_MODE);
         hm.adapter_index = adapter_index;
@@ -510,7 +510,7 @@ u16 hpi_adapter_debug_read(const struct hpi_hsubsys *ph_subsys,
         hm.adapter_index = adapter_index;
         hm.u.ax.debug_read.dsp_address = dsp_address;
 
-        if (*count_bytes > sizeof(hr.u.bytes))
+        if (*count_bytes > (int)sizeof(hr.u.bytes))
                 *count_bytes = sizeof(hr.u.bytes);
 
         hm.u.ax.debug_read.count_bytes = *count_bytes;
@@ -976,6 +976,7 @@ u16 hpi_outstream_ancillary_read(const struct hpi_hsubsys *ph_subsys,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_OSTREAM,
                 HPI_OSTREAM_ANC_READ);
         u32TOINDEXES(h_outstream, &hm.adapter_index, &hm.obj_index);
@@ -1581,6 +1582,7 @@ u16 hpi_control_param_set(const struct hpi_hsubsys *ph_subsys,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_SET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -1591,6 +1593,22 @@ u16 hpi_control_param_set(const struct hpi_hsubsys *ph_subsys,
         return hr.error;
 }
 
+static u16 hpi_control_log_set2(u32 h_control, u16 attrib, short sv0,
+        short sv1)
+{
+        struct hpi_message hm;
+        struct hpi_response hr;
+
+        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
+                HPI_CONTROL_SET_STATE);
+        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
+        hm.u.c.attribute = attrib;
+        hm.u.c.an_log_value[0] = sv0;
+        hm.u.c.an_log_value[1] = sv1;
+        hpi_send_recv(&hm, &hr);
+        return hr.error;
+}
+
 static
 u16 hpi_control_param_get(const struct hpi_hsubsys *ph_subsys,
         const u32 h_control, const u16 attrib, u32 param1, u32 param2,
@@ -1598,6 +1616,7 @@ u16 hpi_control_param_get(const struct hpi_hsubsys *ph_subsys,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_GET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -1605,8 +1624,8 @@ u16 hpi_control_param_get(const struct hpi_hsubsys *ph_subsys,
         hm.u.c.param1 = param1;
         hm.u.c.param2 = param2;
         hpi_send_recv(&hm, &hr);
-        if (pparam1)
-                *pparam1 = hr.u.c.param1;
+
+        *pparam1 = hr.u.c.param1;
         if (pparam2)
                 *pparam2 = hr.u.c.param2;
 
@@ -1617,10 +1636,23 @@ u16 hpi_control_param_get(const struct hpi_hsubsys *ph_subsys,
                 hpi_control_param_get(s, h, a, 0, 0, p1, NULL)
 #define hpi_control_param2_get(s, h, a, p1, p2) \
                 hpi_control_param_get(s, h, a, 0, 0, p1, p2)
-#define hpi_control_ex_param1_get(s, h, a, p1) \
-                hpi_control_ex_param_get(s, h, a, 0, 0, p1, NULL)
-#define hpi_control_ex_param2_get(s, h, a, p1, p2) \
-                hpi_control_ex_param_get(s, h, a, 0, 0, p1, p2)
+
+static u16 hpi_control_log_get2(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u16 attrib, short *sv0, short *sv1)
+{
+        struct hpi_message hm;
+        struct hpi_response hr;
+        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
+                HPI_CONTROL_GET_STATE);
+        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
+        hm.u.c.attribute = attrib;
+
+        hpi_send_recv(&hm, &hr);
+        *sv0 = hr.u.c.an_log_value[0];
+        if (sv1)
+                *sv1 = hr.u.c.an_log_value[1];
+        return hr.error;
+}
 
 static
 u16 hpi_control_query(const struct hpi_hsubsys *ph_subsys,
@@ -1629,6 +1661,7 @@ u16 hpi_control_query(const struct hpi_hsubsys *ph_subsys,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_GET_INFO);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -1643,9 +1676,8 @@ u16 hpi_control_query(const struct hpi_hsubsys *ph_subsys,
         return hr.error;
 }
 
-static u16 hpi_control_get_string(const struct hpi_hsubsys *ph_subsys,
-        const u32 h_control, const u16 attribute, char *psz_string,
-        const u32 string_length)
+static u16 hpi_control_get_string(const u32 h_control, const u16 attribute,
+        char *psz_string, const u32 string_length)
 {
         unsigned int sub_string_index = 0, j = 0;
         char c = 0;
@@ -1916,6 +1948,7 @@ u16 hpi_cobranet_hmi_write(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROLEX,
                 HPI_CONTROL_SET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -1941,6 +1974,7 @@ u16 hpi_cobranet_hmi_read(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROLEX,
                 HPI_CONTROL_GET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -1980,6 +2014,7 @@ u16 hpi_cobranet_hmi_get_status(const struct hpi_hsubsys *ph_subsys,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROLEX,
                 HPI_CONTROL_GET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2006,6 +2041,7 @@ u16 hpi_cobranet_getI_paddress(const struct hpi_hsubsys *ph_subsys,
         u32 byte_count;
         u32 iP;
         u16 error;
+
         error = hpi_cobranet_hmi_read(ph_subsys, h_control,
                 HPI_COBRANET_HMI_cobra_ip_mon_currentIP, 4, &byte_count,
                 (u8 *)&iP);
@@ -2082,6 +2118,7 @@ u16 hpi_cobranet_getMA_caddress(const struct hpi_hsubsys *ph_subsys,
         u32 byte_count;
         u16 error;
         u32 mAC;
+
         error = hpi_cobranet_hmi_read(ph_subsys, h_control,
                 HPI_COBRANET_HMI_cobra_if_phy_address, 4, &byte_count,
                 (u8 *)&mAC);
@@ -2103,53 +2140,111 @@ u16 hpi_cobranet_getMA_caddress(const struct hpi_hsubsys *ph_subsys,
         return error;
 }
 
-u16 hpi_compander_set(const struct hpi_hsubsys *ph_subsys, u32 h_control,
-        u16 attack, u16 decay, short ratio100, short threshold0_01dB,
-        short makeup_gain0_01dB)
+u16 hpi_compander_set_enable(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 enable)
+{
+        return hpi_control_param_set(ph_subsys, h_control, HPI_GENERIC_ENABLE,
+                enable, 0);
+}
+
+u16 hpi_compander_get_enable(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 *enable)
+{
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_GENERIC_ENABLE, enable);
+}
+
+u16 hpi_compander_set_makeup_gain(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, short makeup_gain0_01dB)
+{
+        return hpi_control_log_set2(h_control, HPI_COMPANDER_MAKEUPGAIN,
+                makeup_gain0_01dB, 0);
+}
+
+u16 hpi_compander_get_makeup_gain(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, short *makeup_gain0_01dB)
+{
+        return hpi_control_log_get2(ph_subsys, h_control,
+                HPI_COMPANDER_MAKEUPGAIN, makeup_gain0_01dB, NULL);
+}
+
+u16 hpi_compander_set_attack_time_constant(const struct hpi_hsubsys
+        *ph_subsys, u32 h_control, unsigned int index, u32 attack)
+{
+        return hpi_control_param_set(ph_subsys, h_control,
+                HPI_COMPANDER_ATTACK, attack, index);
+}
+
+u16 hpi_compander_get_attack_time_constant(const struct hpi_hsubsys
+        *ph_subsys, u32 h_control, unsigned int index, u32 *attack)
+{
+        return hpi_control_param_get(ph_subsys, h_control,
+                HPI_COMPANDER_ATTACK, 0, index, attack, NULL);
+}
+
+u16 hpi_compander_set_decay_time_constant(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, unsigned int index, u32 decay)
+{
+        return hpi_control_param_set(ph_subsys, h_control,
+                HPI_COMPANDER_DECAY, decay, index);
+}
+
+u16 hpi_compander_get_decay_time_constant(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, unsigned int index, u32 *decay)
+{
+        return hpi_control_param_get(ph_subsys, h_control,
+                HPI_COMPANDER_DECAY, 0, index, decay, NULL);
+
+}
+
+u16 hpi_compander_set_threshold(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, unsigned int index, short threshold0_01dB)
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_SET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
-
-        hm.u.c.param1 = attack + ((u32)ratio100 << 16);
-        hm.u.c.param2 = (decay & 0xFFFFL);
+        hm.u.c.attribute = HPI_COMPANDER_THRESHOLD;
+        hm.u.c.param2 = index;
         hm.u.c.an_log_value[0] = threshold0_01dB;
-        hm.u.c.an_log_value[1] = makeup_gain0_01dB;
-        hm.u.c.attribute = HPI_COMPANDER_PARAMS;
 
         hpi_send_recv(&hm, &hr);
 
         return hr.error;
 }
 
-u16 hpi_compander_get(const struct hpi_hsubsys *ph_subsys, u32 h_control,
-        u16 *pw_attack, u16 *pw_decay, short *pw_ratio100,
-        short *pn_threshold0_01dB, short *pn_makeup_gain0_01dB)
+u16 hpi_compander_get_threshold(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, unsigned int index, short *threshold0_01dB)
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_GET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
-        hm.u.c.attribute = HPI_COMPANDER_PARAMS;
+        hm.u.c.attribute = HPI_COMPANDER_THRESHOLD;
+        hm.u.c.param2 = index;
 
         hpi_send_recv(&hm, &hr);
+        *threshold0_01dB = hr.u.c.an_log_value[0];
 
-        if (pw_attack)
-                *pw_attack = (short)(hr.u.c.param1 & 0xFFFF);
-        if (pw_decay)
-                *pw_decay = (short)(hr.u.c.param2 & 0xFFFF);
-        if (pw_ratio100)
-                *pw_ratio100 = (short)(hr.u.c.param1 >> 16);
+        return hr.error;
+}
 
-        if (pn_threshold0_01dB)
-                *pn_threshold0_01dB = hr.u.c.an_log_value[0];
-        if (pn_makeup_gain0_01dB)
-                *pn_makeup_gain0_01dB = hr.u.c.an_log_value[1];
+u16 hpi_compander_set_ratio(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, u32 ratio100)
+{
+        return hpi_control_param_set(ph_subsys, h_control,
+                HPI_COMPANDER_RATIO, ratio100, index);
+}
 
-        return hr.error;
+u16 hpi_compander_get_ratio(const struct hpi_hsubsys *ph_subsys,
+        u32 h_control, u32 index, u32 *ratio100)
+{
+        return hpi_control_param_get(ph_subsys, h_control,
+                HPI_COMPANDER_RATIO, 0, index, ratio100, NULL);
 }
 
 u16 hpi_level_query_range(const struct hpi_hsubsys *ph_subsys, u32 h_control,
@@ -2157,6 +2252,7 @@ u16 hpi_level_query_range(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_GET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2181,37 +2277,16 @@ u16 hpi_level_set_gain(const struct hpi_hsubsys *ph_subsys, u32 h_control,
         short an_gain0_01dB[HPI_MAX_CHANNELS]
         )
 {
-        struct hpi_message hm;
-        struct hpi_response hr;
-
-        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
-                HPI_CONTROL_SET_STATE);
-        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
-        memcpy(hm.u.c.an_log_value, an_gain0_01dB,
-                sizeof(short) * HPI_MAX_CHANNELS);
-        hm.u.c.attribute = HPI_LEVEL_GAIN;
-
-        hpi_send_recv(&hm, &hr);
-
-        return hr.error;
+        return hpi_control_log_set2(h_control, HPI_LEVEL_GAIN,
+                an_gain0_01dB[0], an_gain0_01dB[1]);
 }
 
 u16 hpi_level_get_gain(const struct hpi_hsubsys *ph_subsys, u32 h_control,
         short an_gain0_01dB[HPI_MAX_CHANNELS]
         )
 {
-        struct hpi_message hm;
-        struct hpi_response hr;
-        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
-                HPI_CONTROL_GET_STATE);
-        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
-        hm.u.c.attribute = HPI_LEVEL_GAIN;
-
-        hpi_send_recv(&hm, &hr);
-
-        memcpy(an_gain0_01dB, hr.u.c.an_log_value,
-                sizeof(short) * HPI_MAX_CHANNELS);
-        return hr.error;
+        return hpi_control_log_get2(ph_subsys, h_control, HPI_LEVEL_GAIN,
+                &an_gain0_01dB[0], &an_gain0_01dB[1]);
 }
 
 u16 hpi_meter_query_channels(const struct hpi_hsubsys *ph_subsys,
@@ -2413,6 +2488,7 @@ u16 hpi_parametricEQ__get_band(const struct hpi_hsubsys *ph_subsys,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_GET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2439,6 +2515,7 @@ u16 hpi_parametricEQ__set_band(const struct hpi_hsubsys *ph_subsys,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_SET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2460,6 +2537,7 @@ u16 hpi_parametricEQ__get_coeffs(const struct hpi_hsubsys *ph_subsys,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_GET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2623,8 +2701,8 @@ u16 hpi_tone_detector_get_frequency(const struct hpi_hsubsys *ph_subsys,
 u16 hpi_tone_detector_get_state(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 *state)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
-                HPI_TONEDETECTOR_STATE, 0, 0, (u32 *)state, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_TONEDETECTOR_STATE, state);
 }
 
 u16 hpi_tone_detector_set_enable(const struct hpi_hsubsys *ph_subsys,
@@ -2637,8 +2715,8 @@ u16 hpi_tone_detector_set_enable(const struct hpi_hsubsys *ph_subsys,
 u16 hpi_tone_detector_get_enable(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 *enable)
 {
-        return hpi_control_param_get(ph_subsys, h_control, HPI_GENERIC_ENABLE,
-                0, 0, (u32 *)enable, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_GENERIC_ENABLE, enable);
 }
 
 u16 hpi_tone_detector_set_event_enable(const struct hpi_hsubsys *ph_subsys,
@@ -2651,8 +2729,8 @@ u16 hpi_tone_detector_set_event_enable(const struct hpi_hsubsys *ph_subsys,
 u16 hpi_tone_detector_get_event_enable(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 *event_enable)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
-                HPI_GENERIC_EVENT_ENABLE, 0, 0, (u32 *)event_enable, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_GENERIC_EVENT_ENABLE, event_enable);
 }
 
 u16 hpi_tone_detector_set_threshold(const struct hpi_hsubsys *ph_subsys,
@@ -2665,15 +2743,15 @@ u16 hpi_tone_detector_set_threshold(const struct hpi_hsubsys *ph_subsys,
 u16 hpi_tone_detector_get_threshold(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, int *threshold)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
-                HPI_TONEDETECTOR_THRESHOLD, 0, 0, (u32 *)threshold, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_TONEDETECTOR_THRESHOLD, (u32 *)threshold);
 }
 
 u16 hpi_silence_detector_get_state(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 *state)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
-                HPI_SILENCEDETECTOR_STATE, 0, 0, (u32 *)state, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_SILENCEDETECTOR_STATE, state);
 }
 
 u16 hpi_silence_detector_set_enable(const struct hpi_hsubsys *ph_subsys,
@@ -2686,50 +2764,50 @@ u16 hpi_silence_detector_set_enable(const struct hpi_hsubsys *ph_subsys,
 u16 hpi_silence_detector_get_enable(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 *enable)
 {
-        return hpi_control_param_get(ph_subsys, h_control, HPI_GENERIC_ENABLE,
-                0, 0, (u32 *)enable, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_GENERIC_ENABLE, enable);
 }
 
 u16 hpi_silence_detector_set_event_enable(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 event_enable)
 {
         return hpi_control_param_set(ph_subsys, h_control,
-                HPI_GENERIC_EVENT_ENABLE, (u32)event_enable, 0);
+                HPI_GENERIC_EVENT_ENABLE, event_enable, 0);
 }
 
 u16 hpi_silence_detector_get_event_enable(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 *event_enable)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
-                HPI_GENERIC_EVENT_ENABLE, 0, 0, (u32 *)event_enable, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_GENERIC_EVENT_ENABLE, event_enable);
 }
 
 u16 hpi_silence_detector_set_delay(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 delay)
 {
         return hpi_control_param_set(ph_subsys, h_control,
-                HPI_SILENCEDETECTOR_DELAY, (u32)delay, 0);
+                HPI_SILENCEDETECTOR_DELAY, delay, 0);
 }
 
 u16 hpi_silence_detector_get_delay(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 *delay)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
-                HPI_SILENCEDETECTOR_DELAY, 0, 0, (u32 *)delay, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_SILENCEDETECTOR_DELAY, delay);
 }
 
 u16 hpi_silence_detector_set_threshold(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, int threshold)
 {
         return hpi_control_param_set(ph_subsys, h_control,
-                HPI_SILENCEDETECTOR_THRESHOLD, (u32)threshold, 0);
+                HPI_SILENCEDETECTOR_THRESHOLD, threshold, 0);
 }
 
 u16 hpi_silence_detector_get_threshold(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, int *threshold)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
-                HPI_SILENCEDETECTOR_THRESHOLD, 0, 0, (u32 *)threshold, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_SILENCEDETECTOR_THRESHOLD, (u32 *)threshold);
 }
 
 u16 hpi_tuner_query_band(const struct hpi_hsubsys *ph_subsys,
@@ -2822,6 +2900,7 @@ u16 hpi_tuner_getRF_level(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_GET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2838,6 +2917,7 @@ u16 hpi_tuner_get_rawRF_level(const struct hpi_hsubsys *ph_subsys,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_GET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2894,14 +2974,14 @@ u16 hpi_tuner_get_program(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 u16 hpi_tuner_get_hd_radio_dsp_version(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, char *psz_dsp_version, const u32 string_size)
 {
-        return hpi_control_get_string(ph_subsys, h_control,
+        return hpi_control_get_string(h_control,
                 HPI_TUNER_HDRADIO_DSP_VERSION, psz_dsp_version, string_size);
 }
 
 u16 hpi_tuner_get_hd_radio_sdk_version(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, char *psz_sdk_version, const u32 string_size)
 {
-        return hpi_control_get_string(ph_subsys, h_control,
+        return hpi_control_get_string(h_control,
                 HPI_TUNER_HDRADIO_SDK_VERSION, psz_sdk_version, string_size);
 }
 
@@ -2942,15 +3022,15 @@ u16 hpi_tuner_get_mode(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 u16 hpi_tuner_get_hd_radio_signal_quality(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 *pquality)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
-                HPI_TUNER_HDRADIO_SIGNAL_QUALITY, 0, 0, pquality, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_TUNER_HDRADIO_SIGNAL_QUALITY, pquality);
 }
 
 u16 hpi_tuner_get_hd_radio_signal_blend(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 *pblend)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
-                HPI_TUNER_HDRADIO_BLEND, 0, 0, pblend, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_TUNER_HDRADIO_BLEND, pblend);
 }
 
 u16 hpi_tuner_set_hd_radio_signal_blend(const struct hpi_hsubsys *ph_subsys,
@@ -2965,6 +3045,7 @@ u16 hpi_tuner_getRDS(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_GET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -2981,43 +3062,43 @@ u16 hpi_tuner_getRDS(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 u16 HPI_PAD__get_channel_name(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, char *psz_string, const u32 data_length)
 {
-        return hpi_control_get_string(ph_subsys, h_control,
-                HPI_PAD_CHANNEL_NAME, psz_string, data_length);
+        return hpi_control_get_string(h_control, HPI_PAD_CHANNEL_NAME,
+                psz_string, data_length);
 }
 
 u16 HPI_PAD__get_artist(const struct hpi_hsubsys *ph_subsys, u32 h_control,
         char *psz_string, const u32 data_length)
 {
-        return hpi_control_get_string(ph_subsys, h_control, HPI_PAD_ARTIST,
-                psz_string, data_length);
+        return hpi_control_get_string(h_control, HPI_PAD_ARTIST, psz_string,
+                data_length);
 }
 
 u16 HPI_PAD__get_title(const struct hpi_hsubsys *ph_subsys, u32 h_control,
         char *psz_string, const u32 data_length)
 {
-        return hpi_control_get_string(ph_subsys, h_control, HPI_PAD_TITLE,
-                psz_string, data_length);
+        return hpi_control_get_string(h_control, HPI_PAD_TITLE, psz_string,
+                data_length);
 }
 
 u16 HPI_PAD__get_comment(const struct hpi_hsubsys *ph_subsys, u32 h_control,
         char *psz_string, const u32 data_length)
 {
-        return hpi_control_get_string(ph_subsys, h_control, HPI_PAD_COMMENT,
-                psz_string, data_length);
+        return hpi_control_get_string(h_control, HPI_PAD_COMMENT, psz_string,
+                data_length);
 }
 
 u16 HPI_PAD__get_program_type(const struct hpi_hsubsys *ph_subsys,
         u32 h_control, u32 *ppTY)
 {
-        return hpi_control_param_get(ph_subsys, h_control,
-                HPI_PAD_PROGRAM_TYPE, 0, 0, ppTY, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_PAD_PROGRAM_TYPE, ppTY);
 }
 
 u16 HPI_PAD__get_rdsPI(const struct hpi_hsubsys *ph_subsys, u32 h_control,
         u32 *ppI)
 {
-        return hpi_control_param_get(ph_subsys, h_control, HPI_PAD_PROGRAM_ID,
-                0, 0, ppI, NULL);
+        return hpi_control_param1_get(ph_subsys, h_control,
+                HPI_PAD_PROGRAM_ID, ppI);
 }
 
 u16 hpi_volume_query_channels(const struct hpi_hsubsys *ph_subsys,
@@ -3031,36 +3112,16 @@ u16 hpi_volume_set_gain(const struct hpi_hsubsys *ph_subsys, u32 h_control,
         short an_log_gain[HPI_MAX_CHANNELS]
         )
 {
-        struct hpi_message hm;
-        struct hpi_response hr;
-        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
-                HPI_CONTROL_SET_STATE);
-        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
-        memcpy(hm.u.c.an_log_value, an_log_gain,
-                sizeof(short) * HPI_MAX_CHANNELS);
-        hm.u.c.attribute = HPI_VOLUME_GAIN;
-
-        hpi_send_recv(&hm, &hr);
-
-        return hr.error;
+        return hpi_control_log_set2(h_control, HPI_VOLUME_GAIN,
+                an_log_gain[0], an_log_gain[1]);
 }
 
 u16 hpi_volume_get_gain(const struct hpi_hsubsys *ph_subsys, u32 h_control,
         short an_log_gain[HPI_MAX_CHANNELS]
         )
 {
-        struct hpi_message hm;
-        struct hpi_response hr;
-        hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
-                HPI_CONTROL_GET_STATE);
-        u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
-        hm.u.c.attribute = HPI_VOLUME_GAIN;
-
-        hpi_send_recv(&hm, &hr);
-
-        memcpy(an_log_gain, hr.u.c.an_log_value,
-                sizeof(short) * HPI_MAX_CHANNELS);
-        return hr.error;
+        return hpi_control_log_get2(ph_subsys, h_control, HPI_VOLUME_GAIN,
+                &an_log_gain[0], &an_log_gain[1]);
 }
 
 u16 hpi_volume_query_range(const struct hpi_hsubsys *ph_subsys, u32 h_control,
@@ -3068,6 +3129,7 @@ u16 hpi_volume_query_range(const struct hpi_hsubsys *ph_subsys, u32 h_control,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_GET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -3094,6 +3156,7 @@ u16 hpi_volume_auto_fade_profile(const struct hpi_hsubsys *ph_subsys,
 {
         struct hpi_message hm;
         struct hpi_response hr;
+
         hpi_init_message_response(&hm, &hr, HPI_OBJ_CONTROL,
                 HPI_CONTROL_SET_STATE);
         u32TOINDEXES(h_control, &hm.adapter_index, &hm.obj_index);
@@ -3170,43 +3233,42 @@ static size_t entity_type_to_size[LAST_ENTITY_TYPE] = {
         6 * sizeof(char),
 };
 
-inline size_t hpi_entity_size(struct hpi_entity *entity_ptr)
+static inline size_t hpi_entity_size(struct hpi_entity *entity_ptr)
 {
         return entity_ptr->header.size;
 }
 
-inline size_t hpi_entity_header_size(struct hpi_entity *entity_ptr)
+static inline size_t hpi_entity_header_size(struct hpi_entity *entity_ptr)
 {
         return sizeof(entity_ptr->header);
 }
 
-inline size_t hpi_entity_value_size(struct hpi_entity *entity_ptr)
+static inline size_t hpi_entity_value_size(struct hpi_entity *entity_ptr)
 {
         return hpi_entity_size(entity_ptr) -
                 hpi_entity_header_size(entity_ptr);
 }
 
-inline size_t hpi_entity_item_count(struct hpi_entity *entity_ptr)
+static inline size_t hpi_entity_item_count(struct hpi_entity *entity_ptr)
 {
         return hpi_entity_value_size(entity_ptr) /
                 entity_type_to_size[entity_ptr->header.type];
 }
 
-inline struct hpi_entity *hpi_entity_ptr_to_next(struct hpi_entity
+static inline struct hpi_entity *hpi_entity_ptr_to_next(struct hpi_entity
         *entity_ptr)
 {
-        return (void *)(((uint8_t *) entity_ptr) +
-                hpi_entity_size(entity_ptr));
+        return (void *)(((u8 *)entity_ptr) + hpi_entity_size(entity_ptr));
 }
 
-inline u16 hpi_entity_check_type(const enum e_entity_type t)
+static inline u16 hpi_entity_check_type(const enum e_entity_type t)
 {
         if (t >= 0 && t < STR_TYPE_FIELD_MAX)
                 return 0;
         return HPI_ERROR_ENTITY_TYPE_INVALID;
 }
 
-inline u16 hpi_entity_check_role(const enum e_entity_role r)
+static inline u16 hpi_entity_check_role(const enum e_entity_role r)
 {
         if (r >= 0 && r < STR_ROLE_FIELD_MAX)
                 return 0;
@@ -3624,6 +3686,7 @@ u16 hpi_async_event_wait(const struct hpi_hsubsys *ph_subsys, u32 h_async,
         u16 maximum_events, struct hpi_async_event *p_events,
         u16 *pw_number_returned)
 {
+
         return 0;
 }
 
diff --git a/sound/pci/asihpi/hpimsgx.c b/sound/pci/asihpi/hpimsgx.c
index 2ee90dc3d897..f01ab964f602 100644
--- a/sound/pci/asihpi/hpimsgx.c
+++ b/sound/pci/asihpi/hpimsgx.c
@@ -741,7 +741,7 @@ static void HPIMSGX__reset(u16 adapter_index)
                 hpi_init_response(&hr, HPI_OBJ_SUBSYSTEM,
                         HPI_SUBSYS_FIND_ADAPTERS, 0);
                 memcpy(&gRESP_HPI_SUBSYS_FIND_ADAPTERS, &hr,
-                        sizeof(&gRESP_HPI_SUBSYS_FIND_ADAPTERS));
+                        sizeof(gRESP_HPI_SUBSYS_FIND_ADAPTERS));
 
                 for (adapter = 0; adapter < HPI_MAX_ADAPTERS; adapter++) {
 
diff --git a/sound/pci/asihpi/hpioctl.c b/sound/pci/asihpi/hpioctl.c
index 7396ac54e99f..62895a719fcb 100644
--- a/sound/pci/asihpi/hpioctl.c
+++ b/sound/pci/asihpi/hpioctl.c
@@ -121,11 +121,17 @@ long asihpi_hpi_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         phpi_ioctl_data = (struct hpi_ioctl_linux __user *)arg;
 
         /* Read the message and response pointers from user space.  */
-        get_user(puhm, &phpi_ioctl_data->phm);
-        get_user(puhr, &phpi_ioctl_data->phr);
+        if (get_user(puhm, &phpi_ioctl_data->phm) ||
+            get_user(puhr, &phpi_ioctl_data->phr)) {
+                err = -EFAULT;
+                goto out;
+        }
 
         /* Now read the message size and data from user space.  */
-        get_user(hm->h.size, (u16 __user *)puhm);
+        if (get_user(hm->h.size, (u16 __user *)puhm)) {
+                err = -EFAULT;
+                goto out;
+        }
         if (hm->h.size > sizeof(*hm))
                 hm->h.size = sizeof(*hm);
 
@@ -138,7 +144,10 @@ long asihpi_hpi_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 goto out;
         }
 
-        get_user(res_max_size, (u16 __user *)puhr);
+        if (get_user(res_max_size, (u16 __user *)puhr)) {
+                err = -EFAULT;
+                goto out;
+        }
         /* printk(KERN_INFO "user response size %d\n", res_max_size); */
         if (res_max_size < sizeof(struct hpi_response_header)) {
                 HPI_DEBUG_LOG(WARNING, "small res size %d\n", res_max_size);
@@ -464,9 +473,7 @@ void __init asihpi_init(void)
 
         memset(adapters, 0, sizeof(adapters));
 
-        printk(KERN_INFO "ASIHPI driver %d.%02d.%02d\n",
-                HPI_VER_MAJOR(HPI_VER), HPI_VER_MINOR(HPI_VER),
-                HPI_VER_RELEASE(HPI_VER));
+        printk(KERN_INFO "ASIHPI driver " HPI_VER_STRING "\n");
 
         hpi_init_message_response(&hm, &hr, HPI_OBJ_SUBSYSTEM,
                 HPI_SUBSYS_DRIVER_LOAD);
diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c
index 0a3d3d6e77b4..8e69620da20b 100644
--- a/sound/pci/ca0106/ca0106_main.c
+++ b/sound/pci/ca0106/ca0106_main.c
@@ -1002,29 +1002,27 @@ snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream)
         struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_ca0106_pcm *epcm = runtime->private_data;
-        snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0;
+        unsigned int ptr, prev_ptr;
         int channel = epcm->channel_id;
+        int timeout = 10;
 
         if (!epcm->running)
                 return 0;
 
-        ptr3 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
-        ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel);
-        ptr4 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
-        if (ptr3 != ptr4) ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel);
-        ptr2 = bytes_to_frames(runtime, ptr1);
-        ptr2+= (ptr4 >> 3) * runtime->period_size;
-        ptr=ptr2;
-        if (ptr >= runtime->buffer_size)
-                ptr -= runtime->buffer_size;
-        /*
-        printk(KERN_DEBUG "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, "
-               "buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n",
-               ptr1, ptr2, ptr, (int)runtime->buffer_size,
-               (int)runtime->period_size, (int)runtime->frame_bits,
-               (int)runtime->rate);
-        */
-        return ptr;
+        prev_ptr = -1;
+        do {
+                ptr = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
+                ptr = (ptr >> 3) * runtime->period_size;
+                ptr += bytes_to_frames(runtime,
+                        snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel));
+                if (ptr >= runtime->buffer_size)
+                        ptr -= runtime->buffer_size;
+                if (prev_ptr == ptr)
+                        return ptr;
+                prev_ptr = ptr;
+        } while (--timeout);
+        snd_printk(KERN_WARNING "ca0106: unstable DMA pointer!\n");
+        return 0;
 }
 
 /* pointer_capture callback */
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index 668a5ec04499..20763dd03fa0 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -2250,6 +2250,8 @@ static int snd_echo_resume(struct pci_dev *pci)
         DE_INIT(("resume start\n"));
         pci_restore_state(pci);
         commpage_bak = kmalloc(sizeof(struct echoaudio), GFP_KERNEL);
+        if (commpage_bak == NULL)
+                return -ENOMEM;
         commpage = chip->comm_page;
         memcpy(commpage_bak, commpage, sizeof(struct comm_page));
 
diff --git a/sound/pci/emu10k1/emu10k1.c b/sound/pci/emu10k1/emu10k1.c
index 4203782d7cb7..aff8387c45cf 100644
--- a/sound/pci/emu10k1/emu10k1.c
+++ b/sound/pci/emu10k1/emu10k1.c
@@ -52,6 +52,7 @@ static int max_synth_voices[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 64};
 static int max_buffer_size[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 128};
 static int enable_ir[SNDRV_CARDS];
 static uint subsystem[SNDRV_CARDS]; /* Force card subsystem model */
+static uint delay_pcm_irq[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for the EMU10K1 soundcard.");
@@ -73,6 +74,8 @@ module_param_array(enable_ir, bool, NULL, 0444);
 MODULE_PARM_DESC(enable_ir, "Enable IR.");
 module_param_array(subsystem, uint, NULL, 0444);
 MODULE_PARM_DESC(subsystem, "Force card subsystem model.");
+module_param_array(delay_pcm_irq, uint, NULL, 0444);
+MODULE_PARM_DESC(delay_pcm_irq, "Delay PCM interrupt by specified number of samples (default 0).");
 /*
  * Class 0401: 1102:0008 (rev 00) Subsystem: 1102:1001 -> Audigy2 Value  Model:SB0400
  */
@@ -127,6 +130,7 @@ static int __devinit snd_card_emu10k1_probe(struct pci_dev *pci,
                                       &emu)) < 0)
                 goto error;
         card->private_data = emu;
+        emu->delay_pcm_irq = delay_pcm_irq[dev] & 0x1f;
         if ((err = snd_emu10k1_pcm(emu, 0, NULL)) < 0)
                 goto error;
         if ((err = snd_emu10k1_pcm_mic(emu, 1, NULL)) < 0)
diff --git a/sound/pci/emu10k1/emumpu401.c b/sound/pci/emu10k1/emumpu401.c
index 8578c70c61f2..bab564824efe 100644
--- a/sound/pci/emu10k1/emumpu401.c
+++ b/sound/pci/emu10k1/emumpu401.c
@@ -321,7 +321,7 @@ static struct snd_rawmidi_ops snd_emu10k1_midi_input =
 
 static void snd_emu10k1_midi_free(struct snd_rawmidi *rmidi)
 {
-        struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)rmidi->private_data;
+        struct snd_emu10k1_midi *midi = rmidi->private_data;
         midi->interrupt = NULL;
         midi->rmidi = NULL;
 }
diff --git a/sound/pci/emu10k1/emupcm.c b/sound/pci/emu10k1/emupcm.c
index 55b83ef73c63..622bace148e3 100644
--- a/sound/pci/emu10k1/emupcm.c
+++ b/sound/pci/emu10k1/emupcm.c
@@ -332,7 +332,7 @@ static void snd_emu10k1_pcm_init_voice(struct snd_emu10k1 *emu,
                 evoice->epcm->ccca_start_addr = start_addr + ccis;
                 if (extra) {
                         start_addr += ccis;
-                        end_addr += ccis;
+                        end_addr += ccis + emu->delay_pcm_irq;
                 }
                 if (stereo && !extra) {
                         snd_emu10k1_ptr_write(emu, CPF, voice, CPF_STEREO_MASK);
@@ -360,7 +360,9 @@ static void snd_emu10k1_pcm_init_voice(struct snd_emu10k1 *emu,
         /* Assumption that PT is already 0 so no harm overwriting */
         snd_emu10k1_ptr_write(emu, PTRX, voice, (send_amount[0] << 8) | send_amount[1]);
         snd_emu10k1_ptr_write(emu, DSL, voice, end_addr | (send_amount[3] << 24));
-        snd_emu10k1_ptr_write(emu, PSST, voice, start_addr | (send_amount[2] << 24));
+        snd_emu10k1_ptr_write(emu, PSST, voice,
+                        (start_addr + (extra ? emu->delay_pcm_irq : 0)) |
+                        (send_amount[2] << 24));
         if (emu->card_capabilities->emu_model)
                 pitch_target = PITCH_48000; /* Disable interpolators on emu1010 card */
         else 
@@ -732,6 +734,23 @@ static void snd_emu10k1_playback_stop_voice(struct snd_emu10k1 *emu, struct snd_
         snd_emu10k1_ptr_write(emu, IP, voice, 0);
 }
 
+static inline void snd_emu10k1_playback_mangle_extra(struct snd_emu10k1 *emu,
+                struct snd_emu10k1_pcm *epcm,
+                struct snd_pcm_substream *substream,
+                struct snd_pcm_runtime *runtime)
+{
+        unsigned int ptr, period_pos;
+
+        /* try to sychronize the current position for the interrupt
+           source voice */
+        period_pos = runtime->status->hw_ptr - runtime->hw_ptr_interrupt;
+        period_pos %= runtime->period_size;
+        ptr = snd_emu10k1_ptr_read(emu, CCCA, epcm->extra->number);
+        ptr &= ~0x00ffffff;
+        ptr |= epcm->ccca_start_addr + period_pos;
+        snd_emu10k1_ptr_write(emu, CCCA, epcm->extra->number, ptr);
+}
+
 static int snd_emu10k1_playback_trigger(struct snd_pcm_substream *substream,
                                         int cmd)
 {
@@ -753,6 +772,8 @@ static int snd_emu10k1_playback_trigger(struct snd_pcm_substream *substream,
                 /* follow thru */
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
         case SNDRV_PCM_TRIGGER_RESUME:
+                if (cmd == SNDRV_PCM_TRIGGER_PAUSE_RELEASE)
+                        snd_emu10k1_playback_mangle_extra(emu, epcm, substream, runtime);
                 mix = &emu->pcm_mixer[substream->number];
                 snd_emu10k1_playback_prepare_voice(emu, epcm->voices[0], 1, 0, mix);
                 snd_emu10k1_playback_prepare_voice(emu, epcm->voices[1], 0, 0, mix);
@@ -869,8 +890,9 @@ static snd_pcm_uframes_t snd_emu10k1_playback_pointer(struct snd_pcm_substream *
 #endif
         /*
         printk(KERN_DEBUG
-               "ptr = 0x%x, buffer_size = 0x%x, period_size = 0x%x\n",
-               ptr, runtime->buffer_size, runtime->period_size);
+               "ptr = 0x%lx, buffer_size = 0x%lx, period_size = 0x%lx\n",
+               (long)ptr, (long)runtime->buffer_size,
+               (long)runtime->period_size);
         */
         return ptr;
 }
diff --git a/sound/pci/emu10k1/memory.c b/sound/pci/emu10k1/memory.c
index ffb1ddb8dc28..957a311514c8 100644
--- a/sound/pci/emu10k1/memory.c
+++ b/sound/pci/emu10k1/memory.c
@@ -310,8 +310,10 @@ snd_emu10k1_alloc_pages(struct snd_emu10k1 *emu, struct snd_pcm_substream *subst
         if (snd_BUG_ON(!hdr))
                 return NULL;
 
+        idx = runtime->period_size >= runtime->buffer_size ?
+                                        (emu->delay_pcm_irq * 2) : 0;
         mutex_lock(&hdr->block_mutex);
-        blk = search_empty(emu, runtime->dma_bytes);
+        blk = search_empty(emu, runtime->dma_bytes + idx);
         if (blk == NULL) {
                 mutex_unlock(&hdr->block_mutex);
                 return NULL;
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index ba2098d20ccc..14829210ef0b 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -396,15 +396,18 @@ int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
                         }
                         for (n = prev_nid + 1; n <= val; n++) {
                                 if (conns >= max_conns) {
-                                        snd_printk(KERN_ERR
-                                                   "Too many connections\n");
+                                        snd_printk(KERN_ERR "hda_codec: "
+                                                   "Too many connections %d for NID 0x%x\n",
+                                                   conns, nid);
                                         return -EINVAL;
                                 }
                                 conn_list[conns++] = n;
                         }
                 } else {
                         if (conns >= max_conns) {
-                                snd_printk(KERN_ERR "Too many connections\n");
+                                snd_printk(KERN_ERR "hda_codec: "
+                                           "Too many connections %d for NID 0x%x\n",
+                                           conns, nid);
                                 return -EINVAL;
                         }
                         conn_list[conns++] = val;
@@ -586,6 +589,7 @@ int /*__devinit*/ snd_hda_bus_new(struct snd_card *card,
         bus->ops = temp->ops;
 
         mutex_init(&bus->cmd_mutex);
+        mutex_init(&bus->prepare_mutex);
         INIT_LIST_HEAD(&bus->codec_list);
 
         snprintf(bus->workq_name, sizeof(bus->workq_name),
@@ -730,15 +734,17 @@ static void /*__devinit*/ setup_fg_nodes(struct hda_codec *codec)
         total_nodes = snd_hda_get_sub_nodes(codec, AC_NODE_ROOT, &nid);
         for (i = 0; i < total_nodes; i++, nid++) {
                 function_id = snd_hda_param_read(codec, nid,
-                                                AC_PAR_FUNCTION_TYPE) & 0xff;
-                switch (function_id) {
+                                                AC_PAR_FUNCTION_TYPE);
+                switch (function_id & 0xff) {
                 case AC_GRP_AUDIO_FUNCTION:
                         codec->afg = nid;
-                        codec->function_id = function_id;
+                        codec->afg_function_id = function_id & 0xff;
+                        codec->afg_unsol = (function_id >> 8) & 1;
                         break;
                 case AC_GRP_MODEM_FUNCTION:
                         codec->mfg = nid;
-                        codec->function_id = function_id;
+                        codec->mfg_function_id = function_id & 0xff;
+                        codec->mfg_unsol = (function_id >> 8) & 1;
                         break;
                 default:
                         break;
@@ -966,6 +972,36 @@ static void restore_init_pincfgs(struct hda_codec *codec)
 }
 
 /*
+ * audio-converter setup caches
+ */
+struct hda_cvt_setup {
+        hda_nid_t nid;
+        u8 stream_tag;
+        u8 channel_id;
+        u16 format_id;
+        unsigned char active;   /* cvt is currently used */
+        unsigned char dirty;    /* setups should be cleared */
+};
+
+/* get or create a cache entry for the given audio converter NID */
+static struct hda_cvt_setup *
+get_hda_cvt_setup(struct hda_codec *codec, hda_nid_t nid)
+{
+        struct hda_cvt_setup *p;
+        int i;
+
+        for (i = 0; i < codec->cvt_setups.used; i++) {
+                p = snd_array_elem(&codec->cvt_setups, i);
+                if (p->nid == nid)
+                        return p;
+        }
+        p = snd_array_new(&codec->cvt_setups);
+        if (p)
+                p->nid = nid;
+        return p;
+}
+
+/*
  * codec destructor
  */
 static void snd_hda_codec_free(struct hda_codec *codec)
@@ -1039,6 +1075,7 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
         snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32);
         snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16);
         snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
+        snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
         if (codec->bus->modelname) {
                 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
                 if (!codec->modelname) {
@@ -1176,37 +1213,126 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
                                 u32 stream_tag,
                                 int channel_id, int format)
 {
+        struct hda_codec *c;
+        struct hda_cvt_setup *p;
+        unsigned int oldval, newval;
+        int i;
+
         if (!nid)
                 return;
 
         snd_printdd("hda_codec_setup_stream: "
                     "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
                     nid, stream_tag, channel_id, format);
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID,
-                            (stream_tag << 4) | channel_id);
-        msleep(1);
-        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
+        p = get_hda_cvt_setup(codec, nid);
+        if (!p)
+                return;
+        /* update the stream-id if changed */
+        if (p->stream_tag != stream_tag || p->channel_id != channel_id) {
+                oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
+                newval = (stream_tag << 4) | channel_id;
+                if (oldval != newval)
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_CHANNEL_STREAMID,
+                                            newval);
+                p->stream_tag = stream_tag;
+                p->channel_id = channel_id;
+        }
+        /* update the format-id if changed */
+        if (p->format_id != format) {
+                oldval = snd_hda_codec_read(codec, nid, 0,
+                                            AC_VERB_GET_STREAM_FORMAT, 0);
+                if (oldval != format) {
+                        msleep(1);
+                        snd_hda_codec_write(codec, nid, 0,
+                                            AC_VERB_SET_STREAM_FORMAT,
+                                            format);
+                }
+                p->format_id = format;
+        }
+        p->active = 1;
+        p->dirty = 0;
+
+        /* make other inactive cvts with the same stream-tag dirty */
+        list_for_each_entry(c, &codec->bus->codec_list, list) {
+                for (i = 0; i < c->cvt_setups.used; i++) {
+                        p = snd_array_elem(&c->cvt_setups, i);
+                        if (!p->active && p->stream_tag == stream_tag)
+                                p->dirty = 1;
+                }
+        }
 }
 EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream);
 
+static void really_cleanup_stream(struct hda_codec *codec,
+                                  struct hda_cvt_setup *q);
+
 /**
- * snd_hda_codec_cleanup_stream - clean up the codec for closing
+ * __snd_hda_codec_cleanup_stream - clean up the codec for closing
  * @codec: the CODEC to clean up
  * @nid: the NID to clean up
+ * @do_now: really clean up the stream instead of clearing the active flag
  */
-void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
+void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
+                                    int do_now)
 {
+        struct hda_cvt_setup *p;
+
         if (!nid)
                 return;
 
         snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid);
+        p = get_hda_cvt_setup(codec, nid);
+        if (p) {
+                /* here we just clear the active flag when do_now isn't set;
+                 * actual clean-ups will be done later in
+                 * purify_inactive_streams() called from snd_hda_codec_prpapre()
+                 */
+                if (do_now)
+                        really_cleanup_stream(codec, p);
+                else
+                        p->active = 0;
+        }
+}
+EXPORT_SYMBOL_HDA(__snd_hda_codec_cleanup_stream);
+
+static void really_cleanup_stream(struct hda_codec *codec,
+                                  struct hda_cvt_setup *q)
+{
+        hda_nid_t nid = q->nid;
         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
-#if 0 /* keep the format */
-        msleep(1);
         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
-#endif
+        memset(q, 0, sizeof(*q));
+        q->nid = nid;
+}
+
+/* clean up the all conflicting obsolete streams */
+static void purify_inactive_streams(struct hda_codec *codec)
+{
+        struct hda_codec *c;
+        int i;
+
+        list_for_each_entry(c, &codec->bus->codec_list, list) {
+                for (i = 0; i < c->cvt_setups.used; i++) {
+                        struct hda_cvt_setup *p;
+                        p = snd_array_elem(&c->cvt_setups, i);
+                        if (p->dirty)
+                                really_cleanup_stream(c, p);
+                }
+        }
+}
+
+/* clean up all streams; called from suspend */
+static void hda_cleanup_all_streams(struct hda_codec *codec)
+{
+        int i;
+
+        for (i = 0; i < codec->cvt_setups.used; i++) {
+                struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i);
+                if (p->stream_tag)
+                        really_cleanup_stream(codec, p);
+        }
 }
-EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup_stream);
 
 /*
  * amp access functions
@@ -1565,6 +1691,17 @@ void snd_hda_codec_resume_amp(struct hda_codec *codec)
 EXPORT_SYMBOL_HDA(snd_hda_codec_resume_amp);
 #endif /* SND_HDA_NEEDS_RESUME */
 
+static u32 get_amp_max_value(struct hda_codec *codec, hda_nid_t nid, int dir,
+                             unsigned int ofs)
+{
+        u32 caps = query_amp_caps(codec, nid, dir);
+        /* get num steps */
+        caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
+        if (ofs < caps)
+                caps -= ofs;
+        return caps;
+}
+
 /**
  * snd_hda_mixer_amp_volume_info - Info callback for a standard AMP mixer
  *
@@ -1579,23 +1716,17 @@ int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
         u8 chs = get_amp_channels(kcontrol);
         int dir = get_amp_direction(kcontrol);
         unsigned int ofs = get_amp_offset(kcontrol);
-        u32 caps;
 
-        caps = query_amp_caps(codec, nid, dir);
-        /* num steps */
-        caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
-        if (!caps) {
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = chs == 3 ? 2 : 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = get_amp_max_value(codec, nid, dir, ofs);
+        if (!uinfo->value.integer.max) {
                 printk(KERN_WARNING "hda_codec: "
                        "num_steps = 0 for NID=0x%x (ctl = %s)\n", nid,
                        kcontrol->id.name);
                 return -EINVAL;
         }
-        if (ofs < caps)
-                caps -= ofs;
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = chs == 3 ? 2 : 1;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = caps;
         return 0;
 }
 EXPORT_SYMBOL_HDA(snd_hda_mixer_amp_volume_info);
@@ -1620,8 +1751,14 @@ update_amp_value(struct hda_codec *codec, hda_nid_t nid,
                  int ch, int dir, int idx, unsigned int ofs,
                  unsigned int val)
 {
+        unsigned int maxval;
+
         if (val > 0)
                 val += ofs;
+        /* ofs = 0: raw max value */
+        maxval = get_amp_max_value(codec, nid, dir, 0);
+        if (val > maxval)
+                val = maxval;
         return snd_hda_codec_amp_update(codec, nid, ch, dir, idx,
                                         HDA_AMP_VOLMASK, val);
 }
@@ -2912,6 +3049,7 @@ static void hda_call_codec_suspend(struct hda_codec *codec)
 {
         if (codec->patch_ops.suspend)
                 codec->patch_ops.suspend(codec, PMSG_SUSPEND);
+        hda_cleanup_all_streams(codec);
         hda_set_power_state(codec,
                             codec->afg ? codec->afg : codec->mfg,
                             AC_PWRST_D3);
@@ -2999,26 +3137,31 @@ struct hda_rate_tbl {
         unsigned int hda_fmt;
 };
 
+/* rate = base * mult / div */
+#define HDA_RATE(base, mult, div) \
+        (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \
+         (((div) - 1) << AC_FMT_DIV_SHIFT))
+
 static struct hda_rate_tbl rate_bits[] = {
         /* rate in Hz, ALSA rate bitmask, HDA format value */
 
         /* autodetected value used in snd_hda_query_supported_pcm */
-        { 8000, SNDRV_PCM_RATE_8000, 0x0500 }, /* 1/6 x 48 */
-        { 11025, SNDRV_PCM_RATE_11025, 0x4300 }, /* 1/4 x 44 */
-        { 16000, SNDRV_PCM_RATE_16000, 0x0200 }, /* 1/3 x 48 */
-        { 22050, SNDRV_PCM_RATE_22050, 0x4100 }, /* 1/2 x 44 */
-        { 32000, SNDRV_PCM_RATE_32000, 0x0a00 }, /* 2/3 x 48 */
-        { 44100, SNDRV_PCM_RATE_44100, 0x4000 }, /* 44 */
-        { 48000, SNDRV_PCM_RATE_48000, 0x0000 }, /* 48 */
-        { 88200, SNDRV_PCM_RATE_88200, 0x4800 }, /* 2 x 44 */
-        { 96000, SNDRV_PCM_RATE_96000, 0x0800 }, /* 2 x 48 */
-        { 176400, SNDRV_PCM_RATE_176400, 0x5800 },/* 4 x 44 */
-        { 192000, SNDRV_PCM_RATE_192000, 0x1800 }, /* 4 x 48 */
+        { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },
+        { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },
+        { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },
+        { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },
+        { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },
+        { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },
+        { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },
+        { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },
+        { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },
+        { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },
+        { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },
 #define AC_PAR_PCM_RATE_BITS    11
         /* up to bits 10, 384kHZ isn't supported properly */
 
         /* not autodetected value */
-        { 9600, SNDRV_PCM_RATE_KNOT, 0x0400 }, /* 1/5 x 48 */
+        { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },
 
         { 0 } /* terminator */
 };
@@ -3037,7 +3180,8 @@ static struct hda_rate_tbl rate_bits[] = {
 unsigned int snd_hda_calc_stream_format(unsigned int rate,
                                         unsigned int channels,
                                         unsigned int format,
-                                        unsigned int maxbps)
+                                        unsigned int maxbps,
+                                        unsigned short spdif_ctls)
 {
         int i;
         unsigned int val = 0;
@@ -3060,20 +3204,20 @@ unsigned int snd_hda_calc_stream_format(unsigned int rate,
 
         switch (snd_pcm_format_width(format)) {
         case 8:
-                val |= 0x00;
+                val |= AC_FMT_BITS_8;
                 break;
         case 16:
-                val |= 0x10;
+                val |= AC_FMT_BITS_16;
                 break;
         case 20:
         case 24:
         case 32:
                 if (maxbps >= 32 || format == SNDRV_PCM_FORMAT_FLOAT_LE)
-                        val |= 0x40;
+                        val |= AC_FMT_BITS_32;
                 else if (maxbps >= 24)
-                        val |= 0x30;
+                        val |= AC_FMT_BITS_24;
                 else
-                        val |= 0x20;
+                        val |= AC_FMT_BITS_20;
                 break;
         default:
                 snd_printdd("invalid format width %d\n",
@@ -3081,6 +3225,9 @@ unsigned int snd_hda_calc_stream_format(unsigned int rate,
                 return 0;
         }
 
+        if (spdif_ctls & AC_DIG1_NONAUDIO)
+                val |= AC_FMT_TYPE_NON_PCM;
+
         return val;
 }
 EXPORT_SYMBOL_HDA(snd_hda_calc_stream_format);
@@ -3352,6 +3499,35 @@ static int set_pcm_default_values(struct hda_codec *codec,
         return 0;
 }
 
+/*
+ * codec prepare/cleanup entries
+ */
+int snd_hda_codec_prepare(struct hda_codec *codec,
+                          struct hda_pcm_stream *hinfo,
+                          unsigned int stream,
+                          unsigned int format,
+                          struct snd_pcm_substream *substream)
+{
+        int ret;
+        mutex_lock(&codec->bus->prepare_mutex);
+        ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream);
+        if (ret >= 0)
+                purify_inactive_streams(codec);
+        mutex_unlock(&codec->bus->prepare_mutex);
+        return ret;
+}
+EXPORT_SYMBOL_HDA(snd_hda_codec_prepare);
+
+void snd_hda_codec_cleanup(struct hda_codec *codec,
+                           struct hda_pcm_stream *hinfo,
+                           struct snd_pcm_substream *substream)
+{
+        mutex_lock(&codec->bus->prepare_mutex);
+        hinfo->ops.cleanup(hinfo, codec, substream);
+        mutex_unlock(&codec->bus->prepare_mutex);
+}
+EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup);
+
 /* global */
 const char *snd_hda_pcm_type_name[HDA_PCM_NTYPES] = {
         "Audio", "SPDIF", "HDMI", "Modem"
@@ -4360,7 +4536,7 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
                         cfg->hp_outs--;
                         memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1,
                                 sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i));
-                        memmove(sequences_hp + i - 1, sequences_hp + i,
+                        memmove(sequences_hp + i, sequences_hp + i + 1,
                                 sizeof(sequences_hp[0]) * (cfg->hp_outs - i));
                 }
         }
diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h
index 5991d14e1ec0..62c702240108 100644
--- a/sound/pci/hda/hda_codec.h
+++ b/sound/pci/hda/hda_codec.h
@@ -224,6 +224,27 @@ enum {
 /* Input converter SDI select */
 #define AC_SDI_SELECT                   (0xf<<0)
 
+/* stream format id */
+#define AC_FMT_CHAN_SHIFT               0
+#define AC_FMT_CHAN_MASK                (0x0f << 0)
+#define AC_FMT_BITS_SHIFT               4
+#define AC_FMT_BITS_MASK                (7 << 4)
+#define AC_FMT_BITS_8                   (0 << 4)
+#define AC_FMT_BITS_16                  (1 << 4)
+#define AC_FMT_BITS_20                  (2 << 4)
+#define AC_FMT_BITS_24                  (3 << 4)
+#define AC_FMT_BITS_32                  (4 << 4)
+#define AC_FMT_DIV_SHIFT                8
+#define AC_FMT_DIV_MASK                 (7 << 8)
+#define AC_FMT_MULT_SHIFT               11
+#define AC_FMT_MULT_MASK                (7 << 11)
+#define AC_FMT_BASE_SHIFT               14
+#define AC_FMT_BASE_48K                 (0 << 14)
+#define AC_FMT_BASE_44K                 (1 << 14)
+#define AC_FMT_TYPE_SHIFT               15
+#define AC_FMT_TYPE_PCM                 (0 << 15)
+#define AC_FMT_TYPE_NON_PCM             (1 << 15)
+
 /* Unsolicited response control */
 #define AC_UNSOL_TAG                    (0x3f<<0)
 #define AC_UNSOL_ENABLED                (1<<7)
@@ -364,6 +385,9 @@ enum {
 #define AC_DIG2_CC                      (0x7f<<0)
 
 /* Pin widget control - 8bit */
+#define AC_PINCTL_EPT                   (0x3<<0)
+#define AC_PINCTL_EPT_NATIVE            0
+#define AC_PINCTL_EPT_HBR               3
 #define AC_PINCTL_VREFEN                (0x7<<0)
 #define AC_PINCTL_VREF_HIZ              0       /* Hi-Z */
 #define AC_PINCTL_VREF_50               1       /* 50% */
@@ -624,6 +648,7 @@ struct hda_bus {
         struct hda_codec *caddr_tbl[HDA_MAX_CODEC_ADDRESS + 1];
 
         struct mutex cmd_mutex;
+        struct mutex prepare_mutex;
 
         /* unsolicited event queue */
         struct hda_bus_unsolicited *unsol;
@@ -760,7 +785,10 @@ struct hda_codec {
         hda_nid_t mfg;  /* MFG node id */
 
         /* ids */
-        u32 function_id;
+        u8 afg_function_id;
+        u8 mfg_function_id;
+        u8 afg_unsol;
+        u8 mfg_unsol;
         u32 vendor_id;
         u32 subsystem_id;
         u32 revision_id;
@@ -805,6 +833,7 @@ struct hda_codec {
         hda_nid_t *slave_dig_outs; /* optional digital out slave widgets */
         struct snd_array init_pins;     /* initial (BIOS) pin configurations */
         struct snd_array driver_pins;   /* pin configs set by codec parser */
+        struct snd_array cvt_setups;    /* audio convert setups */
 
 #ifdef CONFIG_SND_HDA_HWDEP
         struct snd_hwdep *hwdep;        /* assigned hwdep device */
@@ -921,14 +950,28 @@ int snd_hda_codec_build_controls(struct hda_codec *codec);
  */
 int snd_hda_build_pcms(struct hda_bus *bus);
 int snd_hda_codec_build_pcms(struct hda_codec *codec);
+
+int snd_hda_codec_prepare(struct hda_codec *codec,
+                          struct hda_pcm_stream *hinfo,
+                          unsigned int stream,
+                          unsigned int format,
+                          struct snd_pcm_substream *substream);
+void snd_hda_codec_cleanup(struct hda_codec *codec,
+                           struct hda_pcm_stream *hinfo,
+                           struct snd_pcm_substream *substream);
+
 void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid,
                                 u32 stream_tag,
                                 int channel_id, int format);
-void snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid);
+void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid,
+                                    int do_now);
+#define snd_hda_codec_cleanup_stream(codec, nid) \
+        __snd_hda_codec_cleanup_stream(codec, nid, 0)
 unsigned int snd_hda_calc_stream_format(unsigned int rate,
                                         unsigned int channels,
                                         unsigned int format,
-                                        unsigned int maxbps);
+                                        unsigned int maxbps,
+                                        unsigned short spdif_ctls);
 int snd_hda_is_supported_format(struct hda_codec *codec, hda_nid_t nid,
                                 unsigned int format);
 
diff --git a/sound/pci/hda/hda_eld.c b/sound/pci/hda/hda_eld.c
index d8da18a9e98b..26c3ade73583 100644
--- a/sound/pci/hda/hda_eld.c
+++ b/sound/pci/hda/hda_eld.c
@@ -597,3 +597,52 @@ void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld)
 EXPORT_SYMBOL_HDA(snd_hda_eld_proc_free);
 
 #endif /* CONFIG_PROC_FS */
+
+/* update PCM info based on ELD */
+void hdmi_eld_update_pcm_info(struct hdmi_eld *eld, struct hda_pcm_stream *pcm,
+                              struct hda_pcm_stream *codec_pars)
+{
+        int i;
+
+        pcm->rates = 0;
+        pcm->formats = 0;
+        pcm->maxbps = 0;
+        pcm->channels_min = -1;
+        pcm->channels_max = 0;
+        for (i = 0; i < eld->sad_count; i++) {
+                struct cea_sad *a = &eld->sad[i];
+                pcm->rates |= a->rates;
+                if (a->channels < pcm->channels_min)
+                        pcm->channels_min = a->channels;
+                if (a->channels > pcm->channels_max)
+                        pcm->channels_max = a->channels;
+                if (a->format == AUDIO_CODING_TYPE_LPCM) {
+                        if (a->sample_bits & AC_SUPPCM_BITS_16) {
+                                pcm->formats |= SNDRV_PCM_FMTBIT_S16_LE;
+                                if (pcm->maxbps < 16)
+                                        pcm->maxbps = 16;
+                        }
+                        if (a->sample_bits & AC_SUPPCM_BITS_20) {
+                                pcm->formats |= SNDRV_PCM_FMTBIT_S32_LE;
+                                if (pcm->maxbps < 20)
+                                        pcm->maxbps = 20;
+                        }
+                        if (a->sample_bits & AC_SUPPCM_BITS_24) {
+                                pcm->formats |= SNDRV_PCM_FMTBIT_S32_LE;
+                                if (pcm->maxbps < 24)
+                                        pcm->maxbps = 24;
+                        }
+                }
+        }
+
+        if (!codec_pars)
+                return;
+
+        /* restrict the parameters by the values the codec provides */
+        pcm->rates &= codec_pars->rates;
+        pcm->formats &= codec_pars->formats;
+        pcm->channels_min = max(pcm->channels_min, codec_pars->channels_min);
+        pcm->channels_max = min(pcm->channels_max, codec_pars->channels_max);
+        pcm->maxbps = min(pcm->maxbps, codec_pars->maxbps);
+}
+EXPORT_SYMBOL_HDA(hdmi_eld_update_pcm_info);
diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c
index a1fc83753cc6..bf3ced51e0f8 100644
--- a/sound/pci/hda/hda_hwdep.c
+++ b/sound/pci/hda/hda_hwdep.c
@@ -649,7 +649,9 @@ static void parse_codec_mode(char *buf, struct hda_bus *bus,
         *codecp = NULL;
         if (sscanf(buf, "%i %i %i", &vendorid, &subid, &caddr) == 3) {
                 list_for_each_entry(codec, &bus->codec_list, list) {
-                        if (codec->addr == caddr) {
+                        if (codec->vendor_id == vendorid &&
+                            codec->subsystem_id == subid &&
+                            codec->addr == caddr) {
                                 *codecp = codec;
                                 break;
                         }
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index 1df25cf5ce38..1053fff4bd0a 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -1634,7 +1634,7 @@ static int azx_pcm_hw_free(struct snd_pcm_substream *substream)
         azx_dev->period_bytes = 0;
         azx_dev->format_val = 0;
 
-        hinfo->ops.cleanup(hinfo, apcm->codec, substream);
+        snd_hda_codec_cleanup(apcm->codec, hinfo, substream);
 
         return snd_pcm_lib_free_pages(substream);
 }
@@ -1653,7 +1653,8 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream)
         format_val = snd_hda_calc_stream_format(runtime->rate,
                                                 runtime->channels,
                                                 runtime->format,
-                                                hinfo->maxbps);
+                                                hinfo->maxbps,
+                                                apcm->codec->spdif_ctls);
         if (!format_val) {
                 snd_printk(KERN_ERR SFX
                            "invalid format_val, rate=%d, ch=%d, format=%d\n",
@@ -1687,8 +1688,8 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream)
         else
                 azx_dev->fifo_size = 0;
 
-        return hinfo->ops.prepare(hinfo, apcm->codec, azx_dev->stream_tag,
-                                  azx_dev->format_val, substream);
+        return snd_hda_codec_prepare(apcm->codec, hinfo, azx_dev->stream_tag,
+                                     azx_dev->format_val, substream);
 }
 
 static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
@@ -1960,7 +1961,7 @@ static void azx_irq_pending_work(struct work_struct *work)
                 spin_unlock_irq(&chip->reg_lock);
                 if (!pending)
                         return;
-                cond_resched();
+                msleep(1);
         }
 }
 
diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h
index 7a97f126f6f7..28ab4aead48f 100644
--- a/sound/pci/hda/hda_local.h
+++ b/sound/pci/hda/hda_local.h
@@ -604,6 +604,8 @@ struct hdmi_eld {
 int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid);
 int snd_hdmi_get_eld(struct hdmi_eld *, struct hda_codec *, hda_nid_t);
 void snd_hdmi_show_eld(struct hdmi_eld *eld);
+void hdmi_eld_update_pcm_info(struct hdmi_eld *eld, struct hda_pcm_stream *pcm,
+                              struct hda_pcm_stream *codec_pars);
 
 #ifdef CONFIG_PROC_FS
 int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld,
diff --git a/sound/pci/hda/hda_proc.c b/sound/pci/hda/hda_proc.c
index f97d35de66c4..f025200f2a62 100644
--- a/sound/pci/hda/hda_proc.c
+++ b/sound/pci/hda/hda_proc.c
@@ -557,7 +557,12 @@ static void print_codec_info(struct snd_info_entry *entry,
         else
                 snd_iprintf(buffer, "Not Set\n");
         snd_iprintf(buffer, "Address: %d\n", codec->addr);
-        snd_iprintf(buffer, "Function Id: 0x%x\n", codec->function_id);
+        if (codec->afg)
+                snd_iprintf(buffer, "AFG Function Id: 0x%x (unsol %u)\n",
+                        codec->afg_function_id, codec->afg_unsol);
+        if (codec->mfg)
+                snd_iprintf(buffer, "MFG Function Id: 0x%x (unsol %u)\n",
+                        codec->mfg_function_id, codec->mfg_unsol);
         snd_iprintf(buffer, "Vendor Id: 0x%08x\n", codec->vendor_id);
         snd_iprintf(buffer, "Subsystem Id: 0x%08x\n", codec->subsystem_id);
         snd_iprintf(buffer, "Revision Id: 0x%x\n", codec->revision_id);
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index afbe314a5bf3..b697fd2a6f8b 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -3662,7 +3662,12 @@ static int patch_ad1984(struct hda_codec *codec)
                 codec->patch_ops.build_pcms = ad1984_build_pcms;
                 break;
         case AD1984_THINKPAD:
-                spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
+                if (codec->subsystem_id == 0x17aa20fb) {
+                        /* Thinpad X300 does not have the ability to do SPDIF,
+                           or attach to docking station to use SPDIF */
+                        spec->multiout.dig_out_nid = 0;
+                } else
+                        spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
                 spec->input_mux = &ad1984_thinkpad_capture_source;
                 spec->mixers[0] = ad1984_thinkpad_mixers;
                 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c
index 350ee8ac4153..488fd9ade1ba 100644
--- a/sound/pci/hda/patch_cirrus.c
+++ b/sound/pci/hda/patch_cirrus.c
@@ -656,7 +656,7 @@ static int change_cur_input(struct hda_codec *codec, unsigned int idx,
                 return 0;
         if (spec->cur_adc && spec->cur_adc != spec->adc_nid[idx]) {
                 /* stream is running, let's swap the current ADC */
-                snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
+                __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
                 spec->cur_adc = spec->adc_nid[idx];
                 snd_hda_codec_setup_stream(codec, spec->cur_adc,
                                            spec->cur_adc_stream_tag, 0,
@@ -972,6 +972,53 @@ static struct hda_verb cs_coef_init_verbs[] = {
         {} /* terminator */
 };
 
+/* Errata: CS4207 rev C0/C1/C2 Silicon
+ *
+ * http://www.cirrus.com/en/pubs/errata/ER880C3.pdf
+ *
+ * 6. At high temperature (TA > +85°C), the digital supply current (IVD)
+ * may be excessive (up to an additional 200 μA), which is most easily
+ * observed while the part is being held in reset (RESET# active low).
+ *
+ * Root Cause: At initial powerup of the device, the logic that drives
+ * the clock and write enable to the S/PDIF SRC RAMs is not properly
+ * initialized.
+ * Certain random patterns will cause a steady leakage current in those
+ * RAM cells. The issue will resolve once the SRCs are used (turned on).
+ *
+ * Workaround: The following verb sequence briefly turns on the S/PDIF SRC
+ * blocks, which will alleviate the issue.
+ */
+
+static struct hda_verb cs_errata_init_verbs[] = {
+        {0x01, AC_VERB_SET_POWER_STATE, 0x00}, /* AFG: D0 */
+        {0x11, AC_VERB_SET_PROC_STATE, 0x01},  /* VPW: processing on */
+
+        {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
+        {0x11, AC_VERB_SET_PROC_COEF, 0x9999},
+        {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
+        {0x11, AC_VERB_SET_PROC_COEF, 0xa412},
+        {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
+        {0x11, AC_VERB_SET_PROC_COEF, 0x0009},
+
+        {0x07, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Rx: D0 */
+        {0x08, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Tx: D0 */
+
+        {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
+        {0x11, AC_VERB_SET_PROC_COEF, 0x2412},
+        {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
+        {0x11, AC_VERB_SET_PROC_COEF, 0x0000},
+        {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
+        {0x11, AC_VERB_SET_PROC_COEF, 0x0008},
+        {0x11, AC_VERB_SET_PROC_STATE, 0x00},
+
+        {0x07, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Rx: D3 */
+        {0x08, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Tx: D3 */
+        /*{0x01, AC_VERB_SET_POWER_STATE, 0x03},*/ /* AFG: D3 This is already handled */
+
+        {} /* terminator */
+};
+
 /* SPDIF setup */
 static void init_digital(struct hda_codec *codec)
 {
@@ -991,6 +1038,9 @@ static int cs_init(struct hda_codec *codec)
 {
         struct cs_spec *spec = codec->spec;
 
+        /* init_verb sequence for C0/C1/C2 errata*/
+        snd_hda_sequence_write(codec, cs_errata_init_verbs);
+
         snd_hda_sequence_write(codec, cs_coef_init_verbs);
 
         if (spec->gpio_mask) {
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
index 2bf2cb5da956..71f9d6475b09 100644
--- a/sound/pci/hda/patch_conexant.c
+++ b/sound/pci/hda/patch_conexant.c
@@ -116,6 +116,7 @@ struct conexant_spec {
         unsigned int dell_vostro:1;
         unsigned int ideapad:1;
         unsigned int thinkpad:1;
+        unsigned int hp_laptop:1;
 
         unsigned int ext_mic_present;
         unsigned int recording;
@@ -131,6 +132,8 @@ struct conexant_spec {
         unsigned int dc_enable;
         unsigned int dc_input_bias; /* offset into cxt5066_olpc_dc_bias */
         unsigned int mic_boost; /* offset into cxt5066_analog_mic_boost */
+
+        unsigned int beep_amp;
 };
 
 static int conexant_playback_pcm_open(struct hda_pcm_stream *hinfo,
@@ -515,6 +518,15 @@ static struct snd_kcontrol_new cxt_capture_mixers[] = {
         {}
 };
 
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+/* additional beep mixers; the actual parameters are overwritten at build */
+static struct snd_kcontrol_new cxt_beep_mixer[] = {
+        HDA_CODEC_VOLUME_MONO("Beep Playback Volume", 0, 1, 0, HDA_OUTPUT),
+        HDA_CODEC_MUTE_BEEP_MONO("Beep Playback Switch", 0, 1, 0, HDA_OUTPUT),
+        { } /* end */
+};
+#endif
+
 static const char *slave_vols[] = {
         "Headphone Playback Volume",
         "Speaker Playback Volume",
@@ -580,16 +592,52 @@ static int conexant_build_controls(struct hda_codec *codec)
                         return err;
         }
 
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+        /* create beep controls if needed */
+        if (spec->beep_amp) {
+                struct snd_kcontrol_new *knew;
+                for (knew = cxt_beep_mixer; knew->name; knew++) {
+                        struct snd_kcontrol *kctl;
+                        kctl = snd_ctl_new1(knew, codec);
+                        if (!kctl)
+                                return -ENOMEM;
+                        kctl->private_value = spec->beep_amp;
+                        err = snd_hda_ctl_add(codec, 0, kctl);
+                        if (err < 0)
+                                return err;
+                }
+        }
+#endif
+
         return 0;
 }
 
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+static int conexant_suspend(struct hda_codec *codec, pm_message_t state)
+{
+        snd_hda_shutup_pins(codec);
+        return 0;
+}
+#endif
+
 static struct hda_codec_ops conexant_patch_ops = {
         .build_controls = conexant_build_controls,
         .build_pcms = conexant_build_pcms,
         .init = conexant_init,
         .free = conexant_free,
+#ifdef CONFIG_SND_HDA_POWER_SAVE
+        .suspend = conexant_suspend,
+#endif
+        .reboot_notify = snd_hda_shutup_pins,
 };
 
+#ifdef CONFIG_SND_HDA_INPUT_BEEP
+#define set_beep_amp(spec, nid, idx, dir) \
+        ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir))
+#else
+#define set_beep_amp(spec, nid, idx, dir) /* NOP */
+#endif
+
 /*
  * EAPD control
  * the private value = nid | (invert << 8)
@@ -1130,9 +1178,10 @@ static int patch_cxt5045(struct hda_codec *codec)
         spec->num_init_verbs = 1;
         spec->init_verbs[0] = cxt5045_init_verbs;
         spec->spdif_route = 0;
-        spec->num_channel_mode = ARRAY_SIZE(cxt5045_modes),
-        spec->channel_mode = cxt5045_modes,
+        spec->num_channel_mode = ARRAY_SIZE(cxt5045_modes);
+        spec->channel_mode = cxt5045_modes;
 
+        set_beep_amp(spec, 0x16, 0, 1);
 
         codec->patch_ops = conexant_patch_ops;
 
@@ -1211,6 +1260,9 @@ static int patch_cxt5045(struct hda_codec *codec)
                 break;
         }
 
+        if (spec->beep_amp)
+                snd_hda_attach_beep_device(codec, spec->beep_amp);
+
         return 0;
 }
 
@@ -1632,6 +1684,11 @@ static void cxt5051_update_speaker(struct hda_codec *codec)
         pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0;
         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
                             pinctl);
+        /* on ideapad there is an aditional speaker (subwoofer) to mute */
+        if (spec->ideapad)
+                snd_hda_codec_write(codec, 0x1b, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                    pinctl);
 }
 
 /* turn on/off EAPD (+ mute HP) as a master switch */
@@ -1677,7 +1734,7 @@ static void cxt5051_portc_automic(struct hda_codec *codec)
         new_adc = spec->adc_nids[spec->cur_adc_idx];
         if (spec->cur_adc && spec->cur_adc != new_adc) {
                 /* stream is running, let's swap the current ADC */
-                snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
+                __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
                 spec->cur_adc = new_adc;
                 snd_hda_codec_setup_stream(codec, new_adc,
                                            spec->cur_adc_stream_tag, 0,
@@ -1888,6 +1945,13 @@ static void cxt5051_init_mic_port(struct hda_codec *codec, hda_nid_t nid,
 #endif
 }
 
+static struct hda_verb cxt5051_ideapad_init_verbs[] = {
+        /* Subwoofer */
+        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
+        { } /* end */
+};
+
 /* initialize jack-sensing, too */
 static int cxt5051_init(struct hda_codec *codec)
 {
@@ -1917,6 +1981,7 @@ enum {
         CXT5051_LENOVO_X200,    /* Lenovo X200 laptop, also used for Advanced Mini Dock 250410 */
         CXT5051_F700,       /* HP Compaq Presario F700 */
         CXT5051_TOSHIBA,        /* Toshiba M300 & co */
+        CXT5051_IDEAPAD,        /* Lenovo IdeaPad Y430 */
         CXT5051_MODELS
 };
 
@@ -1927,6 +1992,7 @@ static const char *cxt5051_models[CXT5051_MODELS] = {
         [CXT5051_LENOVO_X200]   = "lenovo-x200",
         [CXT5051_F700]          = "hp-700",
         [CXT5051_TOSHIBA]       = "toshiba",
+        [CXT5051_IDEAPAD]       = "ideapad",
 };
 
 static struct snd_pci_quirk cxt5051_cfg_tbl[] = {
@@ -1938,6 +2004,7 @@ static struct snd_pci_quirk cxt5051_cfg_tbl[] = {
                       CXT5051_LAPTOP),
         SND_PCI_QUIRK(0x14f1, 0x5051, "HP Spartan 1.1", CXT5051_HP),
         SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo X200", CXT5051_LENOVO_X200),
+        SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo IdeaPad", CXT5051_IDEAPAD),
         {}
 };
 
@@ -1972,6 +2039,8 @@ static int patch_cxt5051(struct hda_codec *codec)
         spec->cur_adc = 0;
         spec->cur_adc_idx = 0;
 
+        set_beep_amp(spec, 0x13, 0, HDA_OUTPUT);
+
         codec->patch_ops.unsol_event = cxt5051_hp_unsol_event;
 
         board_config = snd_hda_check_board_config(codec, CXT5051_MODELS,
@@ -1989,6 +2058,10 @@ static int patch_cxt5051(struct hda_codec *codec)
                 break;
         case CXT5051_LENOVO_X200:
                 spec->init_verbs[0] = cxt5051_lenovo_x200_init_verbs;
+                /* Thinkpad X301 does not have S/PDIF wired and no ability
+                   to use a docking station. */
+                if (codec->subsystem_id == 0x17aa211f)
+                        spec->multiout.dig_out_nid = 0;
                 break;
         case CXT5051_F700:
                 spec->init_verbs[0] = cxt5051_f700_init_verbs;
@@ -1999,8 +2072,16 @@ static int patch_cxt5051(struct hda_codec *codec)
                 spec->mixers[0] = cxt5051_toshiba_mixers;
                 spec->auto_mic = AUTO_MIC_PORTB;
                 break;
+        case CXT5051_IDEAPAD:
+                spec->init_verbs[spec->num_init_verbs++] =
+                        cxt5051_ideapad_init_verbs;
+                spec->ideapad = 1;
+                break;
         }
 
+        if (spec->beep_amp)
+                snd_hda_attach_beep_device(codec, spec->beep_amp);
+
         return 0;
 }
 
@@ -2219,6 +2300,18 @@ static void cxt5066_ideapad_automic(struct hda_codec *codec)
         }
 }
 
+/* toggle input of built-in digital mic and mic jack appropriately */
+static void cxt5066_hp_laptop_automic(struct hda_codec *codec)
+{
+        unsigned int present;
+
+        present = snd_hda_jack_detect(codec, 0x1b);
+        snd_printdd("CXT5066: external microphone present=%d\n", present);
+        snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_CONNECT_SEL,
+                            present ? 1 : 3);
+}
+
+
 /* toggle input of built-in digital mic and mic jack appropriately
    order is: external mic -> dock mic -> interal mic */
 static void cxt5066_thinkpad_automic(struct hda_codec *codec)
@@ -2328,6 +2421,20 @@ static void cxt5066_ideapad_event(struct hda_codec *codec, unsigned int res)
 }
 
 /* unsolicited event for jack sensing */
+static void cxt5066_hp_laptop_event(struct hda_codec *codec, unsigned int res)
+{
+        snd_printdd("CXT5066_hp_laptop: unsol event %x (%x)\n", res, res >> 26);
+        switch (res >> 26) {
+        case CONEXANT_HP_EVENT:
+                cxt5066_hp_automute(codec);
+                break;
+        case CONEXANT_MIC_EVENT:
+                cxt5066_hp_laptop_automic(codec);
+                break;
+        }
+}
+
+/* unsolicited event for jack sensing */
 static void cxt5066_thinkpad_event(struct hda_codec *codec, unsigned int res)
 {
         snd_printdd("CXT5066_thinkpad: unsol event %x (%x)\n", res, res >> 26);
@@ -2616,7 +2723,6 @@ static struct snd_kcontrol_new cxt5066_vostro_mixers[] = {
                 .put = cxt5066_mic_boost_mux_enum_put,
                 .private_value = 0x23 | 0x100,
         },
-        HDA_CODEC_VOLUME_MONO("Beep Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
         {}
 };
 
@@ -2910,6 +3016,14 @@ static struct hda_verb cxt5066_init_verbs_portd_lo[] = {
         { } /* end */
 };
 
+
+static struct hda_verb cxt5066_init_verbs_hp_laptop[] = {
+        {0x14, AC_VERB_SET_CONNECT_SEL, 0x0},
+        {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
+        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
+        { } /* end */
+};
+
 /* initialize jack-sensing, too */
 static int cxt5066_init(struct hda_codec *codec)
 {
@@ -2925,6 +3039,8 @@ static int cxt5066_init(struct hda_codec *codec)
                         cxt5066_ideapad_automic(codec);
                 else if (spec->thinkpad)
                         cxt5066_thinkpad_automic(codec);
+                else if (spec->hp_laptop)
+                        cxt5066_hp_laptop_automic(codec);
         }
         cxt5066_set_mic_boost(codec);
         return 0;
@@ -2952,6 +3068,7 @@ enum {
         CXT5066_DELL_VOSTO,     /* Dell Vostro 1015i */
         CXT5066_IDEAPAD,        /* Lenovo IdeaPad U150 */
         CXT5066_THINKPAD,       /* Lenovo ThinkPad T410s, others? */
+        CXT5066_HP_LAPTOP,      /* HP Laptop */
         CXT5066_MODELS
 };
 
@@ -2962,6 +3079,7 @@ static const char *cxt5066_models[CXT5066_MODELS] = {
         [CXT5066_DELL_VOSTO]    = "dell-vostro",
         [CXT5066_IDEAPAD]       = "ideapad",
         [CXT5066_THINKPAD]      = "thinkpad",
+        [CXT5066_HP_LAPTOP]     = "hp-laptop",
 };
 
 static struct snd_pci_quirk cxt5066_cfg_tbl[] = {
@@ -2970,15 +3088,21 @@ static struct snd_pci_quirk cxt5066_cfg_tbl[] = {
         SND_PCI_QUIRK(0x1028, 0x02f5, "Dell",
                       CXT5066_DELL_LAPTOP),
         SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT5066_OLPC_XO_1_5),
+        SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTO),
         SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTO),
         SND_PCI_QUIRK(0x1028, 0x0408, "Dell Inspiron One 19T", CXT5066_IDEAPAD),
+        SND_PCI_QUIRK(0x103c, 0x360b, "HP G60", CXT5066_HP_LAPTOP),
         SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba Satellite P500-PSPGSC-01800T", CXT5066_OLPC_XO_1_5),
         SND_PCI_QUIRK(0x1179, 0xffe0, "Toshiba Satellite Pro T130-15F", CXT5066_OLPC_XO_1_5),
+        SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo T400s", CXT5066_THINKPAD),
         SND_PCI_QUIRK(0x17aa, 0x21b2, "Thinkpad X100e", CXT5066_IDEAPAD),
         SND_PCI_QUIRK(0x17aa, 0x21b3, "Thinkpad Edge 13 (197)", CXT5066_IDEAPAD),
         SND_PCI_QUIRK(0x17aa, 0x21b4, "Thinkpad Edge", CXT5066_IDEAPAD),
+        SND_PCI_QUIRK(0x17aa, 0x215e, "Lenovo Thinkpad", CXT5066_THINKPAD),
+        SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo G series", CXT5066_IDEAPAD),
+        SND_PCI_QUIRK(0x17aa, 0x390a, "Lenovo S10-3t", CXT5066_IDEAPAD),
+        SND_PCI_QUIRK(0x17aa, 0x3938, "Lenovo G series (AMD)", CXT5066_IDEAPAD),
         SND_PCI_QUIRK(0x17aa, 0x3a0d, "ideapad", CXT5066_IDEAPAD),
-        SND_PCI_QUIRK(0x17aa, 0x215e, "Lenovo Thinkpad", CXT5066_THINKPAD),
         {}
 };
 
@@ -3014,6 +3138,8 @@ static int patch_cxt5066(struct hda_codec *codec)
         spec->cur_adc = 0;
         spec->cur_adc_idx = 0;
 
+        set_beep_amp(spec, 0x13, 0, HDA_OUTPUT);
+
         board_config = snd_hda_check_board_config(codec, CXT5066_MODELS,
                                                   cxt5066_models, cxt5066_cfg_tbl);
         switch (board_config) {
@@ -3031,6 +3157,23 @@ static int patch_cxt5066(struct hda_codec *codec)
                 spec->num_init_verbs++;
                 spec->dell_automute = 1;
                 break;
+        case CXT5066_HP_LAPTOP:
+                codec->patch_ops.init = cxt5066_init;
+                codec->patch_ops.unsol_event = cxt5066_hp_laptop_event;
+                spec->init_verbs[spec->num_init_verbs] =
+                        cxt5066_init_verbs_hp_laptop;
+                spec->num_init_verbs++;
+                spec->hp_laptop = 1;
+                spec->mixers[spec->num_mixers++] = cxt5066_mixer_master;
+                spec->mixers[spec->num_mixers++] = cxt5066_mixers;
+                /* no S/PDIF out */
+                spec->multiout.dig_out_nid = 0;
+                /* input source automatically selected */
+                spec->input_mux = NULL;
+                spec->port_d_mode = 0;
+                spec->mic_boost = 3; /* default 30dB gain */
+                break;
+
         case CXT5066_OLPC_XO_1_5:
                 codec->patch_ops.init = cxt5066_olpc_init;
                 codec->patch_ops.unsol_event = cxt5066_olpc_unsol_event;
@@ -3062,7 +3205,6 @@ static int patch_cxt5066(struct hda_codec *codec)
                 spec->port_d_mode = 0;
                 spec->dell_vostro = 1;
                 spec->mic_boost = 3; /* default 30dB gain */
-                snd_hda_attach_beep_device(codec, 0x13);
 
                 /* no S/PDIF out */
                 spec->multiout.dig_out_nid = 0;
@@ -3104,6 +3246,9 @@ static int patch_cxt5066(struct hda_codec *codec)
                 break;
         }
 
+        if (spec->beep_amp)
+                snd_hda_attach_beep_device(codec, spec->beep_amp);
+
         return 0;
 }
 
@@ -3121,6 +3266,8 @@ static struct hda_codec_preset snd_hda_preset_conexant[] = {
           .patch = patch_cxt5066 },
         { .id = 0x14f15067, .name = "CX20583 (Pebble HSF)",
           .patch = patch_cxt5066 },
+        { .id = 0x14f15068, .name = "CX20584",
+          .patch = patch_cxt5066 },
         { .id = 0x14f15069, .name = "CX20585",
           .patch = patch_cxt5066 },
         {} /* terminator */
@@ -3131,6 +3278,7 @@ MODULE_ALIAS("snd-hda-codec-id:14f15047");
 MODULE_ALIAS("snd-hda-codec-id:14f15051");
 MODULE_ALIAS("snd-hda-codec-id:14f15066");
 MODULE_ALIAS("snd-hda-codec-id:14f15067");
+MODULE_ALIAS("snd-hda-codec-id:14f15068");
 MODULE_ALIAS("snd-hda-codec-id:14f15069");
 
 MODULE_LICENSE("GPL");
diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
index 2fc53961054e..afd6022a96a7 100644
--- a/sound/pci/hda/patch_hdmi.c
+++ b/sound/pci/hda/patch_hdmi.c
@@ -46,6 +46,7 @@ struct hdmi_spec {
          * export one pcm per pipe
          */
         struct hda_pcm  pcm_rec[MAX_HDMI_CVTS];
+        struct hda_pcm_stream codec_pcm_pars[MAX_HDMI_CVTS];
 
         /*
          * nvhdmi specific
@@ -698,30 +699,93 @@ static void hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
  * Callbacks
  */
 
-static void hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid,
+/* HBR should be Non-PCM, 8 channels */
+#define is_hbr_format(format) \
+        ((format & AC_FMT_TYPE_NON_PCM) && (format & AC_FMT_CHAN_MASK) == 7)
+
+static int hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid,
                               u32 stream_tag, int format)
 {
-        int tag;
-        int fmt;
+        struct hdmi_spec *spec = codec->spec;
+        int pinctl;
+        int new_pinctl = 0;
+        int i;
+
+        for (i = 0; i < spec->num_pins; i++) {
+                if (spec->pin_cvt[i] != nid)
+                        continue;
+                if (!(snd_hda_query_pin_caps(codec, spec->pin[i]) & AC_PINCAP_HBR))
+                        continue;
 
-        tag = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0) >> 4;
-        fmt = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_STREAM_FORMAT, 0);
+                pinctl = snd_hda_codec_read(codec, spec->pin[i], 0,
+                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
+
+                new_pinctl = pinctl & ~AC_PINCTL_EPT;
+                if (is_hbr_format(format))
+                        new_pinctl |= AC_PINCTL_EPT_HBR;
+                else
+                        new_pinctl |= AC_PINCTL_EPT_NATIVE;
+
+                snd_printdd("hdmi_setup_stream: "
+                            "NID=0x%x, %spinctl=0x%x\n",
+                            spec->pin[i],
+                            pinctl == new_pinctl ? "" : "new-",
+                            new_pinctl);
+
+                if (pinctl != new_pinctl)
+                        snd_hda_codec_write(codec, spec->pin[i], 0,
+                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                            new_pinctl);
+        }
 
-        snd_printdd("hdmi_setup_stream: "
-                    "NID=0x%x, %sstream=0x%x, %sformat=0x%x\n",
-                    nid,
-                    tag == stream_tag ? "" : "new-",
-                    stream_tag,
-                    fmt == format ? "" : "new-",
-                    format);
+        if (is_hbr_format(format) && !new_pinctl) {
+                snd_printdd("hdmi_setup_stream: HBR is not supported\n");
+                return -EINVAL;
+        }
 
-        if (tag != stream_tag)
-                snd_hda_codec_write(codec, nid, 0,
-                                    AC_VERB_SET_CHANNEL_STREAMID,
-                                    stream_tag << 4);
-        if (fmt != format)
-                snd_hda_codec_write(codec, nid, 0,
-                                    AC_VERB_SET_STREAM_FORMAT, format);
+        snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
+        return 0;
+}
+
+/*
+ * HDA PCM callbacks
+ */
+static int hdmi_pcm_open(struct hda_pcm_stream *hinfo,
+                         struct hda_codec *codec,
+                         struct snd_pcm_substream *substream)
+{
+        struct hdmi_spec *spec = codec->spec;
+        struct hdmi_eld *eld;
+        struct hda_pcm_stream *codec_pars;
+        unsigned int idx;
+
+        for (idx = 0; idx < spec->num_cvts; idx++)
+                if (hinfo->nid == spec->cvt[idx])
+                        break;
+        if (snd_BUG_ON(idx >= spec->num_cvts) ||
+            snd_BUG_ON(idx >= spec->num_pins))
+                return -EINVAL;
+
+        /* save the PCM info the codec provides */
+        codec_pars = &spec->codec_pcm_pars[idx];
+        if (!codec_pars->rates)
+                *codec_pars = *hinfo;
+
+        eld = &spec->sink_eld[idx];
+        if (eld->sad_count > 0) {
+                hdmi_eld_update_pcm_info(eld, hinfo, codec_pars);
+                if (hinfo->channels_min > hinfo->channels_max ||
+                    !hinfo->rates || !hinfo->formats)
+                        return -ENODEV;
+        } else {
+                /* fallback to the codec default */
+                hinfo->channels_min = codec_pars->channels_min;
+                hinfo->channels_max = codec_pars->channels_max;
+                hinfo->rates = codec_pars->rates;
+                hinfo->formats = codec_pars->formats;
+                hinfo->maxbps = codec_pars->maxbps;
+        }
+        return 0;
 }
 
 /*
diff --git a/sound/pci/hda/patch_intelhdmi.c b/sound/pci/hda/patch_intelhdmi.c
index b81d23e42ace..36a9b83a6174 100644
--- a/sound/pci/hda/patch_intelhdmi.c
+++ b/sound/pci/hda/patch_intelhdmi.c
@@ -66,23 +66,15 @@ static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 
         hdmi_setup_audio_infoframe(codec, hinfo->nid, substream);
 
-        hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
-        return 0;
-}
-
-static int intel_hdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
-                                           struct hda_codec *codec,
-                                           struct snd_pcm_substream *substream)
-{
-        return 0;
+        return hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
 }
 
 static struct hda_pcm_stream intel_hdmi_pcm_playback = {
         .substreams = 1,
         .channels_min = 2,
         .ops = {
+                .open = hdmi_pcm_open,
                 .prepare = intel_hdmi_playback_pcm_prepare,
-                .cleanup = intel_hdmi_playback_pcm_cleanup,
         },
 };
 
diff --git a/sound/pci/hda/patch_nvhdmi.c b/sound/pci/hda/patch_nvhdmi.c
index b0652acee9b2..69b950d527c3 100644
--- a/sound/pci/hda/patch_nvhdmi.c
+++ b/sound/pci/hda/patch_nvhdmi.c
@@ -202,8 +202,7 @@ static int nvhdmi_dig_playback_pcm_prepare_8ch_89(struct hda_pcm_stream *hinfo,
 
         hdmi_setup_audio_infoframe(codec, hinfo->nid, substream);
 
-        hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
-        return 0;
+        return hdmi_setup_stream(codec, hinfo->nid, stream_tag, format);
 }
 
 static int nvhdmi_dig_playback_pcm_prepare_8ch(struct hda_pcm_stream *hinfo,
@@ -327,13 +326,6 @@ static int nvhdmi_dig_playback_pcm_prepare_8ch(struct hda_pcm_stream *hinfo,
         return 0;
 }
 
-static int nvhdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
-                                           struct hda_codec *codec,
-                                           struct snd_pcm_substream *substream)
-{
-        return 0;
-}
-
 static int nvhdmi_dig_playback_pcm_prepare_2ch(struct hda_pcm_stream *hinfo,
                                         struct hda_codec *codec,
                                         unsigned int stream_tag,
@@ -348,12 +340,9 @@ static int nvhdmi_dig_playback_pcm_prepare_2ch(struct hda_pcm_stream *hinfo,
 static struct hda_pcm_stream nvhdmi_pcm_digital_playback_8ch_89 = {
         .substreams = 1,
         .channels_min = 2,
-        .rates = SUPPORTED_RATES,
-        .maxbps = SUPPORTED_MAXBPS,
-        .formats = SUPPORTED_FORMATS,
         .ops = {
+                .open = hdmi_pcm_open,
                 .prepare = nvhdmi_dig_playback_pcm_prepare_8ch_89,
-                .cleanup = nvhdmi_playback_pcm_cleanup,
         },
 };
 
@@ -541,26 +530,32 @@ static int patch_nvhdmi_2ch(struct hda_codec *codec)
  * patch entries
  */
 static struct hda_codec_preset snd_hda_preset_nvhdmi[] = {
-        { .id = 0x10de0002, .name = "MCP77/78 HDMI",
-          .patch = patch_nvhdmi_8ch_7x },
-        { .id = 0x10de0003, .name = "MCP77/78 HDMI",
-          .patch = patch_nvhdmi_8ch_7x },
-        { .id = 0x10de0005, .name = "MCP77/78 HDMI",
-          .patch = patch_nvhdmi_8ch_7x },
-        { .id = 0x10de0006, .name = "MCP77/78 HDMI",
-          .patch = patch_nvhdmi_8ch_7x },
-        { .id = 0x10de0007, .name = "MCP79/7A HDMI",
-          .patch = patch_nvhdmi_8ch_7x },
-        { .id = 0x10de000a, .name = "GT220 HDMI",
-          .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de000b, .name = "GT21x HDMI",
-          .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de000c, .name = "MCP89 HDMI",
-          .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de000d, .name = "GT240 HDMI",
-          .patch = patch_nvhdmi_8ch_89 },
-        { .id = 0x10de0067, .name = "MCP67 HDMI", .patch = patch_nvhdmi_2ch },
-        { .id = 0x10de8001, .name = "MCP73 HDMI", .patch = patch_nvhdmi_2ch },
+        { .id = 0x10de0002, .name = "MCP77/78 HDMI",  .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de0003, .name = "MCP77/78 HDMI",  .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de0005, .name = "MCP77/78 HDMI",  .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de0006, .name = "MCP77/78 HDMI",  .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de0007, .name = "MCP79/7A HDMI",  .patch = patch_nvhdmi_8ch_7x },
+        { .id = 0x10de000a, .name = "GPU 0a HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de000b, .name = "GPU 0b HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de000c, .name = "MCP89 HDMI",     .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de000d, .name = "GPU 0d HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0010, .name = "GPU 10 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0011, .name = "GPU 11 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0012, .name = "GPU 12 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0013, .name = "GPU 13 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0014, .name = "GPU 14 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0018, .name = "GPU 18 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0019, .name = "GPU 19 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de001a, .name = "GPU 1a HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de001b, .name = "GPU 1b HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de001c, .name = "GPU 1c HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0040, .name = "GPU 40 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0041, .name = "GPU 41 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0042, .name = "GPU 42 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0043, .name = "GPU 43 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0044, .name = "GPU 44 HDMI/DP", .patch = patch_nvhdmi_8ch_89 },
+        { .id = 0x10de0067, .name = "MCP67 HDMI",     .patch = patch_nvhdmi_2ch },
+        { .id = 0x10de8001, .name = "MCP73 HDMI",     .patch = patch_nvhdmi_2ch },
         {} /* terminator */
 };
 
@@ -573,6 +568,21 @@ MODULE_ALIAS("snd-hda-codec-id:10de000a");
 MODULE_ALIAS("snd-hda-codec-id:10de000b");
 MODULE_ALIAS("snd-hda-codec-id:10de000c");
 MODULE_ALIAS("snd-hda-codec-id:10de000d");
+MODULE_ALIAS("snd-hda-codec-id:10de0010");
+MODULE_ALIAS("snd-hda-codec-id:10de0011");
+MODULE_ALIAS("snd-hda-codec-id:10de0012");
+MODULE_ALIAS("snd-hda-codec-id:10de0013");
+MODULE_ALIAS("snd-hda-codec-id:10de0014");
+MODULE_ALIAS("snd-hda-codec-id:10de0018");
+MODULE_ALIAS("snd-hda-codec-id:10de0019");
+MODULE_ALIAS("snd-hda-codec-id:10de001a");
+MODULE_ALIAS("snd-hda-codec-id:10de001b");
+MODULE_ALIAS("snd-hda-codec-id:10de001c");
+MODULE_ALIAS("snd-hda-codec-id:10de0040");
+MODULE_ALIAS("snd-hda-codec-id:10de0041");
+MODULE_ALIAS("snd-hda-codec-id:10de0042");
+MODULE_ALIAS("snd-hda-codec-id:10de0043");
+MODULE_ALIAS("snd-hda-codec-id:10de0044");
 MODULE_ALIAS("snd-hda-codec-id:10de0067");
 MODULE_ALIAS("snd-hda-codec-id:10de8001");
 
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 596ea2f12cf6..bcbf9160ed81 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -137,6 +137,7 @@ enum {
         ALC269VB_DMIC,
         ALC269_FUJITSU,
         ALC269_LIFEBOOK,
+        ALC271_ACER,
         ALC269_AUTO,
         ALC269_MODEL_LAST /* last tag */
 };
@@ -256,6 +257,13 @@ enum {
         ALC882_MODEL_LAST,
 };
 
+/* ALC680 models */
+enum {
+        ALC680_BASE,
+        ALC680_AUTO,
+        ALC680_MODEL_LAST,
+};
+
 /* for GPIO Poll */
 #define GPIO_MASK       0x03
 
@@ -326,6 +334,12 @@ struct alc_spec {
         hda_nid_t *capsrc_nids;
         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 
+        /* capture setup for dynamic dual-adc switch */
+        unsigned int cur_adc_idx;
+        hda_nid_t cur_adc;
+        unsigned int cur_adc_stream_tag;
+        unsigned int cur_adc_format;
+
         /* capture source */
         unsigned int num_mux_defs;
         const struct hda_input_mux *input_mux;
@@ -367,6 +381,7 @@ struct alc_spec {
 
         /* other flags */
         unsigned int no_analog :1; /* digital I/O only */
+        unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
         int init_amp;
 
         /* for virtual master */
@@ -833,9 +848,13 @@ static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 
         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
                 unsigned int pincap;
+                unsigned int oldval;
+                oldval = snd_hda_codec_read(codec, nid, 0,
+                                            AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
                 pincap = snd_hda_query_pin_caps(codec, nid);
                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
-                if (pincap & AC_PINCAP_VREF_80)
+                /* if the default pin setup is vref50, we give it priority */
+                if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
                         val = PIN_VREF80;
                 else if (pincap & AC_PINCAP_VREF_50)
                         val = PIN_VREF50;
@@ -1003,6 +1022,29 @@ static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
         return -1;
 }
 
+/* switch the current ADC according to the jack state */
+static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        unsigned int present;
+        hda_nid_t new_adc;
+
+        present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
+        if (present)
+                spec->cur_adc_idx = 1;
+        else
+                spec->cur_adc_idx = 0;
+        new_adc = spec->adc_nids[spec->cur_adc_idx];
+        if (spec->cur_adc && spec->cur_adc != new_adc) {
+                /* stream is running, let's swap the current ADC */
+                __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
+                spec->cur_adc = new_adc;
+                snd_hda_codec_setup_stream(codec, new_adc,
+                                           spec->cur_adc_stream_tag, 0,
+                                           spec->cur_adc_format);
+        }
+}
+
 static void alc_mic_automute(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
@@ -1017,6 +1059,11 @@ static void alc_mic_automute(struct hda_codec *codec)
         if (snd_BUG_ON(!spec->adc_nids))
                 return;
 
+        if (spec->dual_adc_switch) {
+                alc_dual_mic_adc_auto_switch(codec);
+                return;
+        }
+
         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
 
         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
@@ -1499,6 +1546,63 @@ static int alc_read_coef_idx(struct hda_codec *codec,
         return val;
 }
 
+/* set right pin controls for digital I/O */
+static void alc_auto_init_digital(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        int i;
+        hda_nid_t pin;
+
+        for (i = 0; i < spec->autocfg.dig_outs; i++) {
+                pin = spec->autocfg.dig_out_pins[i];
+                if (pin) {
+                        snd_hda_codec_write(codec, pin, 0,
+                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                            PIN_OUT);
+                }
+        }
+        pin = spec->autocfg.dig_in_pin;
+        if (pin)
+                snd_hda_codec_write(codec, pin, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
+                                    PIN_IN);
+}
+
+/* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
+static void alc_auto_parse_digital(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        int i, err;
+        hda_nid_t dig_nid;
+
+        /* support multiple SPDIFs; the secondary is set up as a slave */
+        for (i = 0; i < spec->autocfg.dig_outs; i++) {
+                err = snd_hda_get_connections(codec,
+                                              spec->autocfg.dig_out_pins[i],
+                                              &dig_nid, 1);
+                if (err < 0)
+                        continue;
+                if (!i) {
+                        spec->multiout.dig_out_nid = dig_nid;
+                        spec->dig_out_type = spec->autocfg.dig_out_type[0];
+                } else {
+                        spec->multiout.slave_dig_outs = spec->slave_dig_outs;
+                        if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
+                                break;
+                        spec->slave_dig_outs[i - 1] = dig_nid;
+                }
+        }
+
+        if (spec->autocfg.dig_in_pin) {
+                hda_nid_t dig_nid;
+                err = snd_hda_get_connections(codec,
+                                              spec->autocfg.dig_in_pin,
+                                              &dig_nid, 1);
+                if (err > 0)
+                        spec->dig_in_nid = dig_nid;
+        }
+}
+
 /*
  * ALC888
  */
@@ -3607,6 +3711,41 @@ static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
         return 0;
 }
 
+/* analog capture with dynamic dual-adc changes */
+static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
+                                       struct hda_codec *codec,
+                                       unsigned int stream_tag,
+                                       unsigned int format,
+                                       struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+        spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
+        spec->cur_adc_stream_tag = stream_tag;
+        spec->cur_adc_format = format;
+        snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
+        return 0;
+}
+
+static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                       struct hda_codec *codec,
+                                       struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+        snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
+        spec->cur_adc = 0;
+        return 0;
+}
+
+static struct hda_pcm_stream dualmic_pcm_analog_capture = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = 0, /* fill later */
+        .ops = {
+                .prepare = dualmic_capture_pcm_prepare,
+                .cleanup = dualmic_capture_pcm_cleanup
+        },
+};
 
 /*
  */
@@ -4936,7 +5075,7 @@ static void alc880_auto_init_input_src(struct hda_codec *codec)
 static int alc880_parse_auto_config(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
-        int i, err;
+        int err;
         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
 
         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
@@ -4967,25 +5106,7 @@ static int alc880_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        /* check multiple SPDIF-out (for recent codecs) */
-        for (i = 0; i < spec->autocfg.dig_outs; i++) {
-                hda_nid_t dig_nid;
-                err = snd_hda_get_connections(codec,
-                                              spec->autocfg.dig_out_pins[i],
-                                              &dig_nid, 1);
-                if (err < 0)
-                        continue;
-                if (!i)
-                        spec->multiout.dig_out_nid = dig_nid;
-                else {
-                        spec->multiout.slave_dig_outs = spec->slave_dig_outs;
-                        if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
-                                break;
-                        spec->slave_dig_outs[i - 1] = dig_nid;
-                }
-        }
-        if (spec->autocfg.dig_in_pin)
-                spec->dig_in_nid = ALC880_DIGIN_NID;
+        alc_auto_parse_digital(codec);
 
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
@@ -5008,6 +5129,7 @@ static void alc880_auto_init(struct hda_codec *codec)
         alc880_auto_init_extra_out(codec);
         alc880_auto_init_analog_input(codec);
         alc880_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
@@ -5045,6 +5167,39 @@ static void fixup_automic_adc(struct hda_codec *codec)
         spec->auto_mic = 0; /* disable auto-mic to be sure */
 }
 
+/* select or unmute the given capsrc route */
+static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
+                                    int idx)
+{
+        if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
+                snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
+                                         HDA_AMP_MUTE, 0);
+        } else {
+                snd_hda_codec_write_cache(codec, cap, 0,
+                                          AC_VERB_SET_CONNECT_SEL, idx);
+        }
+}
+
+/* set the default connection to that pin */
+static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
+{
+        struct alc_spec *spec = codec->spec;
+        int i;
+
+        for (i = 0; i < spec->num_adc_nids; i++) {
+                hda_nid_t cap = spec->capsrc_nids ?
+                        spec->capsrc_nids[i] : spec->adc_nids[i];
+                int idx;
+
+                idx = get_connection_index(codec, cap, pin);
+                if (idx < 0)
+                        continue;
+                select_or_unmute_capsrc(codec, cap, idx);
+                return i; /* return the found index */
+        }
+        return -1; /* not found */
+}
+
 /* choose the ADC/MUX containing the input pin and initialize the setup */
 static void fixup_single_adc(struct hda_codec *codec)
 {
@@ -5061,33 +5216,24 @@ static void fixup_single_adc(struct hda_codec *codec)
         }
         if (!pin)
                 return;
-
-        /* set the default connection to that pin */
-        for (i = 0; i < spec->num_adc_nids; i++) {
-                hda_nid_t cap = spec->capsrc_nids ?
-                        spec->capsrc_nids[i] : spec->adc_nids[i];
-                int idx;
-
-                idx = get_connection_index(codec, cap, pin);
-                if (idx < 0)
-                        continue;
+        i = init_capsrc_for_pin(codec, pin);
+        if (i >= 0) {
                 /* use only this ADC */
                 if (spec->capsrc_nids)
                         spec->capsrc_nids += i;
                 spec->adc_nids += i;
                 spec->num_adc_nids = 1;
-                /* select or unmute this route */
-                if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
-                        snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
-                                                 HDA_AMP_MUTE, 0);
-                } else {
-                        snd_hda_codec_write_cache(codec, cap, 0,
-                                          AC_VERB_SET_CONNECT_SEL, idx);
-                }
-                return;
         }
 }
 
+/* initialize dual adcs */
+static void fixup_dual_adc_switch(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        init_capsrc_for_pin(codec, spec->ext_mic.pin);
+        init_capsrc_for_pin(codec, spec->int_mic.pin);
+}
+
 static void set_capture_mixer(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
@@ -5101,7 +5247,10 @@ static void set_capture_mixer(struct hda_codec *codec)
         };
         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
                 int mux = 0;
-                if (spec->auto_mic)
+                int num_adcs = spec->num_adc_nids;
+                if (spec->dual_adc_switch)
+                        fixup_dual_adc_switch(codec);
+                else if (spec->auto_mic)
                         fixup_automic_adc(codec);
                 else if (spec->input_mux) {
                         if (spec->input_mux->num_items > 1)
@@ -5109,7 +5258,9 @@ static void set_capture_mixer(struct hda_codec *codec)
                         else if (spec->input_mux->num_items == 1)
                                 fixup_single_adc(codec);
                 }
-                spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
+                if (spec->dual_adc_switch)
+                        num_adcs = 1;
+                spec->cap_mixer = caps[mux][num_adcs - 1];
         }
 }
 
@@ -5183,6 +5334,8 @@ static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
 
 static struct snd_pci_quirk beep_white_list[] = {
         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
+        SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
+        SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
         {}
 };
 
@@ -6624,6 +6777,7 @@ static void alc260_auto_init(struct hda_codec *codec)
         alc260_auto_init_multi_out(codec);
         alc260_auto_init_analog_input(codec);
         alc260_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
@@ -6640,6 +6794,29 @@ static struct hda_amp_list alc260_loopbacks[] = {
 #endif
 
 /*
+ * Pin config fixes
+ */
+enum {
+        PINFIX_HP_DC5750,
+};
+
+static struct alc_pincfg alc260_hp_dc5750_pinfix[] = {
+        { 0x11, 0x90130110 }, /* speaker */
+        { }
+};
+
+static const struct alc_fixup alc260_fixups[] = {
+        [PINFIX_HP_DC5750] = {
+                .pins = alc260_hp_dc5750_pinfix
+        },
+};
+
+static struct snd_pci_quirk alc260_fixup_tbl[] = {
+        SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
+        {}
+};
+
+/*
  * ALC260 configurations
  */
 static const char *alc260_models[ALC260_MODEL_LAST] = {
@@ -6838,6 +7015,9 @@ static int patch_alc260(struct hda_codec *codec)
                 board_config = ALC260_AUTO;
         }
 
+        if (board_config == ALC260_AUTO)
+                alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 1);
+
         if (board_config == ALC260_AUTO) {
                 /* automatic parse from the BIOS config */
                 err = alc260_parse_auto_config(codec);
@@ -6863,6 +7043,7 @@ static int patch_alc260(struct hda_codec *codec)
 
         spec->stream_analog_playback = &alc260_pcm_analog_playback;
         spec->stream_analog_capture = &alc260_pcm_analog_capture;
+        spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
 
         spec->stream_digital_playback = &alc260_pcm_digital_playback;
         spec->stream_digital_capture = &alc260_pcm_digital_capture;
@@ -6883,6 +7064,9 @@ static int patch_alc260(struct hda_codec *codec)
         set_capture_mixer(codec);
         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
 
+        if (board_config == ALC260_AUTO)
+                alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 0);
+
         spec->vmaster_nid = 0x08;
 
         codec->patch_ops = alc_patch_ops;
@@ -7003,7 +7187,7 @@ static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
         .num_items = 4,
         .items = {
                 { "Mic", 0x0 },
-                { "iMic", 0x1 },
+                { "Int Mic", 0x1 },
                 { "Line", 0x2 },
                 { "CD", 0x4 },
         },
@@ -8573,8 +8757,8 @@ static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
-        HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
+        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
         { } /* end */
 };
 
@@ -10265,7 +10449,8 @@ static struct alc_config_preset alc882_presets[] = {
  * Pin config fixes
  */
 enum {
-        PINFIX_ABIT_AW9D_MAX
+        PINFIX_ABIT_AW9D_MAX,
+        PINFIX_PB_M5210,
 };
 
 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
@@ -10275,13 +10460,22 @@ static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
         { }
 };
 
+static const struct hda_verb pb_m5210_verbs[] = {
+        { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
+        {}
+};
+
 static const struct alc_fixup alc882_fixups[] = {
         [PINFIX_ABIT_AW9D_MAX] = {
                 .pins = alc882_abit_aw9d_pinfix
         },
+        [PINFIX_PB_M5210] = {
+                .verbs = pb_m5210_verbs
+        },
 };
 
 static struct snd_pci_quirk alc882_fixup_tbl[] = {
+        SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
         {}
 };
@@ -10446,7 +10640,7 @@ static int alc882_parse_auto_config(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
-        int i, err;
+        int err;
 
         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
                                            alc882_ignore);
@@ -10476,25 +10670,7 @@ static int alc882_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        /* check multiple SPDIF-out (for recent codecs) */
-        for (i = 0; i < spec->autocfg.dig_outs; i++) {
-                hda_nid_t dig_nid;
-                err = snd_hda_get_connections(codec,
-                                              spec->autocfg.dig_out_pins[i],
-                                              &dig_nid, 1);
-                if (err < 0)
-                        continue;
-                if (!i)
-                        spec->multiout.dig_out_nid = dig_nid;
-                else {
-                        spec->multiout.slave_dig_outs = spec->slave_dig_outs;
-                        if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
-                                break;
-                        spec->slave_dig_outs[i - 1] = dig_nid;
-                }
-        }
-        if (spec->autocfg.dig_in_pin)
-                spec->dig_in_nid = ALC880_DIGIN_NID;
+        alc_auto_parse_digital(codec);
 
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
@@ -10524,6 +10700,7 @@ static void alc882_auto_init(struct hda_codec *codec)
         alc882_auto_init_hp_out(codec);
         alc882_auto_init_analog_input(codec);
         alc882_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
@@ -12054,12 +12231,7 @@ static int alc262_parse_auto_config(struct hda_codec *codec)
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
  dig_only:
-        if (spec->autocfg.dig_outs) {
-                spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
-                spec->dig_out_type = spec->autocfg.dig_out_type[0];
-        }
-        if (spec->autocfg.dig_in_pin)
-                spec->dig_in_nid = ALC262_DIGIN_NID;
+        alc_auto_parse_digital(codec);
 
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
@@ -12091,6 +12263,7 @@ static void alc262_auto_init(struct hda_codec *codec)
         alc262_auto_init_hp_out(codec);
         alc262_auto_init_analog_input(codec);
         alc262_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
@@ -13024,10 +13197,14 @@ static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
                 dac = 0x02;
                 break;
         case 0x15:
+        case 0x1a: /* ALC259/269 only */
+        case 0x1b: /* ALC259/269 only */
         case 0x21: /* ALC269vb has this pin, too */
                 dac = 0x03;
                 break;
         default:
+                snd_printd(KERN_WARNING "hda_codec: "
+                           "ignoring pin 0x%x as unknown\n", nid);
                 return 0;
         }
         if (spec->multiout.dac_nids[0] != dac &&
@@ -13078,7 +13255,7 @@ static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
                 if (err < 0)
                         return err;
-        } else {
+        } else if (nid) {
                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
                 if (err < 0)
                         return err;
@@ -13227,10 +13404,7 @@ static int alc268_parse_auto_config(struct hda_codec *codec)
 
  dig_only:
         /* digital only support output */
-        if (spec->autocfg.dig_outs) {
-                spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
-                spec->dig_out_type = spec->autocfg.dig_out_type[0];
-        }
+        alc_auto_parse_digital(codec);
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
 
@@ -13260,6 +13434,7 @@ static void alc268_auto_init(struct hda_codec *codec)
         alc268_auto_init_hp_out(codec);
         alc268_auto_init_mono_speaker_out(codec);
         alc268_auto_init_analog_input(codec);
+        alc_auto_init_digital(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
@@ -13303,7 +13478,6 @@ static struct snd_pci_quirk alc268_cfg_tbl[] = {
         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
-        SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
         {}
 };
 
@@ -13694,6 +13868,12 @@ static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
         { } /* end */
 };
 
+static struct snd_kcontrol_new alc269_asus_mixer[] = {
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
+        { } /* end */
+};
+
 /* capture mixer elements */
 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
@@ -13914,6 +14094,20 @@ static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
         {}
 };
 
+static struct hda_verb alc271_acer_dmic_verbs[] = {
+        {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
+        {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
+        {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
+        {0x22, AC_VERB_SET_CONNECT_SEL, 6},
+        { }
+};
+
 /* toggle speaker-output according to the hp-jack state */
 static void alc269_speaker_automute(struct hda_codec *codec)
 {
@@ -14152,6 +14346,36 @@ static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
 }
 #endif /* CONFIG_SND_HDA_POWER_SAVE */
 
+static int alc275_setup_dual_adc(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
+                return 0;
+        if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
+            (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
+                if (spec->ext_mic.pin <= 0x12) {
+                        spec->private_adc_nids[0] = 0x08;
+                        spec->private_adc_nids[1] = 0x11;
+                        spec->private_capsrc_nids[0] = 0x23;
+                        spec->private_capsrc_nids[1] = 0x22;
+                } else {
+                        spec->private_adc_nids[0] = 0x11;
+                        spec->private_adc_nids[1] = 0x08;
+                        spec->private_capsrc_nids[0] = 0x22;
+                        spec->private_capsrc_nids[1] = 0x23;
+                }
+                spec->adc_nids = spec->private_adc_nids;
+                spec->capsrc_nids = spec->private_capsrc_nids;
+                spec->num_adc_nids = 2;
+                spec->dual_adc_switch = 1;
+                snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
+                            spec->adc_nids[0], spec->adc_nids[1]);
+                return 1;
+        }
+        return 0;
+}
+
 /*
  * BIOS auto configuration
  */
@@ -14175,8 +14399,7 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_outs)
-                spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
+        alc_auto_parse_digital(codec);
 
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
@@ -14191,13 +14414,15 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
 
         spec->num_mux_defs = 1;
         spec->input_mux = &spec->private_imux[0];
-        fillup_priv_adc_nids(codec, alc269_adc_candidates,
-                             sizeof(alc269_adc_candidates));
+
+        if (!alc275_setup_dual_adc(codec))
+                fillup_priv_adc_nids(codec, alc269_adc_candidates,
+                                     sizeof(alc269_adc_candidates));
 
         /* set default input source */
-        snd_hda_codec_write_cache(codec, spec->capsrc_nids[0],
-                                  0, AC_VERB_SET_CONNECT_SEL,
-                                  spec->input_mux->items[0].index);
+        if (!spec->dual_adc_switch)
+                select_or_unmute_capsrc(codec, spec->capsrc_nids[0],
+                                        spec->input_mux->items[0].index);
 
         err = alc_auto_add_mic_boost(codec);
         if (err < 0)
@@ -14221,6 +14446,7 @@ static void alc269_auto_init(struct hda_codec *codec)
         alc269_auto_init_multi_out(codec);
         alc269_auto_init_hp_out(codec);
         alc269_auto_init_analog_input(codec);
+        alc_auto_init_digital(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
@@ -14242,6 +14468,7 @@ static const struct alc_fixup alc269_fixups[] = {
 
 static struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
+        SND_PCI_QUIRK(0x104d, 0x9077, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
         {}
 };
 
@@ -14261,6 +14488,7 @@ static const char *alc269_models[ALC269_MODEL_LAST] = {
 
 static struct snd_pci_quirk alc269_cfg_tbl[] = {
         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
+        SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
                       ALC269_AMIC),
         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
@@ -14422,6 +14650,23 @@ static struct alc_config_preset alc269_presets[] = {
                 .unsol_event = alc269_lifebook_unsol_event,
                 .init_hook = alc269_lifebook_init_hook,
         },
+        [ALC271_ACER] = {
+                .mixers = { alc269_asus_mixer },
+                .cap_mixer = alc269vb_laptop_digital_capture_mixer,
+                .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
+                .num_dacs = ARRAY_SIZE(alc269_dac_nids),
+                .dac_nids = alc269_dac_nids,
+                .adc_nids = alc262_dmic_adc_nids,
+                .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
+                .capsrc_nids = alc262_dmic_capsrc_nids,
+                .num_channel_mode = ARRAY_SIZE(alc269_modes),
+                .channel_mode = alc269_modes,
+                .input_mux = &alc269_capture_source,
+                .dig_out_nid = ALC880_DIGOUT_NID,
+                .unsol_event = alc_sku_unsol_event,
+                .setup = alc269vb_laptop_dmic_setup,
+                .init_hook = alc_inithook,
+        },
 };
 
 static int patch_alc269(struct hda_codec *codec)
@@ -14493,6 +14738,10 @@ static int patch_alc269(struct hda_codec *codec)
                  */
                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
+        } else if (spec->dual_adc_switch) {
+                spec->stream_analog_playback = &alc269_pcm_analog_playback;
+                /* switch ADC dynamically */
+                spec->stream_analog_capture = &dualmic_pcm_analog_capture;
         } else {
                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
@@ -15378,8 +15627,7 @@ static int alc861_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_outs)
-                spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
+        alc_auto_parse_digital(codec);
 
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
@@ -15405,6 +15653,7 @@ static void alc861_auto_init(struct hda_codec *codec)
         alc861_auto_init_multi_out(codec);
         alc861_auto_init_hp_out(codec);
         alc861_auto_init_analog_input(codec);
+        alc_auto_init_digital(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
@@ -16509,8 +16758,7 @@ static int alc861vd_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_outs)
-                spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
+        alc_auto_parse_digital(codec);
 
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
@@ -16537,6 +16785,7 @@ static void alc861vd_auto_init(struct hda_codec *codec)
         alc861vd_auto_init_hp_out(codec);
         alc861vd_auto_init_analog_input(codec);
         alc861vd_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
@@ -18520,7 +18769,7 @@ static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
                                               hda_nid_t dac)
 {
         int i, num;
-        hda_nid_t srcs[4];
+        hda_nid_t srcs[HDA_MAX_CONNECTIONS];
 
         alc_set_pin_output(codec, nid, pin_type);
         /* need the manual connection? */
@@ -18624,8 +18873,7 @@ static int alc662_parse_auto_config(struct hda_codec *codec)
 
         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 
-        if (spec->autocfg.dig_outs)
-                spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
+        alc_auto_parse_digital(codec);
 
         if (spec->kctls.list)
                 add_mixer(spec, spec->kctls.list);
@@ -18635,7 +18883,7 @@ static int alc662_parse_auto_config(struct hda_codec *codec)
 
         add_verb(spec, alc662_init_verbs);
         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
-            codec->vendor_id == 0x10ec0665)
+            codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
                 add_verb(spec, alc663_init_verbs);
 
         if (codec->vendor_id == 0x10ec0272)
@@ -18662,6 +18910,7 @@ static void alc662_auto_init(struct hda_codec *codec)
         alc662_auto_init_hp_out(codec);
         alc662_auto_init_analog_input(codec);
         alc662_auto_init_input_src(codec);
+        alc_auto_init_digital(codec);
         if (spec->unsol_event)
                 alc_inithook(codec);
 }
@@ -18781,6 +19030,445 @@ static int patch_alc888(struct hda_codec *codec)
 }
 
 /*
+ * ALC680 support
+ */
+#define ALC680_DIGIN_NID        ALC880_DIGIN_NID
+#define ALC680_DIGOUT_NID       ALC880_DIGOUT_NID
+#define alc680_modes            alc260_modes
+
+static hda_nid_t alc680_dac_nids[3] = {
+        /* Lout1, Lout2, hp */
+        0x02, 0x03, 0x04
+};
+
+static hda_nid_t alc680_adc_nids[3] = {
+        /* ADC0-2 */
+        /* DMIC, MIC, Line-in*/
+        0x07, 0x08, 0x09
+};
+
+/*
+ * Analog capture ADC cgange
+ */
+static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
+                                      struct hda_codec *codec,
+                                      unsigned int stream_tag,
+                                      unsigned int format,
+                                      struct snd_pcm_substream *substream)
+{
+        struct alc_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        unsigned int pre_mic, pre_line;
+
+        pre_mic  = snd_hda_jack_detect(codec, cfg->input_pins[AUTO_PIN_MIC]);
+        pre_line = snd_hda_jack_detect(codec, cfg->input_pins[AUTO_PIN_LINE]);
+
+        spec->cur_adc_stream_tag = stream_tag;
+        spec->cur_adc_format = format;
+
+        if (pre_mic || pre_line) {
+                if (pre_mic)
+                        snd_hda_codec_setup_stream(codec, 0x08, stream_tag, 0,
+                                                                        format);
+                else
+                        snd_hda_codec_setup_stream(codec, 0x09, stream_tag, 0,
+                                                                        format);
+        } else
+                snd_hda_codec_setup_stream(codec, 0x07, stream_tag, 0, format);
+        return 0;
+}
+
+static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
+                                      struct hda_codec *codec,
+                                      struct snd_pcm_substream *substream)
+{
+        snd_hda_codec_cleanup_stream(codec, 0x07);
+        snd_hda_codec_cleanup_stream(codec, 0x08);
+        snd_hda_codec_cleanup_stream(codec, 0x09);
+        return 0;
+}
+
+static struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
+        .substreams = 1, /* can be overridden */
+        .channels_min = 2,
+        .channels_max = 2,
+        /* NID is set in alc_build_pcms */
+        .ops = {
+                .prepare = alc680_capture_pcm_prepare,
+                .cleanup = alc680_capture_pcm_cleanup
+        },
+};
+
+static struct snd_kcontrol_new alc680_base_mixer[] = {
+        /* output mixer control */
+        HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Int Mic Boost", 0x12, 0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Line In Boost", 0x19, 0, HDA_INPUT),
+        { }
+};
+
+static struct hda_bind_ctls alc680_bind_cap_vol = {
+        .ops = &snd_hda_bind_vol,
+        .values = {
+                HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
+                HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
+                HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
+                0
+        },
+};
+
+static struct hda_bind_ctls alc680_bind_cap_switch = {
+        .ops = &snd_hda_bind_sw,
+        .values = {
+                HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
+                HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
+                HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
+                0
+        },
+};
+
+static struct snd_kcontrol_new alc680_master_capture_mixer[] = {
+        HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
+        HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
+        { } /* end */
+};
+
+/*
+ * generic initialization of ADC, input mixers and output mixers
+ */
+static struct hda_verb alc680_init_verbs[] = {
+        {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
+
+        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
+        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
+
+        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+
+        {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
+        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
+
+        { }
+};
+
+/* toggle speaker-output according to the hp-jack state */
+static void alc680_base_setup(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        spec->autocfg.hp_pins[0] = 0x16;
+        spec->autocfg.speaker_pins[0] = 0x14;
+        spec->autocfg.speaker_pins[1] = 0x15;
+        spec->autocfg.input_pins[AUTO_PIN_MIC] = 0x18;
+        spec->autocfg.input_pins[AUTO_PIN_LINE] = 0x19;
+}
+
+static void alc680_rec_autoswitch(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        struct auto_pin_cfg *cfg = &spec->autocfg;
+        unsigned int present;
+        hda_nid_t new_adc;
+
+        present = snd_hda_jack_detect(codec, cfg->input_pins[AUTO_PIN_MIC]);
+
+        new_adc = present ? 0x8 : 0x7;
+        __snd_hda_codec_cleanup_stream(codec, !present ? 0x8 : 0x7, 1);
+        snd_hda_codec_setup_stream(codec, new_adc,
+                                   spec->cur_adc_stream_tag, 0,
+                                   spec->cur_adc_format);
+
+}
+
+static void alc680_unsol_event(struct hda_codec *codec,
+                                           unsigned int res)
+{
+        if ((res >> 26) == ALC880_HP_EVENT)
+                alc_automute_amp(codec);
+        if ((res >> 26) == ALC880_MIC_EVENT)
+                alc680_rec_autoswitch(codec);
+}
+
+static void alc680_inithook(struct hda_codec *codec)
+{
+        alc_automute_amp(codec);
+        alc680_rec_autoswitch(codec);
+}
+
+/* create input playback/capture controls for the given pin */
+static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
+                                    const char *ctlname, int idx)
+{
+        hda_nid_t dac;
+        int err;
+
+        switch (nid) {
+        case 0x14:
+                dac = 0x02;
+                break;
+        case 0x15:
+                dac = 0x03;
+                break;
+        case 0x16:
+                dac = 0x04;
+                break;
+        default:
+                return 0;
+        }
+        if (spec->multiout.dac_nids[0] != dac &&
+            spec->multiout.dac_nids[1] != dac) {
+                err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
+                                  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
+                                                      HDA_OUTPUT));
+                if (err < 0)
+                        return err;
+
+                err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
+                          HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
+
+                if (err < 0)
+                        return err;
+                spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
+        }
+
+        return 0;
+}
+
+/* add playback controls from the parsed DAC table */
+static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
+                                             const struct auto_pin_cfg *cfg)
+{
+        hda_nid_t nid;
+        int err;
+
+        spec->multiout.dac_nids = spec->private_dac_nids;
+
+        nid = cfg->line_out_pins[0];
+        if (nid) {
+                const char *name;
+                if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
+                        name = "Speaker";
+                else
+                        name = "Front";
+                err = alc680_new_analog_output(spec, nid, name, 0);
+                if (err < 0)
+                        return err;
+        }
+
+        nid = cfg->speaker_pins[0];
+        if (nid) {
+                err = alc680_new_analog_output(spec, nid, "Speaker", 0);
+                if (err < 0)
+                        return err;
+        }
+        nid = cfg->hp_pins[0];
+        if (nid) {
+                err = alc680_new_analog_output(spec, nid, "Headphone", 0);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
+                                              hda_nid_t nid, int pin_type)
+{
+        alc_set_pin_output(codec, nid, pin_type);
+}
+
+static void alc680_auto_init_multi_out(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t nid = spec->autocfg.line_out_pins[0];
+        if (nid) {
+                int pin_type = get_pin_type(spec->autocfg.line_out_type);
+                alc680_auto_set_output_and_unmute(codec, nid, pin_type);
+        }
+}
+
+static void alc680_auto_init_hp_out(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        hda_nid_t pin;
+
+        pin = spec->autocfg.hp_pins[0];
+        if (pin)
+                alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
+        pin = spec->autocfg.speaker_pins[0];
+        if (pin)
+                alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
+}
+
+/* pcm configuration: identical with ALC880 */
+#define alc680_pcm_analog_playback      alc880_pcm_analog_playback
+#define alc680_pcm_analog_capture       alc880_pcm_analog_capture
+#define alc680_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
+#define alc680_pcm_digital_playback     alc880_pcm_digital_playback
+#define alc680_pcm_digital_capture      alc880_pcm_digital_capture
+
+/*
+ * BIOS auto configuration
+ */
+static int alc680_parse_auto_config(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        int err;
+        static hda_nid_t alc680_ignore[] = { 0 };
+
+        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
+                                           alc680_ignore);
+        if (err < 0)
+                return err;
+
+        if (!spec->autocfg.line_outs) {
+                if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
+                        spec->multiout.max_channels = 2;
+                        spec->no_analog = 1;
+                        goto dig_only;
+                }
+                return 0; /* can't find valid BIOS pin config */
+        }
+        err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
+        if (err < 0)
+                return err;
+
+        spec->multiout.max_channels = 2;
+
+ dig_only:
+        /* digital only support output */
+        alc_auto_parse_digital(codec);
+        if (spec->kctls.list)
+                add_mixer(spec, spec->kctls.list);
+
+        add_verb(spec, alc680_init_verbs);
+
+        err = alc_auto_add_mic_boost(codec);
+        if (err < 0)
+                return err;
+
+        return 1;
+}
+
+#define alc680_auto_init_analog_input   alc882_auto_init_analog_input
+
+/* init callback for auto-configuration model -- overriding the default init */
+static void alc680_auto_init(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+        alc680_auto_init_multi_out(codec);
+        alc680_auto_init_hp_out(codec);
+        alc680_auto_init_analog_input(codec);
+        alc_auto_init_digital(codec);
+        if (spec->unsol_event)
+                alc_inithook(codec);
+}
+
+/*
+ * configuration and preset
+ */
+static const char *alc680_models[ALC680_MODEL_LAST] = {
+        [ALC680_BASE]           = "base",
+        [ALC680_AUTO]           = "auto",
+};
+
+static struct snd_pci_quirk alc680_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
+        {}
+};
+
+static struct alc_config_preset alc680_presets[] = {
+        [ALC680_BASE] = {
+                .mixers = { alc680_base_mixer },
+                .cap_mixer =  alc680_master_capture_mixer,
+                .init_verbs = { alc680_init_verbs },
+                .num_dacs = ARRAY_SIZE(alc680_dac_nids),
+                .dac_nids = alc680_dac_nids,
+                .dig_out_nid = ALC680_DIGOUT_NID,
+                .num_channel_mode = ARRAY_SIZE(alc680_modes),
+                .channel_mode = alc680_modes,
+                .unsol_event = alc680_unsol_event,
+                .setup = alc680_base_setup,
+                .init_hook = alc680_inithook,
+
+        },
+};
+
+static int patch_alc680(struct hda_codec *codec)
+{
+        struct alc_spec *spec;
+        int board_config;
+        int err;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+
+        board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
+                                                  alc680_models,
+                                                  alc680_cfg_tbl);
+
+        if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
+                printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
+                       codec->chip_name);
+                board_config = ALC680_AUTO;
+        }
+
+        if (board_config == ALC680_AUTO) {
+                /* automatic parse from the BIOS config */
+                err = alc680_parse_auto_config(codec);
+                if (err < 0) {
+                        alc_free(codec);
+                        return err;
+                } else if (!err) {
+                        printk(KERN_INFO
+                               "hda_codec: Cannot set up configuration "
+                               "from BIOS.  Using base mode...\n");
+                        board_config = ALC680_BASE;
+                }
+        }
+
+        if (board_config != ALC680_AUTO)
+                setup_preset(codec, &alc680_presets[board_config]);
+
+        spec->stream_analog_playback = &alc680_pcm_analog_playback;
+        spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
+        spec->stream_digital_playback = &alc680_pcm_digital_playback;
+        spec->stream_digital_capture = &alc680_pcm_digital_capture;
+
+        if (!spec->adc_nids) {
+                spec->adc_nids = alc680_adc_nids;
+                spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
+        }
+
+        if (!spec->cap_mixer)
+                set_capture_mixer(codec);
+
+        spec->vmaster_nid = 0x02;
+
+        codec->patch_ops = alc_patch_ops;
+        if (board_config == ALC680_AUTO)
+                spec->init_hook = alc680_auto_init;
+
+        return 0;
+}
+
+/*
  * patch entries
  */
 static struct hda_codec_preset snd_hda_preset_realtek[] = {
@@ -18804,6 +19492,7 @@ static struct hda_codec_preset snd_hda_preset_realtek[] = {
         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
+        { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index f1e7babd6920..95148e58026c 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -94,6 +94,7 @@ enum {
         STAC_92HD83XXX_PWR_REF,
         STAC_DELL_S14,
         STAC_92HD83XXX_HP,
+        STAC_HP_DV7_4000,
         STAC_92HD83XXX_MODELS
 };
 
@@ -202,6 +203,7 @@ struct sigmatel_spec {
         unsigned int spdif_mute: 1;
         unsigned int check_volume_offset:1;
         unsigned int auto_mic:1;
+        unsigned int linear_tone_beep:1;
 
         /* gpio lines */
         unsigned int eapd_mask;
@@ -1631,10 +1633,17 @@ static unsigned int dell_s14_pin_configs[10] = {
         0x40f000f0, 0x40f000f0,
 };
 
+static unsigned int hp_dv7_4000_pin_configs[10] = {
+        0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110,
+        0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140,
+        0x40f000f0, 0x40f000f0,
+};
+
 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
         [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
         [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
         [STAC_DELL_S14] = dell_s14_pin_configs,
+        [STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs,
 };
 
 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
@@ -1643,6 +1652,7 @@ static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
         [STAC_92HD83XXX_PWR_REF] = "mic-ref",
         [STAC_DELL_S14] = "dell-s14",
         [STAC_92HD83XXX_HP] = "hp",
+        [STAC_HP_DV7_4000] = "hp-dv7-4000",
 };
 
 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
@@ -3802,7 +3812,7 @@ static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out
                         return err;
                 if (codec->beep) {
                         /* IDT/STAC codecs have linear beep tone parameter */
-                        codec->beep->linear_tone = 1;
+                        codec->beep->linear_tone = spec->linear_tone_beep;
                         /* if no beep switch is available, make its own one */
                         caps = query_amp_caps(codec, nid, HDA_OUTPUT);
                         if (!(caps & AC_AMPCAP_MUTE)) {
@@ -5005,6 +5015,7 @@ static int patch_stac9200(struct hda_codec *codec)
 
         codec->no_trigger_sense = 1;
         codec->spec = spec;
+        spec->linear_tone_beep = 1;
         spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
         spec->pin_nids = stac9200_pin_nids;
         spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
@@ -5068,6 +5079,7 @@ static int patch_stac925x(struct hda_codec *codec)
 
         codec->no_trigger_sense = 1;
         codec->spec = spec;
+        spec->linear_tone_beep = 1;
         spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
         spec->pin_nids = stac925x_pin_nids;
 
@@ -5153,6 +5165,7 @@ static int patch_stac92hd73xx(struct hda_codec *codec)
 
         codec->no_trigger_sense = 1;
         codec->spec = spec;
+        spec->linear_tone_beep = 0;
         codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
         spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
         spec->pin_nids = stac92hd73xx_pin_nids;
@@ -5300,6 +5313,7 @@ static int patch_stac92hd83xxx(struct hda_codec *codec)
 
         codec->no_trigger_sense = 1;
         codec->spec = spec;
+        spec->linear_tone_beep = 1;
         codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
         spec->digbeep_nid = 0x21;
         spec->mux_nids = stac92hd83xxx_mux_nids;
@@ -5335,6 +5349,8 @@ again:
         case 0x111d7667:
         case 0x111d7668:
         case 0x111d7669:
+        case 0x111d76d1:
+        case 0x111d76d9:
                 spec->num_pins = ARRAY_SIZE(stac92hd88xxx_pin_nids);
                 spec->pin_nids = stac92hd88xxx_pin_nids;
                 spec->mono_nid = 0;
@@ -5522,6 +5538,7 @@ static int patch_stac92hd71bxx(struct hda_codec *codec)
 
         codec->no_trigger_sense = 1;
         codec->spec = spec;
+        spec->linear_tone_beep = 0;
         codec->patch_ops = stac92xx_patch_ops;
         spec->num_pins = STAC92HD71BXX_NUM_PINS;
         switch (codec->vendor_id) {
@@ -5779,6 +5796,7 @@ static int patch_stac922x(struct hda_codec *codec)
 
         codec->no_trigger_sense = 1;
         codec->spec = spec;
+        spec->linear_tone_beep = 1;
         spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
         spec->pin_nids = stac922x_pin_nids;
         spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
@@ -5883,6 +5901,7 @@ static int patch_stac927x(struct hda_codec *codec)
 
         codec->no_trigger_sense = 1;
         codec->spec = spec;
+        spec->linear_tone_beep = 1;
         codec->slave_dig_outs = stac927x_slave_dig_outs;
         spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
         spec->pin_nids = stac927x_pin_nids;
@@ -6018,6 +6037,7 @@ static int patch_stac9205(struct hda_codec *codec)
 
         codec->no_trigger_sense = 1;
         codec->spec = spec;
+        spec->linear_tone_beep = 1;
         spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
         spec->pin_nids = stac9205_pin_nids;
         spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
@@ -6174,6 +6194,7 @@ static int patch_stac9872(struct hda_codec *codec)
                 return -ENOMEM;
         codec->no_trigger_sense = 1;
         codec->spec = spec;
+        spec->linear_tone_beep = 1;
         spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
         spec->pin_nids = stac9872_pin_nids;
 
@@ -6264,6 +6285,8 @@ static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
         { .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx},
         { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
         { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
+        { .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx},
+        { .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx},
         { .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx},
         { .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx},
         { .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx},
@@ -6280,6 +6303,21 @@ static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
         { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
         { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
         { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
+        { .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx },
+        { .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx },
         {} /* terminator */
 };
 
diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c
index 73453814e098..ae3acb2b42d1 100644
--- a/sound/pci/hda/patch_via.c
+++ b/sound/pci/hda/patch_via.c
@@ -552,24 +552,30 @@ static void via_auto_init_hp_out(struct hda_codec *codec)
         }
 }
 
+static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin);
+
 static void via_auto_init_analog_input(struct hda_codec *codec)
 {
         struct via_spec *spec = codec->spec;
+        unsigned int ctl;
         int i;
 
         for (i = 0; i < AUTO_PIN_LAST; i++) {
                 hda_nid_t nid = spec->autocfg.input_pins[i];
+                if (!nid)
+                        continue;
 
+                if (spec->smart51_enabled && is_smart51_pins(spec, nid))
+                        ctl = PIN_OUT;
+                else if (i <= AUTO_PIN_FRONT_MIC)
+                        ctl = PIN_VREF50;
+                else
+                        ctl = PIN_IN;
                 snd_hda_codec_write(codec, nid, 0,
-                                    AC_VERB_SET_PIN_WIDGET_CONTROL,
-                                    (i <= AUTO_PIN_FRONT_MIC ?
-                                     PIN_VREF50 : PIN_IN));
-
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
         }
 }
 
-static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin);
-
 static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
                                 unsigned int *affected_parm)
 {
@@ -658,6 +664,8 @@ static void set_jack_power_state(struct hda_codec *codec)
                 /* PW0 (19h), SW1 (18h), AOW1 (11h) */
                 parm = AC_PWRST_D3;
                 set_pin_power_state(codec, 0x19, &parm);
+                if (spec->smart51_enabled)
+                        parm = AC_PWRST_D0;
                 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE,
                                     parm);
                 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE,
@@ -667,6 +675,8 @@ static void set_jack_power_state(struct hda_codec *codec)
                 if (is_8ch) {
                         parm = AC_PWRST_D3;
                         set_pin_power_state(codec, 0x22, &parm);
+                        if (spec->smart51_enabled)
+                                parm = AC_PWRST_D0;
                         snd_hda_codec_write(codec, 0x26, 0,
                                             AC_VERB_SET_POWER_STATE, parm);
                         snd_hda_codec_write(codec, 0x24, 0,
@@ -3915,6 +3925,13 @@ static int vt1708S_auto_fill_dac_nids(struct via_spec *spec,
                 }
         }
 
+        /* for Smart 5.1, line/mic inputs double as output pins */
+        if (cfg->line_outs == 1) {
+                spec->multiout.num_dacs = 3;
+                spec->multiout.dac_nids[AUTO_SEQ_SURROUND] = 0x11;
+                spec->multiout.dac_nids[AUTO_SEQ_CENLFE] = 0x24;
+        }
+
         return 0;
 }
 
@@ -3932,7 +3949,8 @@ static int vt1708S_auto_create_multi_out_ctls(struct via_spec *spec,
         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
                 nid = cfg->line_out_pins[i];
 
-                if (!nid)
+                /* for Smart 5.1, there are always at least six channels */
+                if (!nid && i > AUTO_SEQ_CENLFE)
                         continue;
 
                 nid_vol = nid_vols[i];
diff --git a/sound/pci/ice1712/delta.c b/sound/pci/ice1712/delta.c
index d216362626d0..712c1710f9a2 100644
--- a/sound/pci/ice1712/delta.c
+++ b/sound/pci/ice1712/delta.c
@@ -563,6 +563,7 @@ static int __devinit snd_ice1712_delta_init(struct snd_ice1712 *ice)
         case ICE1712_SUBDEVICE_DELTA1010E:
         case ICE1712_SUBDEVICE_DELTA1010LT:
         case ICE1712_SUBDEVICE_MEDIASTATION:
+        case ICE1712_SUBDEVICE_EDIROLDA2496:
                 ice->num_total_dacs = 8;
                 ice->num_total_adcs = 8;
                 break;
@@ -635,6 +636,7 @@ static int __devinit snd_ice1712_delta_init(struct snd_ice1712 *ice)
                 err = snd_ice1712_akm4xxx_init(ak, &akm_delta410, &akm_delta410_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_DELTA1010LT:
+        case ICE1712_SUBDEVICE_EDIROLDA2496:
                 err = snd_ice1712_akm4xxx_init(ak, &akm_delta1010lt, &akm_delta1010lt_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_DELTA66:
@@ -734,6 +736,7 @@ static int __devinit snd_ice1712_delta_add_controls(struct snd_ice1712 *ice)
         case ICE1712_SUBDEVICE_DELTA66:
         case ICE1712_SUBDEVICE_VX442:
         case ICE1712_SUBDEVICE_DELTA66E:
+        case ICE1712_SUBDEVICE_EDIROLDA2496:
                 err = snd_ice1712_akm4xxx_build_controls(ice);
                 if (err < 0)
                         return err;
@@ -813,5 +816,12 @@ struct snd_ice1712_card_info snd_ice1712_delta_cards[] __devinitdata = {
                 .chip_init = snd_ice1712_delta_init,
                 .build_controls = snd_ice1712_delta_add_controls,
         },
+        {
+                .subvendor = ICE1712_SUBDEVICE_EDIROLDA2496,
+                .name = "Edirol DA2496",
+                .model = "da2496",
+                .chip_init = snd_ice1712_delta_init,
+                .build_controls = snd_ice1712_delta_add_controls,
+        },
         { } /* terminator */
 };
diff --git a/sound/pci/ice1712/delta.h b/sound/pci/ice1712/delta.h
index f7f14df81f26..1a0ac6cd6501 100644
--- a/sound/pci/ice1712/delta.h
+++ b/sound/pci/ice1712/delta.h
@@ -34,7 +34,8 @@
                 "{MidiMan M Audio,Delta 410},"\
                 "{MidiMan M Audio,Audiophile 24/96},"\
                 "{Digigram,VX442},"\
-                "{Lionstracs,Mediastation},"
+                "{Lionstracs,Mediastation},"\
+                "{Edirol,DA2496},"
 
 #define ICE1712_SUBDEVICE_DELTA1010     0x121430d6
 #define ICE1712_SUBDEVICE_DELTA1010E    0xff1430d6
@@ -47,6 +48,7 @@
 #define ICE1712_SUBDEVICE_DELTA1010LT   0x12143bd6
 #define ICE1712_SUBDEVICE_VX442         0x12143cd6
 #define ICE1712_SUBDEVICE_MEDIASTATION  0x694c0100
+#define ICE1712_SUBDEVICE_EDIROLDA2496  0xce164010
 
 /* entry point */
 extern struct snd_ice1712_card_info snd_ice1712_delta_cards[];
diff --git a/sound/pci/ice1712/pontis.c b/sound/pci/ice1712/pontis.c
index 6bc3f91b7281..cdb873f5da50 100644
--- a/sound/pci/ice1712/pontis.c
+++ b/sound/pci/ice1712/pontis.c
@@ -638,7 +638,7 @@ static struct snd_kcontrol_new pontis_controls[] __devinitdata = {
  */
 static void wm_proc_regs_write(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 {
-        struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
+        struct snd_ice1712 *ice = entry->private_data;
         char line[64];
         unsigned int reg, val;
         mutex_lock(&ice->gpio_mutex);
@@ -653,7 +653,7 @@ static void wm_proc_regs_write(struct snd_info_entry *entry, struct snd_info_buf
 
 static void wm_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 {
-        struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
+        struct snd_ice1712 *ice = entry->private_data;
         int reg, val;
 
         mutex_lock(&ice->gpio_mutex);
@@ -676,7 +676,7 @@ static void wm_proc_init(struct snd_ice1712 *ice)
 
 static void cs_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 {
-        struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
+        struct snd_ice1712 *ice = entry->private_data;
         int reg, val;
 
         mutex_lock(&ice->gpio_mutex);
diff --git a/sound/pci/ice1712/prodigy192.c b/sound/pci/ice1712/prodigy192.c
index 2a8e5cd8f2d8..e36ddb94c382 100644
--- a/sound/pci/ice1712/prodigy192.c
+++ b/sound/pci/ice1712/prodigy192.c
@@ -654,7 +654,7 @@ static int prodigy192_ak4114_init(struct snd_ice1712 *ice)
 static void stac9460_proc_regs_read(struct snd_info_entry *entry,
                 struct snd_info_buffer *buffer)
 {
-        struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
+        struct snd_ice1712 *ice = entry->private_data;
         int reg, val;
         /* registers 0x0 - 0x14 */
         for (reg = 0; reg <= 0x15; reg++) {
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index 6433e65c9507..467749249576 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -1776,6 +1776,12 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = {
         },
         {
                 .subvendor = 0x1014,
+                .subdevice = 0x0534,
+                .name = "ThinkPad X31",
+                .type = AC97_TUNE_INV_EAPD
+        },
+        {
+                .subvendor = 0x1014,
                 .subdevice = 0x1f00,
                 .name = "MS-9128",
                 .type = AC97_TUNE_ALC_JACK
diff --git a/sound/pci/oxygen/oxygen.h b/sound/pci/oxygen/oxygen.h
index 6147216af744..a3409edcfb50 100644
--- a/sound/pci/oxygen/oxygen.h
+++ b/sound/pci/oxygen/oxygen.h
@@ -155,6 +155,7 @@ void oxygen_pci_remove(struct pci_dev *pci);
 int oxygen_pci_suspend(struct pci_dev *pci, pm_message_t state);
 int oxygen_pci_resume(struct pci_dev *pci);
 #endif
+void oxygen_pci_shutdown(struct pci_dev *pci);
 
 /* oxygen_mixer.c */
 
diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c
index fad03d64e3ad..7e93cf884437 100644
--- a/sound/pci/oxygen/oxygen_lib.c
+++ b/sound/pci/oxygen/oxygen_lib.c
@@ -519,16 +519,21 @@ static void oxygen_init(struct oxygen *chip)
         }
 }
 
-static void oxygen_card_free(struct snd_card *card)
+static void oxygen_shutdown(struct oxygen *chip)
 {
-        struct oxygen *chip = card->private_data;
-
         spin_lock_irq(&chip->reg_lock);
         chip->interrupt_mask = 0;
         chip->pcm_running = 0;
         oxygen_write16(chip, OXYGEN_DMA_STATUS, 0);
         oxygen_write16(chip, OXYGEN_INTERRUPT_MASK, 0);
         spin_unlock_irq(&chip->reg_lock);
+}
+
+static void oxygen_card_free(struct snd_card *card)
+{
+        struct oxygen *chip = card->private_data;
+
+        oxygen_shutdown(chip);
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
         flush_scheduled_work();
@@ -778,3 +783,13 @@ int oxygen_pci_resume(struct pci_dev *pci)
 }
 EXPORT_SYMBOL(oxygen_pci_resume);
 #endif /* CONFIG_PM */
+
+void oxygen_pci_shutdown(struct pci_dev *pci)
+{
+        struct snd_card *card = pci_get_drvdata(pci);
+        struct oxygen *chip = card->private_data;
+
+        oxygen_shutdown(chip);
+        chip->model.cleanup(chip);
+}
+EXPORT_SYMBOL(oxygen_pci_shutdown);
diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c
index f03a2f2cffee..06c863e86e3d 100644
--- a/sound/pci/oxygen/virtuoso.c
+++ b/sound/pci/oxygen/virtuoso.c
@@ -95,6 +95,7 @@ static struct pci_driver xonar_driver = {
         .suspend = oxygen_pci_suspend,
         .resume = oxygen_pci_resume,
 #endif
+        .shutdown = oxygen_pci_shutdown,
 };
 
 static int __init alsa_card_xonar_init(void)
diff --git a/sound/pci/oxygen/xonar_wm87x6.c b/sound/pci/oxygen/xonar_wm87x6.c
index dbc4b89d74e4..aceaaa036da6 100644
--- a/sound/pci/oxygen/xonar_wm87x6.c
+++ b/sound/pci/oxygen/xonar_wm87x6.c
@@ -25,16 +25,24 @@
  * SPI 0 -> WM8766 (surround, center/LFE, back)
  * SPI 1 -> WM8776 (front, input)
  *
- * GPIO 4 <- headphone detect
- * GPIO 6 -> route input jack to input 1/2 (1/0)
- * GPIO 7 -> enable output to speakers
- * GPIO 8 -> enable output to speakers
+ * GPIO 4 <- headphone detect, 0 = plugged
+ * GPIO 6 -> route input jack to mic-in (0) or line-in (1)
+ * GPIO 7 -> enable output to front L/R speaker channels
+ * GPIO 8 -> enable output to other speaker channels and front panel headphone
+ *
+ * WM8766:
+ *
+ * input 1 <- line
+ * input 2 <- mic
+ * input 3 <- front mic
+ * input 4 <- aux
  */
 
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <sound/control.h>
 #include <sound/core.h>
+#include <sound/jack.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 #include <sound/tlv.h>
@@ -44,7 +52,8 @@
 
 #define GPIO_DS_HP_DETECT       0x0010
 #define GPIO_DS_INPUT_ROUTE     0x0040
-#define GPIO_DS_OUTPUT_ENABLE   0x0180
+#define GPIO_DS_OUTPUT_FRONTLR  0x0080
+#define GPIO_DS_OUTPUT_ENABLE   0x0100
 
 #define LC_CONTROL_LIMITER      0x40000000
 #define LC_CONTROL_ALC          0x20000000
@@ -53,7 +62,10 @@ struct xonar_wm87x6 {
         struct xonar_generic generic;
         u16 wm8776_regs[0x17];
         u16 wm8766_regs[0x10];
+        struct snd_kcontrol *line_adcmux_control;
+        struct snd_kcontrol *mic_adcmux_control;
         struct snd_kcontrol *lc_controls[13];
+        struct snd_jack *hp_jack;
 };
 
 static void wm8776_write(struct oxygen *chip,
@@ -95,8 +107,12 @@ static void wm8766_write(struct oxygen *chip,
                          (0 << OXYGEN_SPI_CODEC_SHIFT) |
                          OXYGEN_SPI_CEN_LATCH_CLOCK_LO,
                          (reg << 9) | value);
-        if (reg < ARRAY_SIZE(data->wm8766_regs))
+        if (reg < ARRAY_SIZE(data->wm8766_regs)) {
+                if ((reg >= WM8766_LDA1 && reg <= WM8766_RDA1) ||
+                    (reg >= WM8766_LDA2 && reg <= WM8766_MASTDA))
+                        value &= ~WM8766_UPDATE;
                 data->wm8766_regs[reg] = value;
+        }
 }
 
 static void wm8766_write_cached(struct oxygen *chip,
@@ -105,12 +121,8 @@ static void wm8766_write_cached(struct oxygen *chip,
         struct xonar_wm87x6 *data = chip->model_data;
 
         if (reg >= ARRAY_SIZE(data->wm8766_regs) ||
-            value != data->wm8766_regs[reg]) {
-                if ((reg >= WM8766_LDA1 && reg <= WM8766_RDA1) ||
-                    (reg >= WM8766_LDA2 && reg <= WM8766_MASTDA))
-                        value &= ~WM8766_UPDATE;
+            value != data->wm8766_regs[reg])
                 wm8766_write(chip, reg, value);
-        }
 }
 
 static void wm8776_registers_init(struct oxygen *chip)
@@ -139,7 +151,10 @@ static void wm8776_registers_init(struct oxygen *chip)
 
 static void wm8766_registers_init(struct oxygen *chip)
 {
+        struct xonar_wm87x6 *data = chip->model_data;
+
         wm8766_write(chip, WM8766_RESET, 0);
+        wm8766_write(chip, WM8766_DAC_CTRL, data->wm8766_regs[WM8766_DAC_CTRL]);
         wm8766_write(chip, WM8766_INT_CTRL, WM8766_FMT_LJUST | WM8766_IWL_24);
         wm8766_write(chip, WM8766_DAC_CTRL2,
                      WM8766_ZCD | (chip->dac_mute ? WM8766_DMUTE_MASK : 0));
@@ -168,6 +183,40 @@ static void wm8776_init(struct oxygen *chip)
         wm8776_registers_init(chip);
 }
 
+static void wm8766_init(struct oxygen *chip)
+{
+        struct xonar_wm87x6 *data = chip->model_data;
+
+        data->wm8766_regs[WM8766_DAC_CTRL] =
+                WM8766_PL_LEFT_LEFT | WM8766_PL_RIGHT_RIGHT;
+        wm8766_registers_init(chip);
+}
+
+static void xonar_ds_handle_hp_jack(struct oxygen *chip)
+{
+        struct xonar_wm87x6 *data = chip->model_data;
+        bool hp_plugged;
+        unsigned int reg;
+
+        mutex_lock(&chip->mutex);
+
+        hp_plugged = !(oxygen_read16(chip, OXYGEN_GPIO_DATA) &
+                       GPIO_DS_HP_DETECT);
+
+        oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
+                              hp_plugged ? 0 : GPIO_DS_OUTPUT_FRONTLR,
+                              GPIO_DS_OUTPUT_FRONTLR);
+
+        reg = data->wm8766_regs[WM8766_DAC_CTRL] & ~WM8766_MUTEALL;
+        if (hp_plugged)
+                reg |= WM8766_MUTEALL;
+        wm8766_write_cached(chip, WM8766_DAC_CTRL, reg);
+
+        snd_jack_report(data->hp_jack, hp_plugged ? SND_JACK_HEADPHONE : 0);
+
+        mutex_unlock(&chip->mutex);
+}
+
 static void xonar_ds_init(struct oxygen *chip)
 {
         struct xonar_wm87x6 *data = chip->model_data;
@@ -176,16 +225,22 @@ static void xonar_ds_init(struct oxygen *chip)
         data->generic.output_enable_bit = GPIO_DS_OUTPUT_ENABLE;
 
         wm8776_init(chip);
-        wm8766_registers_init(chip);
+        wm8766_init(chip);
 
-        oxygen_write16_masked(chip, OXYGEN_GPIO_CONTROL, GPIO_DS_INPUT_ROUTE,
-                              GPIO_DS_HP_DETECT | GPIO_DS_INPUT_ROUTE);
+        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
+                          GPIO_DS_INPUT_ROUTE | GPIO_DS_OUTPUT_FRONTLR);
+        oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL,
+                            GPIO_DS_HP_DETECT);
         oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, GPIO_DS_INPUT_ROUTE);
         oxygen_set_bits16(chip, OXYGEN_GPIO_INTERRUPT_MASK, GPIO_DS_HP_DETECT);
         chip->interrupt_mask |= OXYGEN_INT_GPIO;
 
         xonar_enable_output(chip);
 
+        snd_jack_new(chip->card, "Headphone",
+                     SND_JACK_HEADPHONE, &data->hp_jack);
+        xonar_ds_handle_hp_jack(chip);
+
         snd_component_add(chip->card, "WM8776");
         snd_component_add(chip->card, "WM8766");
 }
@@ -193,6 +248,7 @@ static void xonar_ds_init(struct oxygen *chip)
 static void xonar_ds_cleanup(struct oxygen *chip)
 {
         xonar_disable_output(chip);
+        wm8776_write(chip, WM8776_RESET, 0);
 }
 
 static void xonar_ds_suspend(struct oxygen *chip)
@@ -205,6 +261,7 @@ static void xonar_ds_resume(struct oxygen *chip)
         wm8776_registers_init(chip);
         wm8766_registers_init(chip);
         xonar_enable_output(chip);
+        xonar_ds_handle_hp_jack(chip);
 }
 
 static void wm8776_adc_hardware_filter(unsigned int channel,
@@ -320,12 +377,27 @@ static void update_wm87x6_mute(struct oxygen *chip)
                             (chip->dac_mute ? WM8766_DMUTE_MASK : 0));
 }
 
-static void xonar_ds_gpio_changed(struct oxygen *chip)
+static void update_wm8766_center_lfe_mix(struct oxygen *chip, bool mixed)
 {
-        u16 bits;
+        struct xonar_wm87x6 *data = chip->model_data;
+        unsigned int reg;
 
-        bits = oxygen_read16(chip, OXYGEN_GPIO_DATA);
-        snd_printk(KERN_INFO "HP detect: %d\n", !!(bits & GPIO_DS_HP_DETECT));
+        /*
+         * The WM8766 can mix left and right channels, but this setting
+         * applies to all three stereo pairs.
+         */
+        reg = data->wm8766_regs[WM8766_DAC_CTRL] &
+                ~(WM8766_PL_LEFT_MASK | WM8766_PL_RIGHT_MASK);
+        if (mixed)
+                reg |= WM8766_PL_LEFT_LRMIX | WM8766_PL_RIGHT_LRMIX;
+        else
+                reg |= WM8766_PL_LEFT_LEFT | WM8766_PL_RIGHT_RIGHT;
+        wm8766_write_cached(chip, WM8766_DAC_CTRL, reg);
+}
+
+static void xonar_ds_gpio_changed(struct oxygen *chip)
+{
+        xonar_ds_handle_hp_jack(chip);
 }
 
 static int wm8776_bit_switch_get(struct snd_kcontrol *ctl,
@@ -603,6 +675,7 @@ static int wm8776_input_mux_put(struct snd_kcontrol *ctl,
 {
         struct oxygen *chip = ctl->private_data;
         struct xonar_wm87x6 *data = chip->model_data;
+        struct snd_kcontrol *other_ctl;
         unsigned int mux_bit = ctl->private_value;
         u16 reg;
         int changed;
@@ -610,8 +683,18 @@ static int wm8776_input_mux_put(struct snd_kcontrol *ctl,
         mutex_lock(&chip->mutex);
         reg = data->wm8776_regs[WM8776_ADCMUX];
         if (value->value.integer.value[0]) {
-                reg &= ~0x003;
                 reg |= mux_bit;
+                /* line-in and mic-in are exclusive */
+                mux_bit ^= 3;
+                if (reg & mux_bit) {
+                        reg &= ~mux_bit;
+                        if (mux_bit == 1)
+                                other_ctl = data->line_adcmux_control;
+                        else
+                                other_ctl = data->mic_adcmux_control;
+                        snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                                       &other_ctl->id);
+                }
         } else
                 reg &= ~mux_bit;
         changed = reg != data->wm8776_regs[WM8776_ADCMUX];
@@ -882,7 +965,10 @@ static const struct snd_kcontrol_new ds_controls[] = {
                 .put = wm8776_input_mux_put,
                 .private_value = 1 << 1,
         },
-        WM8776_BIT_SWITCH("Aux", WM8776_ADCMUX, 1 << 2, 0, 0),
+        WM8776_BIT_SWITCH("Front Mic Capture Switch",
+                          WM8776_ADCMUX, 1 << 2, 0, 0),
+        WM8776_BIT_SWITCH("Aux Capture Switch",
+                          WM8776_ADCMUX, 1 << 3, 0, 0),
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = "ADC Filter Capture Enum",
@@ -963,7 +1049,13 @@ static int xonar_ds_mixer_init(struct oxygen *chip)
                 err = snd_ctl_add(chip->card, ctl);
                 if (err < 0)
                         return err;
+                if (!strcmp(ctl->id.name, "Line Capture Switch"))
+                        data->line_adcmux_control = ctl;
+                else if (!strcmp(ctl->id.name, "Mic Capture Switch"))
+                        data->mic_adcmux_control = ctl;
         }
+        if (!data->line_adcmux_control || !data->mic_adcmux_control)
+                return -ENXIO;
         BUILD_BUG_ON(ARRAY_SIZE(lc_controls) != ARRAY_SIZE(data->lc_controls));
         for (i = 0; i < ARRAY_SIZE(lc_controls); ++i) {
                 ctl = snd_ctl_new1(&lc_controls[i], chip);
@@ -993,6 +1085,7 @@ static const struct oxygen_model model_xonar_ds = {
         .set_adc_params = set_wm8776_adc_params,
         .update_dac_volume = update_wm87x6_volume,
         .update_dac_mute = update_wm87x6_mute,
+        .update_center_lfe_mix = update_wm8766_center_lfe_mix,
         .gpio_changed = xonar_ds_gpio_changed,
         .dac_tlv = wm87x6_dac_db_scale,
         .model_data_size = sizeof(struct xonar_wm87x6),
diff --git a/sound/pci/riptide/riptide.c b/sound/pci/riptide/riptide.c
index ad4462677615..ad5202efd7a9 100644
--- a/sound/pci/riptide/riptide.c
+++ b/sound/pci/riptide/riptide.c
@@ -97,6 +97,7 @@
 #include <linux/gameport.h>
 #include <linux/device.h>
 #include <linux/firmware.h>
+#include <linux/kernel.h>
 #include <asm/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
@@ -667,13 +668,12 @@ static u32 atoh(const unsigned char *in, unsigned int len)
         unsigned char c;
 
         while (len) {
+                int value;
+
                 c = in[len - 1];
-                if ((c >= '0') && (c <= '9'))
-                        sum += mult * (c - '0');
-                else if ((c >= 'A') && (c <= 'F'))
-                        sum += mult * (c - ('A' - 10));
-                else if ((c >= 'a') && (c <= 'f'))
-                        sum += mult * (c - ('a' - 10));
+                value = hex_to_bin(c);
+                if (value >= 0)
+                        sum += mult * value;
                 mult *= 16;
                 --len;
         }
@@ -1224,15 +1224,14 @@ static int try_to_load_firmware(struct cmdif *cif, struct snd_riptide *chip)
                     firmware.firmware.ASIC, firmware.firmware.CODEC,
                     firmware.firmware.AUXDSP, firmware.firmware.PROG);
 
+        if (!chip)
+                return 1;
+
         for (i = 0; i < FIRMWARE_VERSIONS; i++) {
                 if (!memcmp(&firmware_versions[i], &firmware, sizeof(firmware)))
-                        break;
-        }
-        if (i >= FIRMWARE_VERSIONS)
-                return 0; /* no match */
+                        return 1; /* OK */
 
-        if (!chip)
-                return 1; /* OK */
+        }
 
         snd_printdd("Writing Firmware\n");
         if (!chip->fw_entry) {
@@ -1615,7 +1614,10 @@ static int snd_riptide_playback_open(struct snd_pcm_substream *substream)
 
         chip->playback_substream[sub_num] = substream;
         runtime->hw = snd_riptide_playback;
+
         data = kzalloc(sizeof(struct pcmhw), GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
         data->paths = lbus_play_paths[sub_num];
         data->id = play_ids[sub_num];
         data->source = play_sources[sub_num];
@@ -1635,7 +1637,10 @@ static int snd_riptide_capture_open(struct snd_pcm_substream *substream)
 
         chip->capture_substream = substream;
         runtime->hw = snd_riptide_capture;
+
         data = kzalloc(sizeof(struct pcmhw), GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
         data->paths = lbus_rec_path;
         data->id = PADC;
         data->source = ACLNK2PADC;
diff --git a/sound/pci/rme96.c b/sound/pci/rme96.c
index d19dc052c391..d5f5b440fc40 100644
--- a/sound/pci/rme96.c
+++ b/sound/pci/rme96.c
@@ -1527,14 +1527,14 @@ snd_rme96_free(void *private_data)
 static void
 snd_rme96_free_spdif_pcm(struct snd_pcm *pcm)
 {
-        struct rme96 *rme96 = (struct rme96 *) pcm->private_data;
+        struct rme96 *rme96 = pcm->private_data;
         rme96->spdif_pcm = NULL;
 }
 
 static void
 snd_rme96_free_adat_pcm(struct snd_pcm *pcm)
 {
-        struct rme96 *rme96 = (struct rme96 *) pcm->private_data;
+        struct rme96 *rme96 = pcm->private_data;
         rme96->adat_pcm = NULL;
 }
 
@@ -1661,7 +1661,7 @@ static void
 snd_rme96_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 {
         int n;
-        struct rme96 *rme96 = (struct rme96 *)entry->private_data;
+        struct rme96 *rme96 = entry->private_data;
         
         rme96->rcreg = readl(rme96->iobase + RME96_IO_CONTROL_REGISTER);
 
@@ -2348,7 +2348,7 @@ snd_rme96_probe(struct pci_dev *pci,
         if (err < 0)
                 return err;
         card->private_free = snd_rme96_card_free;
-        rme96 = (struct rme96 *)card->private_data;     
+        rme96 = card->private_data;
         rme96->card = card;
         rme96->pci = pci;
         snd_card_set_dev(card, &pci->dev);
diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c
index b92adef8e81e..599e09051663 100644
--- a/sound/pci/rme9652/hdsp.c
+++ b/sound/pci/rme9652/hdsp.c
@@ -3284,7 +3284,7 @@ static int snd_hdsp_create_controls(struct snd_card *card, struct hdsp *hdsp)
 static void
 snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 {
-        struct hdsp *hdsp = (struct hdsp *) entry->private_data;
+        struct hdsp *hdsp = entry->private_data;
         unsigned int status;
         unsigned int status2;
         char *pref_sync_ref;
@@ -4566,7 +4566,7 @@ static int hdsp_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *peak_rm
 
 static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct hdsp *hdsp = (struct hdsp *)hw->private_data;
+        struct hdsp *hdsp = hw->private_data;
         void __user *argp = (void __user *)arg;
         int err;
 
@@ -5155,7 +5155,7 @@ static int snd_hdsp_free(struct hdsp *hdsp)
 
 static void snd_hdsp_card_free(struct snd_card *card)
 {
-        struct hdsp *hdsp = (struct hdsp *) card->private_data;
+        struct hdsp *hdsp = card->private_data;
 
         if (hdsp)
                 snd_hdsp_free(hdsp);
@@ -5181,7 +5181,7 @@ static int __devinit snd_hdsp_probe(struct pci_dev *pci,
         if (err < 0)
                 return err;
 
-        hdsp = (struct hdsp *) card->private_data;
+        hdsp = card->private_data;
         card->private_free = snd_hdsp_card_free;
         hdsp->dev = dev;
         hdsp->pci = pci;
diff --git a/sound/pci/sis7019.c b/sound/pci/sis7019.c
index 9cc1b5aa0148..1b8f6742b5fa 100644
--- a/sound/pci/sis7019.c
+++ b/sound/pci/sis7019.c
@@ -264,11 +264,13 @@ static void sis_update_voice(struct voice *voice)
                  * if using small periods.
                  *
                  * If we're less than 9 samples behind, we're on target.
+                 * Otherwise, shorten the next vperiod by the amount we've
+                 * been delayed.
                  */
                 if (sync > -9)
                         voice->vperiod = voice->sync_period_size + 1;
                 else
-                        voice->vperiod = voice->sync_period_size - 4;
+                        voice->vperiod = voice->sync_period_size + sync + 10;
 
                 if (voice->vperiod < voice->buffer_size) {
                         sis_update_sso(voice, voice->vperiod);
@@ -736,7 +738,7 @@ static void sis_prepare_timing_voice(struct voice *voice,
         period_size = buffer_size;
 
         /* Initially, we want to interrupt just a bit behind the end of
-         * the period we're clocking out. 10 samples seems to give a good
+         * the period we're clocking out. 12 samples seems to give a good
          * delay.
          *
          * We want to spread our interrupts throughout the virtual period,
@@ -747,7 +749,7 @@ static void sis_prepare_timing_voice(struct voice *voice,
          *
          * This is all moot if we don't need to use virtual periods.
          */
-        vperiod = runtime->period_size + 10;
+        vperiod = runtime->period_size + 12;
         if (vperiod > period_size) {
                 u16 tail = vperiod % period_size;
                 u16 quarter_period = period_size / 4;
@@ -776,7 +778,7 @@ static void sis_prepare_timing_voice(struct voice *voice,
          */
         timing->flags |= VOICE_SYNC_TIMING;
         timing->sync_base = voice->ctrl_base;
-        timing->sync_cso = runtime->period_size - 1;
+        timing->sync_cso = runtime->period_size;
         timing->sync_period_size = runtime->period_size;
         timing->sync_buffer_size = runtime->buffer_size;
         timing->period_size = period_size;
@@ -1047,7 +1049,7 @@ static int sis_chip_free(struct sis7019 *sis)
         /* Reset the chip, and disable all interrputs.
          */
         outl(SIS_GCR_SOFTWARE_RESET, sis->ioport + SIS_GCR);
-        udelay(10);
+        udelay(25);
         outl(0, sis->ioport + SIS_GCR);
         outl(0, sis->ioport + SIS_GIER);
 
@@ -1083,7 +1085,7 @@ static int sis_chip_init(struct sis7019 *sis)
         /* Reset the audio controller
          */
         outl(SIS_GCR_SOFTWARE_RESET, io + SIS_GCR);
-        udelay(10);
+        udelay(25);
         outl(0, io + SIS_GCR);
 
         /* Get the AC-link semaphore, and reset the codecs
@@ -1096,7 +1098,7 @@ static int sis_chip_init(struct sis7019 *sis)
                 return -EIO;
 
         outl(SIS_AC97_CMD_CODEC_COLD_RESET, io + SIS_AC97_CMD);
-        udelay(10);
+        udelay(250);
 
         count = 0xffff;
         while ((inw(io + SIS_AC97_STATUS) & SIS_AC97_STATUS_BUSY) && --count)
diff --git a/sound/pci/trident/trident_main.c b/sound/pci/trident/trident_main.c
index 6d943f6f6b70..2870a4fdc130 100644
--- a/sound/pci/trident/trident_main.c
+++ b/sound/pci/trident/trident_main.c
@@ -1055,7 +1055,7 @@ static int snd_trident_capture_prepare(struct snd_pcm_substream *substream)
 
         spin_lock_irq(&trident->reg_lock);
 
-        // Initilize the channel and set channel Mode
+        // Initialize the channel and set channel Mode
         outb(0, TRID_REG(trident, LEGACY_DMAR15));
 
         // Set DMA channel operation mode register
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index 7e494b6a1d0e..8c5f8b5a59f0 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -85,6 +85,7 @@ static int joystick;
 static int ac97_clock = 48000;
 static char *ac97_quirk;
 static int dxs_support;
+static int dxs_init_volume = 31;
 static int nodelay;
 
 module_param(index, int, 0444);
@@ -103,6 +104,8 @@ module_param(ac97_quirk, charp, 0444);
 MODULE_PARM_DESC(ac97_quirk, "AC'97 workaround for strange hardware.");
 module_param(dxs_support, int, 0444);
 MODULE_PARM_DESC(dxs_support, "Support for DXS channels (0 = auto, 1 = enable, 2 = disable, 3 = 48k only, 4 = no VRA, 5 = enable any sample rate)");
+module_param(dxs_init_volume, int, 0644);
+MODULE_PARM_DESC(dxs_init_volume, "initial DXS volume (0-31)");
 module_param(nodelay, int, 0444);
 MODULE_PARM_DESC(nodelay, "Disable 500ms init delay");
 
@@ -1245,8 +1248,10 @@ static int snd_via8233_playback_open(struct snd_pcm_substream *substream)
                 return err;
         stream = viadev->reg_offset / 0x10;
         if (chip->dxs_controls[stream]) {
-                chip->playback_volume[stream][0] = 0;
-                chip->playback_volume[stream][1] = 0;
+                chip->playback_volume[stream][0] =
+                                VIA_DXS_MAX_VOLUME - (dxs_init_volume & 31);
+                chip->playback_volume[stream][1] =
+                                VIA_DXS_MAX_VOLUME - (dxs_init_volume & 31);
                 chip->dxs_controls[stream]->vd[0].access &=
                         ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE |
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf.c b/sound/pcmcia/pdaudiocf/pdaudiocf.c
index df110df52a8b..7ab9174a8a84 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf.c
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf.c
@@ -139,8 +139,8 @@ static int snd_pdacf_probe(struct pcmcia_device *link)
         pdacf->p_dev = link;
         link->priv = pdacf;
 
-        link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-        link->io.NumPorts1 = 16;
+        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
+        link->resource[0]->end = 16;
 
         link->conf.Attributes = CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ;
         link->conf.IntType = INT_MEMORY_AND_IO;
@@ -219,7 +219,7 @@ static int pdacf_config(struct pcmcia_device *link)
         snd_printdd(KERN_DEBUG "pdacf_config called\n");
         link->conf.ConfigIndex = 0x5;
 
-        ret = pcmcia_request_io(link, &link->io);
+        ret = pcmcia_request_io(link);
         if (ret)
                 goto failed;
 
@@ -231,7 +231,8 @@ static int pdacf_config(struct pcmcia_device *link)
         if (ret)
                 goto failed;
 
-        if (snd_pdacf_assign_resources(pdacf, link->io.BasePort1, link->irq) < 0)
+        if (snd_pdacf_assign_resources(pdacf, link->resource[0]->start,
+                                        link->irq) < 0)
                 goto failed;
 
         return 0;
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf.h b/sound/pcmcia/pdaudiocf/pdaudiocf.h
index a0a7ec64222a..5cc3e4573074 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf.h
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf.h
@@ -24,7 +24,6 @@
 #include <sound/pcm.h>
 #include <asm/io.h>
 #include <linux/interrupt.h>
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
diff --git a/sound/pcmcia/vx/vxpocket.c b/sound/pcmcia/vx/vxpocket.c
index 624b47a85f0a..a6edfc3be29a 100644
--- a/sound/pcmcia/vx/vxpocket.c
+++ b/sound/pcmcia/vx/vxpocket.c
@@ -159,8 +159,8 @@ static int snd_vxpocket_new(struct snd_card *card, int ibl,
         vxp->p_dev = link;
         link->priv = chip;
 
-        link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
-        link->io.NumPorts1 = 16;
+        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
+        link->resource[0]->end = 16;
 
         link->conf.Attributes = CONF_ENABLE_IRQ;
         link->conf.IntType = INT_MEMORY_AND_IO;
@@ -226,7 +226,7 @@ static int vxpocket_config(struct pcmcia_device *link)
                 strcpy(chip->card->driver, vxp440_hw.name);
         }
 
-        ret = pcmcia_request_io(link, &link->io);
+        ret = pcmcia_request_io(link);
         if (ret)
                 goto failed;
 
@@ -241,7 +241,8 @@ static int vxpocket_config(struct pcmcia_device *link)
         chip->dev = &link->dev;
         snd_card_set_dev(chip->card, chip->dev);
 
-        if (snd_vxpocket_assign_resources(chip, link->io.BasePort1, link->irq) < 0)
+        if (snd_vxpocket_assign_resources(chip, link->resource[0]->start,
+                                                link->irq) < 0)
                 goto failed;
 
         return 0;
diff --git a/sound/pcmcia/vx/vxpocket.h b/sound/pcmcia/vx/vxpocket.h
index ea4df16a28ef..d9110669d042 100644
--- a/sound/pcmcia/vx/vxpocket.h
+++ b/sound/pcmcia/vx/vxpocket.h
@@ -23,7 +23,6 @@
 
 #include <sound/vx_core.h>
 
-#include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
diff --git a/sound/ppc/snd_ps3.c b/sound/ppc/snd_ps3.c
index 2f12da4da561..581a670e8261 100644
--- a/sound/ppc/snd_ps3.c
+++ b/sound/ppc/snd_ps3.c
@@ -579,7 +579,7 @@ static int snd_ps3_delay_to_bytes(struct snd_pcm_substream *substream,
                                   rate * delay_ms / 1000)
                 * substream->runtime->channels;
 
-        pr_debug(KERN_ERR "%s: time=%d rate=%d bytes=%ld, frames=%d, ret=%d\n",
+        pr_debug("%s: time=%d rate=%d bytes=%ld, frames=%d, ret=%d\n",
                  __func__,
                  delay_ms,
                  rate,
diff --git a/sound/ppc/tumbler.c b/sound/ppc/tumbler.c
index 20afdf9772ee..961d98297695 100644
--- a/sound/ppc/tumbler.c
+++ b/sound/ppc/tumbler.c
@@ -785,7 +785,7 @@ static int snapper_set_capture_source(struct pmac_tumbler *mix)
         if (! mix->i2c.client)
                 return -ENODEV;
         if (mix->capture_source)
-                mix->acs = mix->acs |= 2;
+                mix->acs |= 2;
         else
                 mix->acs &= ~2;
         return i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs);
diff --git a/sound/soc/Kconfig b/sound/soc/Kconfig
index b1749bc67979..3e598e756e54 100644
--- a/sound/soc/Kconfig
+++ b/sound/soc/Kconfig
@@ -28,9 +28,13 @@ source "sound/soc/atmel/Kconfig"
 source "sound/soc/au1x/Kconfig"
 source "sound/soc/blackfin/Kconfig"
 source "sound/soc/davinci/Kconfig"
+source "sound/soc/ep93xx/Kconfig"
 source "sound/soc/fsl/Kconfig"
 source "sound/soc/imx/Kconfig"
+source "sound/soc/jz4740/Kconfig"
+source "sound/soc/nuc900/Kconfig"
 source "sound/soc/omap/Kconfig"
+source "sound/soc/kirkwood/Kconfig"
 source "sound/soc/pxa/Kconfig"
 source "sound/soc/s3c24xx/Kconfig"
 source "sound/soc/s6000/Kconfig"
diff --git a/sound/soc/Makefile b/sound/soc/Makefile
index 1470141d4167..eb183443eee4 100644
--- a/sound/soc/Makefile
+++ b/sound/soc/Makefile
@@ -6,9 +6,13 @@ obj-$(CONFIG_SND_SOC)	+= atmel/
 obj-$(CONFIG_SND_SOC)   += au1x/
 obj-$(CONFIG_SND_SOC)   += blackfin/
 obj-$(CONFIG_SND_SOC)   += davinci/
+obj-$(CONFIG_SND_SOC)   += ep93xx/
 obj-$(CONFIG_SND_SOC)   += fsl/
 obj-$(CONFIG_SND_SOC)   += imx/
+obj-$(CONFIG_SND_SOC)   += jz4740/
+obj-$(CONFIG_SND_SOC)   += nuc900/
 obj-$(CONFIG_SND_SOC)   += omap/
+obj-$(CONFIG_SND_SOC)   += kirkwood/
 obj-$(CONFIG_SND_SOC)   += pxa/
 obj-$(CONFIG_SND_SOC)   += s3c24xx/
 obj-$(CONFIG_SND_SOC)   += s6000/
diff --git a/sound/soc/atmel/atmel-pcm.c b/sound/soc/atmel/atmel-pcm.c
index f6b3cc04b34b..dc5249fba85c 100644
--- a/sound/soc/atmel/atmel-pcm.c
+++ b/sound/soc/atmel/atmel-pcm.c
@@ -77,7 +77,6 @@ struct atmel_runtime_data {
         size_t period_size;
 
         dma_addr_t period_ptr;          /* physical address of next period */
-        int periods;                    /* period index of period_ptr */
 
         /* PDC register save */
         u32 pdc_xpr_save;
diff --git a/sound/soc/atmel/atmel_ssc_dai.c b/sound/soc/atmel/atmel_ssc_dai.c
index 0b59806905d1..c85844d4845b 100644
--- a/sound/soc/atmel/atmel_ssc_dai.c
+++ b/sound/soc/atmel/atmel_ssc_dai.c
@@ -549,7 +549,6 @@ static int atmel_ssc_hw_params(struct snd_pcm_substream *substream,
                 printk(KERN_WARNING "atmel_ssc_dai: unsupported DAI format 0x%x\n",
                         ssc_p->daifmt);
                 return -EINVAL;
-                break;
         }
         pr_debug("atmel_ssc_hw_params: "
                         "RCMR=%08x RFMR=%08x TCMR=%08x TFMR=%08x\n",
diff --git a/sound/soc/au1x/psc-ac97.c b/sound/soc/au1x/psc-ac97.c
index a61ccd2d505f..d14a5a91a465 100644
--- a/sound/soc/au1x/psc-ac97.c
+++ b/sound/soc/au1x/psc-ac97.c
@@ -375,12 +375,10 @@ static int __devinit au1xpsc_ac97_drvprobe(struct platform_device *pdev)
         }
 
         ret = -EBUSY;
-        wd->ioarea = request_mem_region(r->start, r->end - r->start + 1,
-                                        "au1xpsc_ac97");
-        if (!wd->ioarea)
+        if (!request_mem_region(r->start, resource_size(r), pdev->name))
                 goto out0;
 
-        wd->mmio = ioremap(r->start, 0xffff);
+        wd->mmio = ioremap(r->start, resource_size(r));
         if (!wd->mmio)
                 goto out1;
 
@@ -410,8 +408,7 @@ static int __devinit au1xpsc_ac97_drvprobe(struct platform_device *pdev)
 
         snd_soc_unregister_dai(&au1xpsc_ac97_dai);
 out1:
-        release_resource(wd->ioarea);
-        kfree(wd->ioarea);
+        release_mem_region(r->start, resource_size(r));
 out0:
         kfree(wd);
         return ret;
@@ -420,6 +417,7 @@ out0:
 static int __devexit au1xpsc_ac97_drvremove(struct platform_device *pdev)
 {
         struct au1xpsc_audio_data *wd = platform_get_drvdata(pdev);
+        struct resource *r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
         if (wd->dmapd)
                 au1xpsc_pcm_destroy(wd->dmapd);
@@ -433,8 +431,7 @@ static int __devexit au1xpsc_ac97_drvremove(struct platform_device *pdev)
         au_sync();
 
         iounmap(wd->mmio);
-        release_resource(wd->ioarea);
-        kfree(wd->ioarea);
+        release_mem_region(r->start, resource_size(r));
         kfree(wd);
 
         au1xpsc_ac97_workdata = NULL;   /* MDEV */
diff --git a/sound/soc/au1x/psc-i2s.c b/sound/soc/au1x/psc-i2s.c
index 24454c98d0ee..6083fe7799fa 100644
--- a/sound/soc/au1x/psc-i2s.c
+++ b/sound/soc/au1x/psc-i2s.c
@@ -321,12 +321,10 @@ static int __devinit au1xpsc_i2s_drvprobe(struct platform_device *pdev)
         }
 
         ret = -EBUSY;
-        wd->ioarea = request_mem_region(r->start, r->end - r->start + 1,
-                                        "au1xpsc_i2s");
-        if (!wd->ioarea)
+        if (!request_mem_region(r->start, resource_size(r), pdev->name))
                 goto out0;
 
-        wd->mmio = ioremap(r->start, 0xffff);
+        wd->mmio = ioremap(r->start, resource_size(r));
         if (!wd->mmio)
                 goto out1;
 
@@ -362,8 +360,7 @@ static int __devinit au1xpsc_i2s_drvprobe(struct platform_device *pdev)
 
         snd_soc_unregister_dai(&au1xpsc_i2s_dai);
 out1:
-        release_resource(wd->ioarea);
-        kfree(wd->ioarea);
+        release_mem_region(r->start, resource_size(r));
 out0:
         kfree(wd);
         return ret;
@@ -372,6 +369,7 @@ out0:
 static int __devexit au1xpsc_i2s_drvremove(struct platform_device *pdev)
 {
         struct au1xpsc_audio_data *wd = platform_get_drvdata(pdev);
+        struct resource *r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
         if (wd->dmapd)
                 au1xpsc_pcm_destroy(wd->dmapd);
@@ -384,8 +382,7 @@ static int __devexit au1xpsc_i2s_drvremove(struct platform_device *pdev)
         au_sync();
 
         iounmap(wd->mmio);
-        release_resource(wd->ioarea);
-        kfree(wd->ioarea);
+        release_mem_region(r->start, resource_size(r));
         kfree(wd);
 
         au1xpsc_i2s_workdata = NULL;    /* MDEV */
diff --git a/sound/soc/au1x/psc.h b/sound/soc/au1x/psc.h
index 32d3807d3f5a..093775d4dc3e 100644
--- a/sound/soc/au1x/psc.h
+++ b/sound/soc/au1x/psc.h
@@ -32,7 +32,6 @@ struct au1xpsc_audio_data {
         unsigned long rate;
 
         unsigned long pm[2];
-        struct resource *ioarea;
         struct mutex lock;
         struct platform_device *dmapd;
 };
diff --git a/sound/soc/blackfin/Kconfig b/sound/soc/blackfin/Kconfig
index 8ef25025f3dc..3abeeddc67d3 100644
--- a/sound/soc/blackfin/Kconfig
+++ b/sound/soc/blackfin/Kconfig
@@ -105,13 +105,18 @@ config SND_BF5XX_RESET_GPIO_NUM
           Set the correct GPIO for RESET the sound chip.
 
 config SND_BF5XX_SOC_AD1980
-        tristate "SoC AD1980/1 Audio support for BF5xx"
+        tristate "SoC AD1980/1 Audio support for BF5xx (Obsolete)"
         depends on SND_BF5XX_AC97
         select SND_BF5XX_SOC_AC97
         select SND_SOC_AD1980
         help
           Say Y if you want to add support for SoC audio on BF5xx STAMP/EZKIT.
 
+          Warning:
+          Because Analog Devices Inc. discontinued the ad1980 sound chip since
+          Sep. 2009, this ad1980 driver is not maintained, tested and supported
+          by ADI now.
+
 config SND_BF5XX_SOC_SPORT
         tristate
 
diff --git a/sound/soc/blackfin/bf5xx-ac97.c b/sound/soc/blackfin/bf5xx-ac97.c
index 523b7fc33f4e..c0eba5109980 100644
--- a/sound/soc/blackfin/bf5xx-ac97.c
+++ b/sound/soc/blackfin/bf5xx-ac97.c
@@ -255,8 +255,7 @@ EXPORT_SYMBOL_GPL(soc_ac97_ops);
 #ifdef CONFIG_PM
 static int bf5xx_ac97_suspend(struct snd_soc_dai *dai)
 {
-        struct sport_device *sport =
-                (struct sport_device *)dai->private_data;
+        struct sport_device *sport = dai->private_data;
 
         pr_debug("%s : sport %d\n", __func__, dai->id);
         if (!dai->active)
@@ -271,8 +270,7 @@ static int bf5xx_ac97_suspend(struct snd_soc_dai *dai)
 static int bf5xx_ac97_resume(struct snd_soc_dai *dai)
 {
         int ret;
-        struct sport_device *sport =
-                (struct sport_device *)dai->private_data;
+        struct sport_device *sport = dai->private_data;
 
         pr_debug("%s : sport %d\n", __func__, dai->id);
         if (!dai->active)
diff --git a/sound/soc/blackfin/bf5xx-ad1980.c b/sound/soc/blackfin/bf5xx-ad1980.c
index d8f591273778..92f7c327bb7a 100644
--- a/sound/soc/blackfin/bf5xx-ad1980.c
+++ b/sound/soc/blackfin/bf5xx-ad1980.c
@@ -26,6 +26,14 @@
  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
+/*
+ * WARNING:
+ *
+ * Because Analog Devices Inc. discontinued the ad1980 sound chip since
+ * Sep. 2009, this ad1980 driver is not maintained, tested and supported
+ * by ADI now.
+ */
+
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/device.h>
@@ -109,5 +117,5 @@ module_exit(bf5xx_board_exit);
 
 /* Module information */
 MODULE_AUTHOR("Cliff Cai");
-MODULE_DESCRIPTION("ALSA SoC AD1980/1 BF5xx board");
+MODULE_DESCRIPTION("ALSA SoC AD1980/1 BF5xx board (Obsolete)");
 MODULE_LICENSE("GPL");
diff --git a/sound/soc/blackfin/bf5xx-tdm.c b/sound/soc/blackfin/bf5xx-tdm.c
index 4b360124083e..24c14269f4bc 100644
--- a/sound/soc/blackfin/bf5xx-tdm.c
+++ b/sound/soc/blackfin/bf5xx-tdm.c
@@ -210,8 +210,7 @@ static int bf5xx_tdm_set_channel_map(struct snd_soc_dai *dai,
 #ifdef CONFIG_PM
 static int bf5xx_tdm_suspend(struct snd_soc_dai *dai)
 {
-        struct sport_device *sport =
-                (struct sport_device *)dai->private_data;
+        struct sport_device *sport = dai->private_data;
 
         if (!dai->active)
                 return 0;
@@ -225,8 +224,7 @@ static int bf5xx_tdm_suspend(struct snd_soc_dai *dai)
 static int bf5xx_tdm_resume(struct snd_soc_dai *dai)
 {
         int ret;
-        struct sport_device *sport =
-                (struct sport_device *)dai->private_data;
+        struct sport_device *sport = dai->private_data;
 
         if (!dai->active)
                 return 0;
diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
index 5da30eb6ad00..83f5c67d3c41 100644
--- a/sound/soc/codecs/Kconfig
+++ b/sound/soc/codecs/Kconfig
@@ -22,9 +22,11 @@ config SND_SOC_ALL_CODECS
         select SND_SOC_AK4642 if I2C
         select SND_SOC_AK4671 if I2C
         select SND_SOC_CQ0093VC if MFD_DAVINCI_VOICECODEC
+        select SND_SOC_CS42L51 if I2C
         select SND_SOC_CS4270 if I2C
-        select SND_SOC_MAX9877 if I2C
         select SND_SOC_DA7210 if I2C
+        select SND_SOC_JZ4740 if SOC_JZ4740
+        select SND_SOC_MAX9877 if I2C
         select SND_SOC_PCM3008
         select SND_SOC_SPDIF
         select SND_SOC_SSM2602 if I2C
@@ -48,6 +50,7 @@ config SND_SOC_ALL_CODECS
         select SND_SOC_WM8727
         select SND_SOC_WM8728 if SND_SOC_I2C_AND_SPI
         select SND_SOC_WM8731 if SND_SOC_I2C_AND_SPI
+        select SND_SOC_WM8741 if SND_SOC_I2C_AND_SPI
         select SND_SOC_WM8750 if SND_SOC_I2C_AND_SPI
         select SND_SOC_WM8753 if SND_SOC_I2C_AND_SPI
         select SND_SOC_WM8776 if SND_SOC_I2C_AND_SPI
@@ -120,13 +123,13 @@ config SND_SOC_AK4671
 config SND_SOC_CQ0093VC
         tristate
 
+config SND_SOC_CS42L51
+        tristate
+
 # Cirrus Logic CS4270 Codec
 config SND_SOC_CS4270
         tristate
 
-config SND_SOC_DA7210
-        tristate
-
 # Cirrus Logic CS4270 Codec VD = 3.3V Errata
 # Select if you are affected by the errata where the part will not function
 # if MCLK divide-by-1.5 is selected and VD is set to 3.3V.  The driver will
@@ -138,9 +141,15 @@ config SND_SOC_CS4270_VD33_ERRATA
 config SND_SOC_CX20442
         tristate
 
+config SND_SOC_JZ4740_CODEC
+        tristate
+
 config SND_SOC_L3
        tristate
 
+config SND_SOC_DA7210
+        tristate
+
 config SND_SOC_PCM3008
        tristate
 
@@ -206,6 +215,9 @@ config SND_SOC_WM8728
 config SND_SOC_WM8731
         tristate
 
+config SND_SOC_WM8741
+        tristate
+
 config SND_SOC_WM8750
         tristate
 
diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile
index 91429eab0707..53524095759c 100644
--- a/sound/soc/codecs/Makefile
+++ b/sound/soc/codecs/Makefile
@@ -9,6 +9,7 @@ snd-soc-ak4535-objs := ak4535.o
 snd-soc-ak4642-objs := ak4642.o
 snd-soc-ak4671-objs := ak4671.o
 snd-soc-cq93vc-objs := cq93vc.o
+snd-soc-cs42l51-objs := cs42l51.o
 snd-soc-cs4270-objs := cs4270.o
 snd-soc-cx20442-objs := cx20442.o
 snd-soc-da7210-objs := da7210.o
@@ -34,6 +35,7 @@ snd-soc-wm8711-objs := wm8711.o
 snd-soc-wm8727-objs := wm8727.o
 snd-soc-wm8728-objs := wm8728.o
 snd-soc-wm8731-objs := wm8731.o
+snd-soc-wm8741-objs := wm8741.o
 snd-soc-wm8750-objs := wm8750.o
 snd-soc-wm8753-objs := wm8753.o
 snd-soc-wm8776-objs := wm8776.o
@@ -56,6 +58,7 @@ snd-soc-wm9705-objs := wm9705.o
 snd-soc-wm9712-objs := wm9712.o
 snd-soc-wm9713-objs := wm9713.o
 snd-soc-wm-hubs-objs := wm_hubs.o
+snd-soc-jz4740-codec-objs := jz4740.o
 
 # Amp
 snd-soc-max9877-objs := max9877.o
@@ -74,10 +77,12 @@ obj-$(CONFIG_SND_SOC_AK4535)	+= snd-soc-ak4535.o
 obj-$(CONFIG_SND_SOC_AK4642)    += snd-soc-ak4642.o
 obj-$(CONFIG_SND_SOC_AK4671)    += snd-soc-ak4671.o
 obj-$(CONFIG_SND_SOC_CQ0093VC) += snd-soc-cq93vc.o
+obj-$(CONFIG_SND_SOC_CS42L51)   += snd-soc-cs42l51.o
 obj-$(CONFIG_SND_SOC_CS4270)    += snd-soc-cs4270.o
 obj-$(CONFIG_SND_SOC_CX20442)   += snd-soc-cx20442.o
 obj-$(CONFIG_SND_SOC_DA7210)    += snd-soc-da7210.o
 obj-$(CONFIG_SND_SOC_L3)        += snd-soc-l3.o
+obj-$(CONFIG_SND_SOC_JZ4740_CODEC)      += snd-soc-jz4740-codec.o
 obj-$(CONFIG_SND_SOC_PCM3008)   += snd-soc-pcm3008.o
 obj-$(CONFIG_SND_SOC_SPDIF)     += snd-soc-spdif.o
 obj-$(CONFIG_SND_SOC_SSM2602)   += snd-soc-ssm2602.o
@@ -99,6 +104,7 @@ obj-$(CONFIG_SND_SOC_WM8711)	+= snd-soc-wm8711.o
 obj-$(CONFIG_SND_SOC_WM8727)    += snd-soc-wm8727.o
 obj-$(CONFIG_SND_SOC_WM8728)    += snd-soc-wm8728.o
 obj-$(CONFIG_SND_SOC_WM8731)    += snd-soc-wm8731.o
+obj-$(CONFIG_SND_SOC_WM8741)    += snd-soc-wm8741.o
 obj-$(CONFIG_SND_SOC_WM8750)    += snd-soc-wm8750.o
 obj-$(CONFIG_SND_SOC_WM8753)    += snd-soc-wm8753.o
 obj-$(CONFIG_SND_SOC_WM8776)    += snd-soc-wm8776.o
diff --git a/sound/soc/codecs/ad1836.c b/sound/soc/codecs/ad1836.c
index 217538423225..a01006c8c606 100644
--- a/sound/soc/codecs/ad1836.c
+++ b/sound/soc/codecs/ad1836.c
@@ -272,6 +272,7 @@ static int ad1836_register(struct ad1836_priv *ad1836)
 
         if (ad1836_codec) {
                 dev_err(codec->dev, "Another ad1836 is registered\n");
+                kfree(ad1836);
                 return -EINVAL;
         }
 
diff --git a/sound/soc/codecs/ad193x.c b/sound/soc/codecs/ad193x.c
index c8ca1142b2f4..1def75e4862f 100644
--- a/sound/soc/codecs/ad193x.c
+++ b/sound/soc/codecs/ad193x.c
@@ -24,6 +24,7 @@
 
 /* codec private data */
 struct ad193x_priv {
+        unsigned int sysclk;
         struct snd_soc_codec codec;
         u8 reg_cache[AD193X_NUM_REGS];
 };
@@ -251,15 +252,32 @@ static int ad193x_set_dai_fmt(struct snd_soc_dai *codec_dai,
         return 0;
 }
 
+static int ad193x_set_dai_sysclk(struct snd_soc_dai *codec_dai,
+                int clk_id, unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(codec);
+        switch (freq) {
+        case 12288000:
+        case 18432000:
+        case 24576000:
+        case 36864000:
+                ad193x->sysclk = freq;
+                return 0;
+        }
+        return -EINVAL;
+}
+
 static int ad193x_hw_params(struct snd_pcm_substream *substream,
                 struct snd_pcm_hw_params *params,
                 struct snd_soc_dai *dai)
 {
-        int word_len = 0, reg = 0;
+        int word_len = 0, reg = 0, master_rate = 0;
 
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_device *socdev = rtd->socdev;
         struct snd_soc_codec *codec = socdev->card->codec;
+        struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(codec);
 
         /* bit size */
         switch (params_format(params)) {
@@ -275,6 +293,25 @@ static int ad193x_hw_params(struct snd_pcm_substream *substream,
                 break;
         }
 
+        switch (ad193x->sysclk) {
+        case 12288000:
+                master_rate = AD193X_PLL_INPUT_256;
+                break;
+        case 18432000:
+                master_rate = AD193X_PLL_INPUT_384;
+                break;
+        case 24576000:
+                master_rate = AD193X_PLL_INPUT_512;
+                break;
+        case 36864000:
+                master_rate = AD193X_PLL_INPUT_768;
+                break;
+        }
+
+        reg = snd_soc_read(codec, AD193X_PLL_CLK_CTRL0);
+        reg = (reg & AD193X_PLL_INPUT_MASK) | master_rate;
+        snd_soc_write(codec, AD193X_PLL_CLK_CTRL0, reg);
+
         reg = snd_soc_read(codec, AD193X_DAC_CTRL2);
         reg = (reg & (~AD193X_DAC_WORD_LEN_MASK)) | word_len;
         snd_soc_write(codec, AD193X_DAC_CTRL2, reg);
@@ -348,6 +385,7 @@ static int ad193x_bus_probe(struct device *dev, void *ctrl_data, int bus_type)
         /* pll input: mclki/xi */
         snd_soc_write(codec, AD193X_PLL_CLK_CTRL0, 0x99); /* mclk=24.576Mhz: 0x9D; mclk=12.288Mhz: 0x99 */
         snd_soc_write(codec, AD193X_PLL_CLK_CTRL1, 0x04);
+        ad193x->sysclk = 12288000;
 
         ret = snd_soc_register_codec(codec);
         if (ret != 0) {
@@ -383,6 +421,7 @@ static struct snd_soc_dai_ops ad193x_dai_ops = {
         .hw_params = ad193x_hw_params,
         .digital_mute = ad193x_mute,
         .set_tdm_slot = ad193x_set_tdm_slot,
+        .set_sysclk     = ad193x_set_dai_sysclk,
         .set_fmt = ad193x_set_dai_fmt,
 };
 
diff --git a/sound/soc/codecs/ad193x.h b/sound/soc/codecs/ad193x.h
index a03c880d52f9..654ba64ae04c 100644
--- a/sound/soc/codecs/ad193x.h
+++ b/sound/soc/codecs/ad193x.h
@@ -11,6 +11,11 @@
 
 #define AD193X_PLL_CLK_CTRL0    0x800
 #define AD193X_PLL_POWERDOWN           0x01
+#define AD193X_PLL_INPUT_MASK   (~0x6)
+#define AD193X_PLL_INPUT_256    (0 << 1)
+#define AD193X_PLL_INPUT_384    (1 << 1)
+#define AD193X_PLL_INPUT_512    (2 << 1)
+#define AD193X_PLL_INPUT_768    (3 << 1)
 #define AD193X_PLL_CLK_CTRL1    0x801
 #define AD193X_DAC_CTRL0        0x802
 #define AD193X_DAC_POWERDOWN           0x01
diff --git a/sound/soc/codecs/ad1980.c b/sound/soc/codecs/ad1980.c
index 042072738cdc..70cfaec3be2c 100644
--- a/sound/soc/codecs/ad1980.c
+++ b/sound/soc/codecs/ad1980.c
@@ -11,6 +11,14 @@
  *  option) any later version.
  */
 
+/*
+ * WARNING:
+ *
+ * Because Analog Devices Inc. discontinued the ad1980 sound chip since
+ * Sep. 2009, this ad1980 driver is not maintained, tested and supported
+ * by ADI now.
+ */
+
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/module.h>
@@ -298,6 +306,6 @@ struct snd_soc_codec_device soc_codec_dev_ad1980 = {
 };
 EXPORT_SYMBOL_GPL(soc_codec_dev_ad1980);
 
-MODULE_DESCRIPTION("ASoC ad1980 driver");
+MODULE_DESCRIPTION("ASoC ad1980 driver (Obsolete)");
 MODULE_AUTHOR("Roy Huang, Cliff Cai");
 MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/ad1980.h b/sound/soc/codecs/ad1980.h
index db6c8500d66b..538f37c90806 100644
--- a/sound/soc/codecs/ad1980.h
+++ b/sound/soc/codecs/ad1980.h
@@ -1,5 +1,11 @@
 /*
  * ad1980.h  --  ad1980 Soc Audio driver
+ *
+ * WARNING:
+ *
+ * Because Analog Devices Inc. discontinued the ad1980 sound chip since
+ * Sep. 2009, this ad1980 driver is not maintained, tested and supported
+ * by ADI now.
  */
 
 #ifndef _AD1980_H
diff --git a/sound/soc/codecs/ak4642.c b/sound/soc/codecs/ak4642.c
index 7528a54102b5..3d7dc55305ec 100644
--- a/sound/soc/codecs/ak4642.c
+++ b/sound/soc/codecs/ak4642.c
@@ -22,20 +22,13 @@
  * AK4643 is tested.
  */
 
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/init.h>
 #include <linux/delay.h>
-#include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/pcm_params.h>
-#include <sound/soc.h>
 #include <sound/soc-dapm.h>
 #include <sound/initval.h>
+#include <sound/tlv.h>
 
 #include "ak4642.h"
 
@@ -111,6 +104,23 @@
 
 struct snd_soc_codec_device soc_codec_dev_ak4642;
 
+/*
+ * Playback Volume (table 39)
+ *
+ * max : 0x00 : +12.0 dB
+ *       ( 0.5 dB step )
+ * min : 0xFE : -115.0 dB
+ * mute: 0xFF
+ */
+static const DECLARE_TLV_DB_SCALE(out_tlv, -11500, 50, 1);
+
+static const struct snd_kcontrol_new ak4642_snd_controls[] = {
+
+        SOC_DOUBLE_R_TLV("Digital Playback Volume", L_DVC, R_DVC,
+                         0, 0xFF, 1, out_tlv),
+};
+
+
 /* codec private data */
 struct ak4642_priv {
         struct snd_soc_codec codec;
@@ -204,7 +214,6 @@ static int ak4642_dai_startup(struct snd_pcm_substream *substream,
                  *
                  * PLL, Master Mode
                  * Audio I/F Format :MSB justified (ADC & DAC)
-                 * Digital Volume: -8dB
                  * Bass Boost Level : Middle
                  *
                  * This operation came from example code of
@@ -214,8 +223,6 @@ static int ak4642_dai_startup(struct snd_pcm_substream *substream,
                 ak4642_write(codec, 0x0e, 0x19);
                 ak4642_write(codec, 0x09, 0x91);
                 ak4642_write(codec, 0x0c, 0x91);
-                ak4642_write(codec, 0x0a, 0x28);
-                ak4642_write(codec, 0x0d, 0x28);
                 ak4642_write(codec, 0x00, 0x64);
                 snd_soc_update_bits(codec, PW_MGMT2, PMHP_MASK, PMHP);
                 snd_soc_update_bits(codec, PW_MGMT2, HPMTN,     HPMTN);
@@ -491,8 +498,10 @@ static int ak4642_i2c_probe(struct i2c_client *i2c,
         codec->control_data = i2c;
 
         ret = ak4642_init(ak4642);
-        if (ret < 0)
+        if (ret < 0) {
                 printk(KERN_ERR "failed to initialise AK4642\n");
+                kfree(ak4642);
+        }
 
         return ret;
 }
@@ -548,6 +557,9 @@ static int ak4642_probe(struct platform_device *pdev)
                 goto pcm_err;
         }
 
+        snd_soc_add_controls(ak4642_codec, ak4642_snd_controls,
+                             ARRAY_SIZE(ak4642_snd_controls));
+
         dev_info(&pdev->dev, "AK4642 Audio Codec %s", AK4642_VERSION);
         return ret;
 
diff --git a/sound/soc/codecs/cs42l51.c b/sound/soc/codecs/cs42l51.c
new file mode 100644
index 000000000000..dd9b8550c402
--- /dev/null
+++ b/sound/soc/codecs/cs42l51.c
@@ -0,0 +1,763 @@
+/*
+ * cs42l51.c
+ *
+ * ASoC Driver for Cirrus Logic CS42L51 codecs
+ *
+ * Copyright (c) 2010 Arnaud Patard <apatard@mandriva.com>
+ *
+ * Based on cs4270.c - Copyright (c) Freescale Semiconductor
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * For now:
+ *  - Only I2C is support. Not SPI
+ *  - master mode *NOT* supported
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/tlv.h>
+#include <sound/initval.h>
+#include <sound/pcm_params.h>
+#include <sound/pcm.h>
+#include <linux/i2c.h>
+
+#include "cs42l51.h"
+
+enum master_slave_mode {
+        MODE_SLAVE,
+        MODE_SLAVE_AUTO,
+        MODE_MASTER,
+};
+
+struct cs42l51_private {
+        unsigned int mclk;
+        unsigned int audio_mode;        /* The mode (I2S or left-justified) */
+        enum master_slave_mode func;
+        struct snd_soc_codec codec;
+        u8 reg_cache[CS42L51_NUMREGS];
+};
+
+static struct snd_soc_codec *cs42l51_codec;
+
+#define CS42L51_FORMATS ( \
+                SNDRV_PCM_FMTBIT_S16_LE  | SNDRV_PCM_FMTBIT_S16_BE  | \
+                SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE | \
+                SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE | \
+                SNDRV_PCM_FMTBIT_S24_LE  | SNDRV_PCM_FMTBIT_S24_BE)
+
+static int cs42l51_fill_cache(struct snd_soc_codec *codec)
+{
+        u8 *cache = codec->reg_cache + 1;
+        struct i2c_client *i2c_client = codec->control_data;
+        s32 length;
+
+        length = i2c_smbus_read_i2c_block_data(i2c_client,
+                        CS42L51_FIRSTREG | 0x80, CS42L51_NUMREGS, cache);
+        if (length != CS42L51_NUMREGS) {
+                dev_err(&i2c_client->dev,
+                                "I2C read failure, addr=0x%x (ret=%d vs %d)\n",
+                                i2c_client->addr, length, CS42L51_NUMREGS);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int cs42l51_i2c_probe(struct i2c_client *i2c_client,
+        const struct i2c_device_id *id)
+{
+        struct snd_soc_codec *codec;
+        struct cs42l51_private *cs42l51;
+        int ret = 0;
+        int reg;
+
+        if (cs42l51_codec)
+                return -EBUSY;
+
+        /* Verify that we have a CS42L51 */
+        ret = i2c_smbus_read_byte_data(i2c_client, CS42L51_CHIP_REV_ID);
+        if (ret < 0) {
+                dev_err(&i2c_client->dev, "failed to read I2C\n");
+                goto error;
+        }
+
+        if ((ret != CS42L51_MK_CHIP_REV(CS42L51_CHIP_ID, CS42L51_CHIP_REV_A)) &&
+            (ret != CS42L51_MK_CHIP_REV(CS42L51_CHIP_ID, CS42L51_CHIP_REV_B))) {
+                dev_err(&i2c_client->dev, "Invalid chip id\n");
+                ret = -ENODEV;
+                goto error;
+        }
+
+        dev_info(&i2c_client->dev, "found device cs42l51 rev %d\n",
+                                ret & 7);
+
+        cs42l51 = kzalloc(sizeof(struct cs42l51_private), GFP_KERNEL);
+        if (!cs42l51) {
+                dev_err(&i2c_client->dev, "could not allocate codec\n");
+                return -ENOMEM;
+        }
+        codec = &cs42l51->codec;
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->dev = &i2c_client->dev;
+        codec->name = "CS42L51";
+        codec->owner = THIS_MODULE;
+        codec->dai = &cs42l51_dai;
+        codec->num_dai = 1;
+        snd_soc_codec_set_drvdata(codec, cs42l51);
+
+        codec->control_data = i2c_client;
+        codec->reg_cache = cs42l51->reg_cache;
+        codec->reg_cache_size = CS42L51_NUMREGS;
+        i2c_set_clientdata(i2c_client, codec);
+
+        ret = cs42l51_fill_cache(codec);
+        if (ret < 0) {
+                dev_err(&i2c_client->dev, "failed to fill register cache\n");
+                goto error_alloc;
+        }
+
+        ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_I2C);
+        if (ret < 0) {
+                dev_err(&i2c_client->dev, "Failed to set cache I/O: %d\n", ret);
+                goto error_alloc;
+        }
+
+        /*
+         * DAC configuration
+         * - Use signal processor
+         * - auto mute
+         * - vol changes immediate
+         * - no de-emphasize
+         */
+        reg = CS42L51_DAC_CTL_DATA_SEL(1)
+                | CS42L51_DAC_CTL_AMUTE | CS42L51_DAC_CTL_DACSZ(0);
+        ret = snd_soc_write(codec, CS42L51_DAC_CTL, reg);
+        if (ret < 0)
+                goto error_alloc;
+
+        cs42l51_dai.dev = codec->dev;
+        cs42l51_codec = codec;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                goto error_alloc;
+        }
+
+        ret = snd_soc_register_dai(&cs42l51_dai);
+        if (ret < 0) {
+                dev_err(&i2c_client->dev, "failed to register DAIe\n");
+                goto error_reg;
+        }
+
+        return 0;
+
+error_reg:
+        snd_soc_unregister_codec(codec);
+error_alloc:
+        kfree(cs42l51);
+error:
+        return ret;
+}
+
+static int cs42l51_i2c_remove(struct i2c_client *client)
+{
+        struct cs42l51_private *cs42l51 = i2c_get_clientdata(client);
+        snd_soc_unregister_dai(&cs42l51_dai);
+        snd_soc_unregister_codec(cs42l51_codec);
+        cs42l51_codec = NULL;
+        kfree(cs42l51);
+        return 0;
+}
+
+
+static const struct i2c_device_id cs42l51_id[] = {
+        {"cs42l51", 0},
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, cs42l51_id);
+
+static struct i2c_driver cs42l51_i2c_driver = {
+        .driver = {
+                .name = "CS42L51 I2C",
+                .owner = THIS_MODULE,
+        },
+        .id_table = cs42l51_id,
+        .probe = cs42l51_i2c_probe,
+        .remove = cs42l51_i2c_remove,
+};
+
+static int cs42l51_get_chan_mix(struct snd_kcontrol *kcontrol,
+                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        unsigned long value = snd_soc_read(codec, CS42L51_PCM_MIXER)&3;
+
+        switch (value) {
+        default:
+        case 0:
+                ucontrol->value.integer.value[0] = 0;
+                break;
+        /* same value : (L+R)/2 and (R+L)/2 */
+        case 1:
+        case 2:
+                ucontrol->value.integer.value[0] = 1;
+                break;
+        case 3:
+                ucontrol->value.integer.value[0] = 2;
+                break;
+        }
+
+        return 0;
+}
+
+#define CHAN_MIX_NORMAL 0x00
+#define CHAN_MIX_BOTH   0x55
+#define CHAN_MIX_SWAP   0xFF
+
+static int cs42l51_set_chan_mix(struct snd_kcontrol *kcontrol,
+                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        unsigned char val;
+
+        switch (ucontrol->value.integer.value[0]) {
+        default:
+        case 0:
+                val = CHAN_MIX_NORMAL;
+                break;
+        case 1:
+                val = CHAN_MIX_BOTH;
+                break;
+        case 2:
+                val = CHAN_MIX_SWAP;
+                break;
+        }
+
+        snd_soc_write(codec, CS42L51_PCM_MIXER, val);
+
+        return 1;
+}
+
+static const DECLARE_TLV_DB_SCALE(adc_pcm_tlv, -5150, 50, 0);
+static const DECLARE_TLV_DB_SCALE(tone_tlv, -1050, 150, 0);
+/* This is a lie. after -102 db, it stays at -102 */
+/* maybe a range would be better */
+static const DECLARE_TLV_DB_SCALE(aout_tlv, -11550, 50, 0);
+
+static const DECLARE_TLV_DB_SCALE(boost_tlv, 1600, 1600, 0);
+static const char *chan_mix[] = {
+        "L R",
+        "L+R",
+        "R L",
+};
+
+static const struct soc_enum cs42l51_chan_mix =
+        SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(chan_mix), chan_mix);
+
+static const struct snd_kcontrol_new cs42l51_snd_controls[] = {
+        SOC_DOUBLE_R_SX_TLV("PCM Playback Volume",
+                        CS42L51_PCMA_VOL, CS42L51_PCMB_VOL,
+                        7, 0xffffff99, 0x18, adc_pcm_tlv),
+        SOC_DOUBLE_R("PCM Playback Switch",
+                        CS42L51_PCMA_VOL, CS42L51_PCMB_VOL, 7, 1, 1),
+        SOC_DOUBLE_R_SX_TLV("Analog Playback Volume",
+                        CS42L51_AOUTA_VOL, CS42L51_AOUTB_VOL,
+                        8, 0xffffff19, 0x18, aout_tlv),
+        SOC_DOUBLE_R_SX_TLV("ADC Mixer Volume",
+                        CS42L51_ADCA_VOL, CS42L51_ADCB_VOL,
+                        7, 0xffffff99, 0x18, adc_pcm_tlv),
+        SOC_DOUBLE_R("ADC Mixer Switch",
+                        CS42L51_ADCA_VOL, CS42L51_ADCB_VOL, 7, 1, 1),
+        SOC_SINGLE("Playback Deemphasis Switch", CS42L51_DAC_CTL, 3, 1, 0),
+        SOC_SINGLE("Auto-Mute Switch", CS42L51_DAC_CTL, 2, 1, 0),
+        SOC_SINGLE("Soft Ramp Switch", CS42L51_DAC_CTL, 1, 1, 0),
+        SOC_SINGLE("Zero Cross Switch", CS42L51_DAC_CTL, 0, 0, 0),
+        SOC_DOUBLE_TLV("Mic Boost Volume",
+                        CS42L51_MIC_CTL, 0, 1, 1, 0, boost_tlv),
+        SOC_SINGLE_TLV("Bass Volume", CS42L51_TONE_CTL, 0, 0xf, 1, tone_tlv),
+        SOC_SINGLE_TLV("Treble Volume", CS42L51_TONE_CTL, 4, 0xf, 1, tone_tlv),
+        SOC_ENUM_EXT("PCM channel mixer",
+                        cs42l51_chan_mix,
+                        cs42l51_get_chan_mix, cs42l51_set_chan_mix),
+};
+
+/*
+ * to power down, one must:
+ * 1.) Enable the PDN bit
+ * 2.) enable power-down for the select channels
+ * 3.) disable the PDN bit.
+ */
+static int cs42l51_pdn_event(struct snd_soc_dapm_widget *w,
+                struct snd_kcontrol *kcontrol, int event)
+{
+        unsigned long value;
+
+        value = snd_soc_read(w->codec, CS42L51_POWER_CTL1);
+        value &= ~CS42L51_POWER_CTL1_PDN;
+
+        switch (event) {
+        case SND_SOC_DAPM_PRE_PMD:
+                value |= CS42L51_POWER_CTL1_PDN;
+                break;
+        default:
+        case SND_SOC_DAPM_POST_PMD:
+                break;
+        }
+        snd_soc_update_bits(w->codec, CS42L51_POWER_CTL1,
+                CS42L51_POWER_CTL1_PDN, value);
+
+        return 0;
+}
+
+static const char *cs42l51_dac_names[] = {"Direct PCM",
+        "DSP PCM", "ADC"};
+static const struct soc_enum cs42l51_dac_mux_enum =
+        SOC_ENUM_SINGLE(CS42L51_DAC_CTL, 6, 3, cs42l51_dac_names);
+static const struct snd_kcontrol_new cs42l51_dac_mux_controls =
+        SOC_DAPM_ENUM("Route", cs42l51_dac_mux_enum);
+
+static const char *cs42l51_adcl_names[] = {"AIN1 Left", "AIN2 Left",
+        "MIC Left", "MIC+preamp Left"};
+static const struct soc_enum cs42l51_adcl_mux_enum =
+        SOC_ENUM_SINGLE(CS42L51_ADC_INPUT, 4, 4, cs42l51_adcl_names);
+static const struct snd_kcontrol_new cs42l51_adcl_mux_controls =
+        SOC_DAPM_ENUM("Route", cs42l51_adcl_mux_enum);
+
+static const char *cs42l51_adcr_names[] = {"AIN1 Right", "AIN2 Right",
+        "MIC Right", "MIC+preamp Right"};
+static const struct soc_enum cs42l51_adcr_mux_enum =
+        SOC_ENUM_SINGLE(CS42L51_ADC_INPUT, 6, 4, cs42l51_adcr_names);
+static const struct snd_kcontrol_new cs42l51_adcr_mux_controls =
+        SOC_DAPM_ENUM("Route", cs42l51_adcr_mux_enum);
+
+static const struct snd_soc_dapm_widget cs42l51_dapm_widgets[] = {
+        SND_SOC_DAPM_MICBIAS("Mic Bias", CS42L51_MIC_POWER_CTL, 1, 1),
+        SND_SOC_DAPM_PGA_E("Left PGA", CS42L51_POWER_CTL1, 3, 1, NULL, 0,
+                cs42l51_pdn_event, SND_SOC_DAPM_PRE_POST_PMD),
+        SND_SOC_DAPM_PGA_E("Right PGA", CS42L51_POWER_CTL1, 4, 1, NULL, 0,
+                cs42l51_pdn_event, SND_SOC_DAPM_PRE_POST_PMD),
+        SND_SOC_DAPM_ADC_E("Left ADC", "Left HiFi Capture",
+                CS42L51_POWER_CTL1, 1, 1,
+                cs42l51_pdn_event, SND_SOC_DAPM_PRE_POST_PMD),
+        SND_SOC_DAPM_ADC_E("Right ADC", "Right HiFi Capture",
+                CS42L51_POWER_CTL1, 2, 1,
+                cs42l51_pdn_event, SND_SOC_DAPM_PRE_POST_PMD),
+        SND_SOC_DAPM_DAC_E("Left DAC", "Left HiFi Playback",
+                CS42L51_POWER_CTL1, 5, 1,
+                cs42l51_pdn_event, SND_SOC_DAPM_PRE_POST_PMD),
+        SND_SOC_DAPM_DAC_E("Right DAC", "Right HiFi Playback",
+                CS42L51_POWER_CTL1, 6, 1,
+                cs42l51_pdn_event, SND_SOC_DAPM_PRE_POST_PMD),
+
+        /* analog/mic */
+        SND_SOC_DAPM_INPUT("AIN1L"),
+        SND_SOC_DAPM_INPUT("AIN1R"),
+        SND_SOC_DAPM_INPUT("AIN2L"),
+        SND_SOC_DAPM_INPUT("AIN2R"),
+        SND_SOC_DAPM_INPUT("MICL"),
+        SND_SOC_DAPM_INPUT("MICR"),
+
+        SND_SOC_DAPM_MIXER("Mic Preamp Left",
+                CS42L51_MIC_POWER_CTL, 2, 1, NULL, 0),
+        SND_SOC_DAPM_MIXER("Mic Preamp Right",
+                CS42L51_MIC_POWER_CTL, 3, 1, NULL, 0),
+
+        /* HP */
+        SND_SOC_DAPM_OUTPUT("HPL"),
+        SND_SOC_DAPM_OUTPUT("HPR"),
+
+        /* mux */
+        SND_SOC_DAPM_MUX("DAC Mux", SND_SOC_NOPM, 0, 0,
+                &cs42l51_dac_mux_controls),
+        SND_SOC_DAPM_MUX("PGA-ADC Mux Left", SND_SOC_NOPM, 0, 0,
+                &cs42l51_adcl_mux_controls),
+        SND_SOC_DAPM_MUX("PGA-ADC Mux Right", SND_SOC_NOPM, 0, 0,
+                &cs42l51_adcr_mux_controls),
+};
+
+static const struct snd_soc_dapm_route cs42l51_routes[] = {
+        {"HPL", NULL, "Left DAC"},
+        {"HPR", NULL, "Right DAC"},
+
+        {"Left ADC", NULL, "Left PGA"},
+        {"Right ADC", NULL, "Right PGA"},
+
+        {"Mic Preamp Left",  NULL,  "MICL"},
+        {"Mic Preamp Right", NULL,  "MICR"},
+
+        {"PGA-ADC Mux Left",  "AIN1 Left",        "AIN1L" },
+        {"PGA-ADC Mux Left",  "AIN2 Left",        "AIN2L" },
+        {"PGA-ADC Mux Left",  "MIC Left",         "MICL"  },
+        {"PGA-ADC Mux Left",  "MIC+preamp Left",  "Mic Preamp Left" },
+        {"PGA-ADC Mux Right", "AIN1 Right",       "AIN1R" },
+        {"PGA-ADC Mux Right", "AIN2 Right",       "AIN2R" },
+        {"PGA-ADC Mux Right", "MIC Right",        "MICR" },
+        {"PGA-ADC Mux Right", "MIC+preamp Right", "Mic Preamp Right" },
+
+        {"Left PGA", NULL, "PGA-ADC Mux Left"},
+        {"Right PGA", NULL, "PGA-ADC Mux Right"},
+};
+
+static int cs42l51_set_dai_fmt(struct snd_soc_dai *codec_dai,
+                unsigned int format)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct cs42l51_private *cs42l51 = snd_soc_codec_get_drvdata(codec);
+        int ret = 0;
+
+        switch (format & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+        case SND_SOC_DAIFMT_LEFT_J:
+        case SND_SOC_DAIFMT_RIGHT_J:
+                cs42l51->audio_mode = format & SND_SOC_DAIFMT_FORMAT_MASK;
+                break;
+        default:
+                dev_err(codec->dev, "invalid DAI format\n");
+                ret = -EINVAL;
+        }
+
+        switch (format & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBM_CFM:
+                cs42l51->func = MODE_MASTER;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFS:
+                cs42l51->func = MODE_SLAVE_AUTO;
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+        return ret;
+}
+
+struct cs42l51_ratios {
+        unsigned int ratio;
+        unsigned char speed_mode;
+        unsigned char mclk;
+};
+
+static struct cs42l51_ratios slave_ratios[] = {
+        {  512, CS42L51_QSM_MODE, 0 }, {  768, CS42L51_QSM_MODE, 0 },
+        { 1024, CS42L51_QSM_MODE, 0 }, { 1536, CS42L51_QSM_MODE, 0 },
+        { 2048, CS42L51_QSM_MODE, 0 }, { 3072, CS42L51_QSM_MODE, 0 },
+        {  256, CS42L51_HSM_MODE, 0 }, {  384, CS42L51_HSM_MODE, 0 },
+        {  512, CS42L51_HSM_MODE, 0 }, {  768, CS42L51_HSM_MODE, 0 },
+        { 1024, CS42L51_HSM_MODE, 0 }, { 1536, CS42L51_HSM_MODE, 0 },
+        {  128, CS42L51_SSM_MODE, 0 }, {  192, CS42L51_SSM_MODE, 0 },
+        {  256, CS42L51_SSM_MODE, 0 }, {  384, CS42L51_SSM_MODE, 0 },
+        {  512, CS42L51_SSM_MODE, 0 }, {  768, CS42L51_SSM_MODE, 0 },
+        {  128, CS42L51_DSM_MODE, 0 }, {  192, CS42L51_DSM_MODE, 0 },
+        {  256, CS42L51_DSM_MODE, 0 }, {  384, CS42L51_DSM_MODE, 0 },
+};
+
+static struct cs42l51_ratios slave_auto_ratios[] = {
+        { 1024, CS42L51_QSM_MODE, 0 }, { 1536, CS42L51_QSM_MODE, 0 },
+        { 2048, CS42L51_QSM_MODE, 1 }, { 3072, CS42L51_QSM_MODE, 1 },
+        {  512, CS42L51_HSM_MODE, 0 }, {  768, CS42L51_HSM_MODE, 0 },
+        { 1024, CS42L51_HSM_MODE, 1 }, { 1536, CS42L51_HSM_MODE, 1 },
+        {  256, CS42L51_SSM_MODE, 0 }, {  384, CS42L51_SSM_MODE, 0 },
+        {  512, CS42L51_SSM_MODE, 1 }, {  768, CS42L51_SSM_MODE, 1 },
+        {  128, CS42L51_DSM_MODE, 0 }, {  192, CS42L51_DSM_MODE, 0 },
+        {  256, CS42L51_DSM_MODE, 1 }, {  384, CS42L51_DSM_MODE, 1 },
+};
+
+static int cs42l51_set_dai_sysclk(struct snd_soc_dai *codec_dai,
+                int clk_id, unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct cs42l51_private *cs42l51 = snd_soc_codec_get_drvdata(codec);
+        struct cs42l51_ratios *ratios = NULL;
+        int nr_ratios = 0;
+        unsigned int rates = 0;
+        unsigned int rate_min = -1;
+        unsigned int rate_max = 0;
+        int i;
+
+        cs42l51->mclk = freq;
+
+        switch (cs42l51->func) {
+        case MODE_MASTER:
+                return -EINVAL;
+        case MODE_SLAVE:
+                ratios = slave_ratios;
+                nr_ratios = ARRAY_SIZE(slave_ratios);
+                break;
+        case MODE_SLAVE_AUTO:
+                ratios = slave_auto_ratios;
+                nr_ratios = ARRAY_SIZE(slave_auto_ratios);
+                break;
+        }
+
+        for (i = 0; i < nr_ratios; i++) {
+                unsigned int rate = freq / ratios[i].ratio;
+                rates |= snd_pcm_rate_to_rate_bit(rate);
+                if (rate < rate_min)
+                        rate_min = rate;
+                if (rate > rate_max)
+                        rate_max = rate;
+        }
+        rates &= ~SNDRV_PCM_RATE_KNOT;
+
+        if (!rates) {
+                dev_err(codec->dev, "could not find a valid sample rate\n");
+                return -EINVAL;
+        }
+
+        codec_dai->playback.rates = rates;
+        codec_dai->playback.rate_min = rate_min;
+        codec_dai->playback.rate_max = rate_max;
+
+        codec_dai->capture.rates = rates;
+        codec_dai->capture.rate_min = rate_min;
+        codec_dai->capture.rate_max = rate_max;
+
+        return 0;
+}
+
+static int cs42l51_hw_params(struct snd_pcm_substream *substream,
+                struct snd_pcm_hw_params *params,
+                struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct cs42l51_private *cs42l51 = snd_soc_codec_get_drvdata(codec);
+        int ret;
+        unsigned int i;
+        unsigned int rate;
+        unsigned int ratio;
+        struct cs42l51_ratios *ratios = NULL;
+        int nr_ratios = 0;
+        int intf_ctl, power_ctl, fmt;
+
+        switch (cs42l51->func) {
+        case MODE_MASTER:
+                return -EINVAL;
+        case MODE_SLAVE:
+                ratios = slave_ratios;
+                nr_ratios = ARRAY_SIZE(slave_ratios);
+                break;
+        case MODE_SLAVE_AUTO:
+                ratios = slave_auto_ratios;
+                nr_ratios = ARRAY_SIZE(slave_auto_ratios);
+                break;
+        }
+
+        /* Figure out which MCLK/LRCK ratio to use */
+        rate = params_rate(params);     /* Sampling rate, in Hz */
+        ratio = cs42l51->mclk / rate;    /* MCLK/LRCK ratio */
+        for (i = 0; i < nr_ratios; i++) {
+                if (ratios[i].ratio == ratio)
+                        break;
+        }
+
+        if (i == nr_ratios) {
+                /* We did not find a matching ratio */
+                dev_err(codec->dev, "could not find matching ratio\n");
+                return -EINVAL;
+        }
+
+        intf_ctl = snd_soc_read(codec, CS42L51_INTF_CTL);
+        power_ctl = snd_soc_read(codec, CS42L51_MIC_POWER_CTL);
+
+        intf_ctl &= ~(CS42L51_INTF_CTL_MASTER | CS42L51_INTF_CTL_ADC_I2S
+                        | CS42L51_INTF_CTL_DAC_FORMAT(7));
+        power_ctl &= ~(CS42L51_MIC_POWER_CTL_SPEED(3)
+                        | CS42L51_MIC_POWER_CTL_MCLK_DIV2);
+
+        switch (cs42l51->func) {
+        case MODE_MASTER:
+                intf_ctl |= CS42L51_INTF_CTL_MASTER;
+                power_ctl |= CS42L51_MIC_POWER_CTL_SPEED(ratios[i].speed_mode);
+                break;
+        case MODE_SLAVE:
+                power_ctl |= CS42L51_MIC_POWER_CTL_SPEED(ratios[i].speed_mode);
+                break;
+        case MODE_SLAVE_AUTO:
+                power_ctl |= CS42L51_MIC_POWER_CTL_AUTO;
+                break;
+        }
+
+        switch (cs42l51->audio_mode) {
+        case SND_SOC_DAIFMT_I2S:
+                intf_ctl |= CS42L51_INTF_CTL_ADC_I2S;
+                intf_ctl |= CS42L51_INTF_CTL_DAC_FORMAT(CS42L51_DAC_DIF_I2S);
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                intf_ctl |= CS42L51_INTF_CTL_DAC_FORMAT(CS42L51_DAC_DIF_LJ24);
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                switch (params_format(params)) {
+                case SNDRV_PCM_FORMAT_S16_LE:
+                case SNDRV_PCM_FORMAT_S16_BE:
+                        fmt = CS42L51_DAC_DIF_RJ16;
+                        break;
+                case SNDRV_PCM_FORMAT_S18_3LE:
+                case SNDRV_PCM_FORMAT_S18_3BE:
+                        fmt = CS42L51_DAC_DIF_RJ18;
+                        break;
+                case SNDRV_PCM_FORMAT_S20_3LE:
+                case SNDRV_PCM_FORMAT_S20_3BE:
+                        fmt = CS42L51_DAC_DIF_RJ20;
+                        break;
+                case SNDRV_PCM_FORMAT_S24_LE:
+                case SNDRV_PCM_FORMAT_S24_BE:
+                        fmt = CS42L51_DAC_DIF_RJ24;
+                        break;
+                default:
+                        dev_err(codec->dev, "unknown format\n");
+                        return -EINVAL;
+                }
+                intf_ctl |= CS42L51_INTF_CTL_DAC_FORMAT(fmt);
+                break;
+        default:
+                dev_err(codec->dev, "unknown format\n");
+                return -EINVAL;
+        }
+
+        if (ratios[i].mclk)
+                power_ctl |= CS42L51_MIC_POWER_CTL_MCLK_DIV2;
+
+        ret = snd_soc_write(codec, CS42L51_INTF_CTL, intf_ctl);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_write(codec, CS42L51_MIC_POWER_CTL, power_ctl);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int cs42l51_dai_mute(struct snd_soc_dai *dai, int mute)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        int reg;
+        int mask = CS42L51_DAC_OUT_CTL_DACA_MUTE|CS42L51_DAC_OUT_CTL_DACB_MUTE;
+
+        reg = snd_soc_read(codec, CS42L51_DAC_OUT_CTL);
+
+        if (mute)
+                reg |= mask;
+        else
+                reg &= ~mask;
+
+        return snd_soc_write(codec, CS42L51_DAC_OUT_CTL, reg);
+}
+
+static struct snd_soc_dai_ops cs42l51_dai_ops = {
+        .hw_params      = cs42l51_hw_params,
+        .set_sysclk     = cs42l51_set_dai_sysclk,
+        .set_fmt        = cs42l51_set_dai_fmt,
+        .digital_mute   = cs42l51_dai_mute,
+};
+
+struct snd_soc_dai cs42l51_dai = {
+        .name = "CS42L51 HiFi",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_96000,
+                .formats = CS42L51_FORMATS,
+        },
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_96000,
+                .formats = CS42L51_FORMATS,
+        },
+        .ops = &cs42l51_dai_ops,
+};
+EXPORT_SYMBOL_GPL(cs42l51_dai);
+
+
+static int cs42l51_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (!cs42l51_codec) {
+                dev_err(&pdev->dev, "CS42L51 codec not yet registered\n");
+                return -EINVAL;
+        }
+
+        socdev->card->codec = cs42l51_codec;
+        codec = socdev->card->codec;
+
+        /* Register PCMs */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "failed to create PCMs\n");
+                return ret;
+        }
+
+        snd_soc_add_controls(codec, cs42l51_snd_controls,
+                ARRAY_SIZE(cs42l51_snd_controls));
+        snd_soc_dapm_new_controls(codec, cs42l51_dapm_widgets,
+                ARRAY_SIZE(cs42l51_dapm_widgets));
+        snd_soc_dapm_add_routes(codec, cs42l51_routes,
+                ARRAY_SIZE(cs42l51_routes));
+
+        return 0;
+}
+
+
+static int cs42l51_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_device_cs42l51 = {
+        .probe =        cs42l51_probe,
+        .remove =       cs42l51_remove
+};
+EXPORT_SYMBOL_GPL(soc_codec_device_cs42l51);
+
+static int __init cs42l51_init(void)
+{
+        int ret;
+
+        ret = i2c_add_driver(&cs42l51_i2c_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "%s: can't add i2c driver\n", __func__);
+                return ret;
+        }
+        return 0;
+}
+module_init(cs42l51_init);
+
+static void __exit cs42l51_exit(void)
+{
+        i2c_del_driver(&cs42l51_i2c_driver);
+}
+module_exit(cs42l51_exit);
+
+MODULE_AUTHOR("Arnaud Patard <apatard@mandriva.com>");
+MODULE_DESCRIPTION("Cirrus Logic CS42L51 ALSA SoC Codec Driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/cs42l51.h b/sound/soc/codecs/cs42l51.h
new file mode 100644
index 000000000000..8f0bd9786ad2
--- /dev/null
+++ b/sound/soc/codecs/cs42l51.h
@@ -0,0 +1,163 @@
+/*
+ * cs42l51.h
+ *
+ * ASoC Driver for Cirrus Logic CS42L51 codecs
+ *
+ * Copyright (c) 2010 Arnaud Patard <apatard@mandriva.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.
+ *
+ * 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.
+ */
+#ifndef _CS42L51_H
+#define _CS42L51_H
+
+#define CS42L51_CHIP_ID                 0x1B
+#define CS42L51_CHIP_REV_A              0x00
+#define CS42L51_CHIP_REV_B              0x01
+
+#define CS42L51_CHIP_REV_ID             0x01
+#define CS42L51_MK_CHIP_REV(a, b)       ((a)<<3|(b))
+
+#define CS42L51_POWER_CTL1              0x02
+#define CS42L51_POWER_CTL1_PDN_DACB     (1<<6)
+#define CS42L51_POWER_CTL1_PDN_DACA     (1<<5)
+#define CS42L51_POWER_CTL1_PDN_PGAB     (1<<4)
+#define CS42L51_POWER_CTL1_PDN_PGAA     (1<<3)
+#define CS42L51_POWER_CTL1_PDN_ADCB     (1<<2)
+#define CS42L51_POWER_CTL1_PDN_ADCA     (1<<1)
+#define CS42L51_POWER_CTL1_PDN          (1<<0)
+
+#define CS42L51_MIC_POWER_CTL           0x03
+#define CS42L51_MIC_POWER_CTL_AUTO      (1<<7)
+#define CS42L51_MIC_POWER_CTL_SPEED(x)  (((x)&3)<<5)
+#define CS42L51_QSM_MODE                3
+#define CS42L51_HSM_MODE                2
+#define CS42L51_SSM_MODE                1
+#define CS42L51_DSM_MODE                0
+#define CS42L51_MIC_POWER_CTL_3ST_SP    (1<<4)
+#define CS42L51_MIC_POWER_CTL_PDN_MICB  (1<<3)
+#define CS42L51_MIC_POWER_CTL_PDN_MICA  (1<<2)
+#define CS42L51_MIC_POWER_CTL_PDN_BIAS  (1<<1)
+#define CS42L51_MIC_POWER_CTL_MCLK_DIV2 (1<<0)
+
+#define CS42L51_INTF_CTL                0x04
+#define CS42L51_INTF_CTL_LOOPBACK       (1<<7)
+#define CS42L51_INTF_CTL_MASTER         (1<<6)
+#define CS42L51_INTF_CTL_DAC_FORMAT(x)  (((x)&7)<<3)
+#define CS42L51_DAC_DIF_LJ24            0x00
+#define CS42L51_DAC_DIF_I2S             0x01
+#define CS42L51_DAC_DIF_RJ24            0x02
+#define CS42L51_DAC_DIF_RJ20            0x03
+#define CS42L51_DAC_DIF_RJ18            0x04
+#define CS42L51_DAC_DIF_RJ16            0x05
+#define CS42L51_INTF_CTL_ADC_I2S        (1<<2)
+#define CS42L51_INTF_CTL_DIGMIX         (1<<1)
+#define CS42L51_INTF_CTL_MICMIX         (1<<0)
+
+#define CS42L51_MIC_CTL                 0x05
+#define CS42L51_MIC_CTL_ADC_SNGVOL      (1<<7)
+#define CS42L51_MIC_CTL_ADCD_DBOOST     (1<<6)
+#define CS42L51_MIC_CTL_ADCA_DBOOST     (1<<5)
+#define CS42L51_MIC_CTL_MICBIAS_SEL     (1<<4)
+#define CS42L51_MIC_CTL_MICBIAS_LVL(x)  (((x)&3)<<2)
+#define CS42L51_MIC_CTL_MICB_BOOST      (1<<1)
+#define CS42L51_MIC_CTL_MICA_BOOST      (1<<0)
+
+#define CS42L51_ADC_CTL                 0x06
+#define CS42L51_ADC_CTL_ADCB_HPFEN      (1<<7)
+#define CS42L51_ADC_CTL_ADCB_HPFRZ      (1<<6)
+#define CS42L51_ADC_CTL_ADCA_HPFEN      (1<<5)
+#define CS42L51_ADC_CTL_ADCA_HPFRZ      (1<<4)
+#define CS42L51_ADC_CTL_SOFTB           (1<<3)
+#define CS42L51_ADC_CTL_ZCROSSB         (1<<2)
+#define CS42L51_ADC_CTL_SOFTA           (1<<1)
+#define CS42L51_ADC_CTL_ZCROSSA         (1<<0)
+
+#define CS42L51_ADC_INPUT               0x07
+#define CS42L51_ADC_INPUT_AINB_MUX(x)   (((x)&3)<<6)
+#define CS42L51_ADC_INPUT_AINA_MUX(x)   (((x)&3)<<4)
+#define CS42L51_ADC_INPUT_INV_ADCB      (1<<3)
+#define CS42L51_ADC_INPUT_INV_ADCA      (1<<2)
+#define CS42L51_ADC_INPUT_ADCB_MUTE     (1<<1)
+#define CS42L51_ADC_INPUT_ADCA_MUTE     (1<<0)
+
+#define CS42L51_DAC_OUT_CTL             0x08
+#define CS42L51_DAC_OUT_CTL_HP_GAIN(x)  (((x)&7)<<5)
+#define CS42L51_DAC_OUT_CTL_DAC_SNGVOL  (1<<4)
+#define CS42L51_DAC_OUT_CTL_INV_PCMB    (1<<3)
+#define CS42L51_DAC_OUT_CTL_INV_PCMA    (1<<2)
+#define CS42L51_DAC_OUT_CTL_DACB_MUTE   (1<<1)
+#define CS42L51_DAC_OUT_CTL_DACA_MUTE   (1<<0)
+
+#define CS42L51_DAC_CTL                 0x09
+#define CS42L51_DAC_CTL_DATA_SEL(x)     (((x)&3)<<6)
+#define CS42L51_DAC_CTL_FREEZE          (1<<5)
+#define CS42L51_DAC_CTL_DEEMPH          (1<<3)
+#define CS42L51_DAC_CTL_AMUTE           (1<<2)
+#define CS42L51_DAC_CTL_DACSZ(x)        (((x)&3)<<0)
+
+#define CS42L51_ALC_PGA_CTL             0x0A
+#define CS42L51_ALC_PGB_CTL             0x0B
+#define CS42L51_ALC_PGX_ALCX_SRDIS      (1<<7)
+#define CS42L51_ALC_PGX_ALCX_ZCDIS      (1<<6)
+#define CS42L51_ALC_PGX_PGX_VOL(x)      (((x)&0x1f)<<0)
+
+#define CS42L51_ADCA_ATT                0x0C
+#define CS42L51_ADCB_ATT                0x0D
+
+#define CS42L51_ADCA_VOL                0x0E
+#define CS42L51_ADCB_VOL                0x0F
+#define CS42L51_PCMA_VOL                0x10
+#define CS42L51_PCMB_VOL                0x11
+#define CS42L51_MIX_MUTE_ADCMIX         (1<<7)
+#define CS42L51_MIX_VOLUME(x)           (((x)&0x7f)<<0)
+
+#define CS42L51_BEEP_FREQ               0x12
+#define CS42L51_BEEP_VOL                0x13
+#define CS42L51_BEEP_CONF               0x14
+
+#define CS42L51_TONE_CTL                0x15
+#define CS42L51_TONE_CTL_TREB(x)        (((x)&0xf)<<4)
+#define CS42L51_TONE_CTL_BASS(x)        (((x)&0xf)<<0)
+
+#define CS42L51_AOUTA_VOL               0x16
+#define CS42L51_AOUTB_VOL               0x17
+#define CS42L51_PCM_MIXER               0x18
+#define CS42L51_LIMIT_THRES_DIS         0x19
+#define CS42L51_LIMIT_REL               0x1A
+#define CS42L51_LIMIT_ATT               0x1B
+#define CS42L51_ALC_EN                  0x1C
+#define CS42L51_ALC_REL                 0x1D
+#define CS42L51_ALC_THRES               0x1E
+#define CS42L51_NOISE_CONF              0x1F
+
+#define CS42L51_STATUS                  0x20
+#define CS42L51_STATUS_SP_CLKERR        (1<<6)
+#define CS42L51_STATUS_SPEA_OVFL        (1<<5)
+#define CS42L51_STATUS_SPEB_OVFL        (1<<4)
+#define CS42L51_STATUS_PCMA_OVFL        (1<<3)
+#define CS42L51_STATUS_PCMB_OVFL        (1<<2)
+#define CS42L51_STATUS_ADCA_OVFL        (1<<1)
+#define CS42L51_STATUS_ADCB_OVFL        (1<<0)
+
+#define CS42L51_CHARGE_FREQ             0x21
+
+#define CS42L51_FIRSTREG        0x01
+/*
+ * Hack: with register 0x21, it makes 33 registers. Looks like someone in the
+ * i2c layer doesn't like i2c smbus block read of 33 regs. Workaround by using
+ * 32 regs
+ */
+#define CS42L51_LASTREG         0x20
+#define CS42L51_NUMREGS         (CS42L51_LASTREG - CS42L51_FIRSTREG + 1)
+
+extern struct snd_soc_dai cs42l51_dai;
+extern struct snd_soc_codec_device soc_codec_device_cs42l51;
+#endif
diff --git a/sound/soc/codecs/da7210.c b/sound/soc/codecs/da7210.c
index 75af2d6e0e78..3c51d6a57523 100644
--- a/sound/soc/codecs/da7210.c
+++ b/sound/soc/codecs/da7210.c
@@ -15,23 +15,15 @@
  * option) any later version.
  */
 
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
 #include <linux/delay.h>
-#include <linux/pm.h>
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
-#include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
-#include <sound/soc.h>
 #include <sound/soc-dapm.h>
-#include <sound/tlv.h>
 #include <sound/initval.h>
-#include <asm/div64.h>
+#include <sound/tlv.h>
 
 #include "da7210.h"
 
@@ -145,6 +137,29 @@
 
 #define DA7210_VERSION "0.0.1"
 
+/*
+ * Playback Volume
+ *
+ * max          : 0x3F (+15.0 dB)
+ *                 (1.5 dB step)
+ * min          : 0x11 (-54.0 dB)
+ * mute         : 0x10
+ * reserved     : 0x00 - 0x0F
+ *
+ * ** FIXME **
+ *
+ * Reserved area are considered as "mute".
+ * -> min = -79.5 dB
+ */
+static const DECLARE_TLV_DB_SCALE(hp_out_tlv, -7950, 150, 1);
+
+static const struct snd_kcontrol_new da7210_snd_controls[] = {
+
+        SOC_DOUBLE_R_TLV("HeadPhone Playback Volume",
+                         DA7210_HP_L_VOL, DA7210_HP_R_VOL,
+                         0, 0x3F, 0, hp_out_tlv),
+};
+
 /* Codec private data */
 struct da7210_priv {
         struct snd_soc_codec codec;
@@ -227,10 +242,6 @@ static int da7210_startup(struct snd_pcm_substream *substream,
         struct snd_soc_codec *codec = dai->codec;
 
         if (is_play) {
-                /* PlayBack Volume 40 */
-                snd_soc_update_bits(codec, DA7210_HP_L_VOL, 0x3F, 40);
-                snd_soc_update_bits(codec, DA7210_HP_R_VOL, 0x3F, 40);
-
                 /* Enable Out */
                 snd_soc_update_bits(codec, DA7210_OUTMIX_L, 0x1F, 0x10);
                 snd_soc_update_bits(codec, DA7210_OUTMIX_R, 0x1F, 0x10);
@@ -488,7 +499,7 @@ static int da7210_init(struct da7210_priv *da7210)
         ret = snd_soc_register_dai(&da7210_dai);
         if (ret) {
                 dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
-                goto init_err;
+                goto codec_err;
         }
 
         /* FIXME
@@ -574,6 +585,8 @@ static int da7210_init(struct da7210_priv *da7210)
 
         return ret;
 
+codec_err:
+        snd_soc_unregister_codec(codec);
 init_err:
         kfree(codec->reg_cache);
         codec->reg_cache = NULL;
@@ -601,8 +614,10 @@ static int __devinit da7210_i2c_probe(struct i2c_client *i2c,
         codec->control_data = i2c;
 
         ret = da7210_init(da7210);
-        if (ret < 0)
+        if (ret < 0) {
                 pr_err("Failed to initialise da7210 audio codec\n");
+                kfree(da7210);
+        }
 
         return ret;
 }
@@ -656,6 +671,9 @@ static int da7210_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto pcm_err;
 
+        snd_soc_add_controls(da7210_codec, da7210_snd_controls,
+                             ARRAY_SIZE(da7210_snd_controls));
+
         dev_info(&pdev->dev, "DA7210 Audio Codec %s\n", DA7210_VERSION);
 
 pcm_err:
diff --git a/sound/soc/codecs/jz4740.c b/sound/soc/codecs/jz4740.c
new file mode 100644
index 000000000000..66557de1e4fe
--- /dev/null
+++ b/sound/soc/codecs/jz4740.c
@@ -0,0 +1,511 @@
+/*
+ * Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * 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.
+ *
+ *  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.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#include <linux/delay.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/initval.h>
+#include <sound/soc-dapm.h>
+#include <sound/soc.h>
+
+#define JZ4740_REG_CODEC_1 0x0
+#define JZ4740_REG_CODEC_2 0x1
+
+#define JZ4740_CODEC_1_LINE_ENABLE BIT(29)
+#define JZ4740_CODEC_1_MIC_ENABLE BIT(28)
+#define JZ4740_CODEC_1_SW1_ENABLE BIT(27)
+#define JZ4740_CODEC_1_ADC_ENABLE BIT(26)
+#define JZ4740_CODEC_1_SW2_ENABLE BIT(25)
+#define JZ4740_CODEC_1_DAC_ENABLE BIT(24)
+#define JZ4740_CODEC_1_VREF_DISABLE BIT(20)
+#define JZ4740_CODEC_1_VREF_AMP_DISABLE BIT(19)
+#define JZ4740_CODEC_1_VREF_PULLDOWN BIT(18)
+#define JZ4740_CODEC_1_VREF_LOW_CURRENT BIT(17)
+#define JZ4740_CODEC_1_VREF_HIGH_CURRENT BIT(16)
+#define JZ4740_CODEC_1_HEADPHONE_DISABLE BIT(14)
+#define JZ4740_CODEC_1_HEADPHONE_AMP_CHANGE_ANY BIT(13)
+#define JZ4740_CODEC_1_HEADPHONE_CHARGE BIT(12)
+#define JZ4740_CODEC_1_HEADPHONE_PULLDOWN (BIT(11) | BIT(10))
+#define JZ4740_CODEC_1_HEADPHONE_POWERDOWN_M BIT(9)
+#define JZ4740_CODEC_1_HEADPHONE_POWERDOWN BIT(8)
+#define JZ4740_CODEC_1_SUSPEND BIT(1)
+#define JZ4740_CODEC_1_RESET BIT(0)
+
+#define JZ4740_CODEC_1_LINE_ENABLE_OFFSET 29
+#define JZ4740_CODEC_1_MIC_ENABLE_OFFSET 28
+#define JZ4740_CODEC_1_SW1_ENABLE_OFFSET 27
+#define JZ4740_CODEC_1_ADC_ENABLE_OFFSET 26
+#define JZ4740_CODEC_1_SW2_ENABLE_OFFSET 25
+#define JZ4740_CODEC_1_DAC_ENABLE_OFFSET 24
+#define JZ4740_CODEC_1_HEADPHONE_DISABLE_OFFSET 14
+#define JZ4740_CODEC_1_HEADPHONE_POWERDOWN_OFFSET 8
+
+#define JZ4740_CODEC_2_INPUT_VOLUME_MASK                0x1f0000
+#define JZ4740_CODEC_2_SAMPLE_RATE_MASK                 0x000f00
+#define JZ4740_CODEC_2_MIC_BOOST_GAIN_MASK              0x000030
+#define JZ4740_CODEC_2_HEADPHONE_VOLUME_MASK    0x000003
+
+#define JZ4740_CODEC_2_INPUT_VOLUME_OFFSET              16
+#define JZ4740_CODEC_2_SAMPLE_RATE_OFFSET                8
+#define JZ4740_CODEC_2_MIC_BOOST_GAIN_OFFSET     4
+#define JZ4740_CODEC_2_HEADPHONE_VOLUME_OFFSET   0
+
+static const uint32_t jz4740_codec_regs[] = {
+        0x021b2302, 0x00170803,
+};
+
+struct jz4740_codec {
+        void __iomem *base;
+        struct resource *mem;
+
+        uint32_t reg_cache[2];
+        struct snd_soc_codec codec;
+};
+
+static inline struct jz4740_codec *codec_to_jz4740(struct snd_soc_codec *codec)
+{
+        return container_of(codec, struct jz4740_codec, codec);
+}
+
+static unsigned int jz4740_codec_read(struct snd_soc_codec *codec,
+        unsigned int reg)
+{
+        struct jz4740_codec *jz4740_codec = codec_to_jz4740(codec);
+        return readl(jz4740_codec->base + (reg << 2));
+}
+
+static int jz4740_codec_write(struct snd_soc_codec *codec, unsigned int reg,
+        unsigned int val)
+{
+        struct jz4740_codec *jz4740_codec = codec_to_jz4740(codec);
+
+        jz4740_codec->reg_cache[reg] = val;
+        writel(val, jz4740_codec->base + (reg << 2));
+
+        return 0;
+}
+
+static const struct snd_kcontrol_new jz4740_codec_controls[] = {
+        SOC_SINGLE("Master Playback Volume", JZ4740_REG_CODEC_2,
+                        JZ4740_CODEC_2_HEADPHONE_VOLUME_OFFSET, 3, 0),
+        SOC_SINGLE("Master Capture Volume", JZ4740_REG_CODEC_2,
+                        JZ4740_CODEC_2_INPUT_VOLUME_OFFSET, 31, 0),
+        SOC_SINGLE("Master Playback Switch", JZ4740_REG_CODEC_1,
+                        JZ4740_CODEC_1_HEADPHONE_DISABLE_OFFSET, 1, 1),
+        SOC_SINGLE("Mic Capture Volume", JZ4740_REG_CODEC_2,
+                        JZ4740_CODEC_2_MIC_BOOST_GAIN_OFFSET, 3, 0),
+};
+
+static const struct snd_kcontrol_new jz4740_codec_output_controls[] = {
+        SOC_DAPM_SINGLE("Bypass Switch", JZ4740_REG_CODEC_1,
+                        JZ4740_CODEC_1_SW1_ENABLE_OFFSET, 1, 0),
+        SOC_DAPM_SINGLE("DAC Switch", JZ4740_REG_CODEC_1,
+                        JZ4740_CODEC_1_SW2_ENABLE_OFFSET, 1, 0),
+};
+
+static const struct snd_kcontrol_new jz4740_codec_input_controls[] = {
+        SOC_DAPM_SINGLE("Line Capture Switch", JZ4740_REG_CODEC_1,
+                        JZ4740_CODEC_1_LINE_ENABLE_OFFSET, 1, 0),
+        SOC_DAPM_SINGLE("Mic Capture Switch", JZ4740_REG_CODEC_1,
+                        JZ4740_CODEC_1_MIC_ENABLE_OFFSET, 1, 0),
+};
+
+static const struct snd_soc_dapm_widget jz4740_codec_dapm_widgets[] = {
+        SND_SOC_DAPM_ADC("ADC", "Capture", JZ4740_REG_CODEC_1,
+                        JZ4740_CODEC_1_ADC_ENABLE_OFFSET, 0),
+        SND_SOC_DAPM_DAC("DAC", "Playback", JZ4740_REG_CODEC_1,
+                        JZ4740_CODEC_1_DAC_ENABLE_OFFSET, 0),
+
+        SND_SOC_DAPM_MIXER("Output Mixer", JZ4740_REG_CODEC_1,
+                        JZ4740_CODEC_1_HEADPHONE_POWERDOWN_OFFSET, 1,
+                        jz4740_codec_output_controls,
+                        ARRAY_SIZE(jz4740_codec_output_controls)),
+
+        SND_SOC_DAPM_MIXER_NAMED_CTL("Input Mixer", SND_SOC_NOPM, 0, 0,
+                        jz4740_codec_input_controls,
+                        ARRAY_SIZE(jz4740_codec_input_controls)),
+        SND_SOC_DAPM_MIXER("Line Input", SND_SOC_NOPM, 0, 0, NULL, 0),
+
+        SND_SOC_DAPM_OUTPUT("LOUT"),
+        SND_SOC_DAPM_OUTPUT("ROUT"),
+
+        SND_SOC_DAPM_INPUT("MIC"),
+        SND_SOC_DAPM_INPUT("LIN"),
+        SND_SOC_DAPM_INPUT("RIN"),
+};
+
+static const struct snd_soc_dapm_route jz4740_codec_dapm_routes[] = {
+        {"Line Input", NULL, "LIN"},
+        {"Line Input", NULL, "RIN"},
+
+        {"Input Mixer", "Line Capture Switch", "Line Input"},
+        {"Input Mixer", "Mic Capture Switch", "MIC"},
+
+        {"ADC", NULL, "Input Mixer"},
+
+        {"Output Mixer", "Bypass Switch", "Input Mixer"},
+        {"Output Mixer", "DAC Switch", "DAC"},
+
+        {"LOUT", NULL, "Output Mixer"},
+        {"ROUT", NULL, "Output Mixer"},
+};
+
+static int jz4740_codec_hw_params(struct snd_pcm_substream *substream,
+        struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
+{
+        uint32_t val;
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        switch (params_rate(params)) {
+        case 8000:
+                val = 0;
+                break;
+        case 11025:
+                val = 1;
+                break;
+        case 12000:
+                val = 2;
+                break;
+        case 16000:
+                val = 3;
+                break;
+        case 22050:
+                val = 4;
+                break;
+        case 24000:
+                val = 5;
+                break;
+        case 32000:
+                val = 6;
+                break;
+        case 44100:
+                val = 7;
+                break;
+        case 48000:
+                val = 8;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        val <<= JZ4740_CODEC_2_SAMPLE_RATE_OFFSET;
+
+        snd_soc_update_bits(codec, JZ4740_REG_CODEC_2,
+                                JZ4740_CODEC_2_SAMPLE_RATE_MASK, val);
+
+        return 0;
+}
+
+static struct snd_soc_dai_ops jz4740_codec_dai_ops = {
+        .hw_params = jz4740_codec_hw_params,
+};
+
+struct snd_soc_dai jz4740_codec_dai = {
+        .name = "jz4740",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8,
+        },
+        .capture = {
+                .stream_name = "Capture",
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+                .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8,
+        },
+        .ops = &jz4740_codec_dai_ops,
+        .symmetric_rates = 1,
+};
+EXPORT_SYMBOL_GPL(jz4740_codec_dai);
+
+static void jz4740_codec_wakeup(struct snd_soc_codec *codec)
+{
+        int i;
+        uint32_t *cache = codec->reg_cache;
+
+        snd_soc_update_bits(codec, JZ4740_REG_CODEC_1,
+                JZ4740_CODEC_1_RESET, JZ4740_CODEC_1_RESET);
+        udelay(2);
+
+        snd_soc_update_bits(codec, JZ4740_REG_CODEC_1,
+                JZ4740_CODEC_1_SUSPEND | JZ4740_CODEC_1_RESET, 0);
+
+        for (i = 0; i < ARRAY_SIZE(jz4740_codec_regs); ++i)
+                jz4740_codec_write(codec, i, cache[i]);
+}
+
+static int jz4740_codec_set_bias_level(struct snd_soc_codec *codec,
+        enum snd_soc_bias_level level)
+{
+        unsigned int mask;
+        unsigned int value;
+
+        switch (level) {
+        case SND_SOC_BIAS_ON:
+                break;
+        case SND_SOC_BIAS_PREPARE:
+                mask = JZ4740_CODEC_1_VREF_DISABLE |
+                                JZ4740_CODEC_1_VREF_AMP_DISABLE |
+                                JZ4740_CODEC_1_HEADPHONE_POWERDOWN_M;
+                value = 0;
+
+                snd_soc_update_bits(codec, JZ4740_REG_CODEC_1, mask, value);
+                break;
+        case SND_SOC_BIAS_STANDBY:
+                /* The only way to clear the suspend flag is to reset the codec */
+                if (codec->bias_level == SND_SOC_BIAS_OFF)
+                        jz4740_codec_wakeup(codec);
+
+                mask = JZ4740_CODEC_1_VREF_DISABLE |
+                        JZ4740_CODEC_1_VREF_AMP_DISABLE |
+                        JZ4740_CODEC_1_HEADPHONE_POWERDOWN_M;
+                value = JZ4740_CODEC_1_VREF_DISABLE |
+                        JZ4740_CODEC_1_VREF_AMP_DISABLE |
+                        JZ4740_CODEC_1_HEADPHONE_POWERDOWN_M;
+
+                snd_soc_update_bits(codec, JZ4740_REG_CODEC_1, mask, value);
+                break;
+        case SND_SOC_BIAS_OFF:
+                mask = JZ4740_CODEC_1_SUSPEND;
+                value = JZ4740_CODEC_1_SUSPEND;
+
+                snd_soc_update_bits(codec, JZ4740_REG_CODEC_1, mask, value);
+                break;
+        default:
+                break;
+        }
+
+        codec->bias_level = level;
+
+        return 0;
+}
+
+static struct snd_soc_codec *jz4740_codec_codec;
+
+static int jz4740_codec_dev_probe(struct platform_device *pdev)
+{
+        int ret;
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = jz4740_codec_codec;
+
+        BUG_ON(!codec);
+
+        socdev->card->codec = codec;
+
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to create pcms: %d\n", ret);
+                return ret;
+        }
+
+        snd_soc_add_controls(codec, jz4740_codec_controls,
+                ARRAY_SIZE(jz4740_codec_controls));
+
+        snd_soc_dapm_new_controls(codec, jz4740_codec_dapm_widgets,
+                ARRAY_SIZE(jz4740_codec_dapm_widgets));
+
+        snd_soc_dapm_add_routes(codec, jz4740_codec_dapm_routes,
+                ARRAY_SIZE(jz4740_codec_dapm_routes));
+
+        snd_soc_dapm_new_widgets(codec);
+
+        return 0;
+}
+
+static int jz4740_codec_dev_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+
+static int jz4740_codec_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        return jz4740_codec_set_bias_level(codec, SND_SOC_BIAS_OFF);
+}
+
+static int jz4740_codec_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+
+        return jz4740_codec_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+}
+
+#else
+#define jz4740_codec_suspend NULL
+#define jz4740_codec_resume NULL
+#endif
+
+struct snd_soc_codec_device soc_codec_dev_jz4740_codec = {
+        .probe = jz4740_codec_dev_probe,
+        .remove = jz4740_codec_dev_remove,
+        .suspend = jz4740_codec_suspend,
+        .resume = jz4740_codec_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_jz4740_codec);
+
+static int __devinit jz4740_codec_probe(struct platform_device *pdev)
+{
+        int ret;
+        struct jz4740_codec *jz4740_codec;
+        struct snd_soc_codec *codec;
+        struct resource *mem;
+
+        jz4740_codec = kzalloc(sizeof(*jz4740_codec), GFP_KERNEL);
+        if (!jz4740_codec)
+                return -ENOMEM;
+
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem) {
+                dev_err(&pdev->dev, "Failed to get mmio memory resource\n");
+                ret = -ENOENT;
+                goto err_free_codec;
+        }
+
+        mem = request_mem_region(mem->start, resource_size(mem), pdev->name);
+        if (!mem) {
+                dev_err(&pdev->dev, "Failed to request mmio memory region\n");
+                ret = -EBUSY;
+                goto err_free_codec;
+        }
+
+        jz4740_codec->base = ioremap(mem->start, resource_size(mem));
+        if (!jz4740_codec->base) {
+                dev_err(&pdev->dev, "Failed to ioremap mmio memory\n");
+                ret = -EBUSY;
+                goto err_release_mem_region;
+        }
+        jz4740_codec->mem = mem;
+
+        jz4740_codec_dai.dev = &pdev->dev;
+
+        codec = &jz4740_codec->codec;
+
+        codec->dev              = &pdev->dev;
+        codec->name             = "jz4740";
+        codec->owner            = THIS_MODULE;
+
+        codec->read             = jz4740_codec_read;
+        codec->write            = jz4740_codec_write;
+        codec->set_bias_level   = jz4740_codec_set_bias_level;
+        codec->bias_level       = SND_SOC_BIAS_OFF;
+
+        codec->dai              = &jz4740_codec_dai;
+        codec->num_dai          = 1;
+
+        codec->reg_cache        = jz4740_codec->reg_cache;
+        codec->reg_cache_size   = 2;
+        memcpy(codec->reg_cache, jz4740_codec_regs, sizeof(jz4740_codec_regs));
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        jz4740_codec_codec = codec;
+
+        snd_soc_update_bits(codec, JZ4740_REG_CODEC_1,
+                        JZ4740_CODEC_1_SW2_ENABLE, JZ4740_CODEC_1_SW2_ENABLE);
+
+        platform_set_drvdata(pdev, jz4740_codec);
+
+        ret = snd_soc_register_codec(codec);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to register codec\n");
+                goto err_iounmap;
+        }
+
+        ret = snd_soc_register_dai(&jz4740_codec_dai);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to register codec dai\n");
+                goto err_unregister_codec;
+        }
+
+        jz4740_codec_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+
+        return 0;
+
+err_unregister_codec:
+        snd_soc_unregister_codec(codec);
+err_iounmap:
+        iounmap(jz4740_codec->base);
+err_release_mem_region:
+        release_mem_region(mem->start, resource_size(mem));
+err_free_codec:
+        kfree(jz4740_codec);
+
+        return ret;
+}
+
+static int __devexit jz4740_codec_remove(struct platform_device *pdev)
+{
+        struct jz4740_codec *jz4740_codec = platform_get_drvdata(pdev);
+        struct resource *mem = jz4740_codec->mem;
+
+        snd_soc_unregister_dai(&jz4740_codec_dai);
+        snd_soc_unregister_codec(&jz4740_codec->codec);
+
+        iounmap(jz4740_codec->base);
+        release_mem_region(mem->start, resource_size(mem));
+
+        platform_set_drvdata(pdev, NULL);
+        kfree(jz4740_codec);
+
+        return 0;
+}
+
+static struct platform_driver jz4740_codec_driver = {
+        .probe = jz4740_codec_probe,
+        .remove = __devexit_p(jz4740_codec_remove),
+        .driver = {
+                .name = "jz4740-codec",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init jz4740_codec_init(void)
+{
+        return platform_driver_register(&jz4740_codec_driver);
+}
+module_init(jz4740_codec_init);
+
+static void __exit jz4740_codec_exit(void)
+{
+        platform_driver_unregister(&jz4740_codec_driver);
+}
+module_exit(jz4740_codec_exit);
+
+MODULE_DESCRIPTION("JZ4740 SoC internal codec driver");
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:jz4740-codec");
diff --git a/sound/soc/codecs/jz4740.h b/sound/soc/codecs/jz4740.h
new file mode 100644
index 000000000000..b5a0691be763
--- /dev/null
+++ b/sound/soc/codecs/jz4740.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2009, Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * 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.
+ *
+ *  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 __SND_SOC_CODECS_JZ4740_CODEC_H__
+#define __SND_SOC_CODECS_JZ4740_CODEC_H__
+
+extern struct snd_soc_dai jz4740_codec_dai;
+extern struct snd_soc_codec_device soc_codec_dev_jz4740_codec;
+
+#endif
diff --git a/sound/soc/codecs/spdif_transciever.c b/sound/soc/codecs/spdif_transciever.c
index a63191141052..9119836051a4 100644
--- a/sound/soc/codecs/spdif_transciever.c
+++ b/sound/soc/codecs/spdif_transciever.c
@@ -16,8 +16,10 @@
 
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
 #include <sound/soc.h>
 #include <sound/pcm.h>
+#include <sound/initval.h>
 
 #include "spdif_transciever.h"
 
@@ -26,6 +28,48 @@ MODULE_LICENSE("GPL");
 #define STUB_RATES      SNDRV_PCM_RATE_8000_96000
 #define STUB_FORMATS    SNDRV_PCM_FMTBIT_S16_LE
 
+static struct snd_soc_codec *spdif_dit_codec;
+
+static int spdif_dit_codec_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret;
+
+        if (spdif_dit_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = spdif_dit_codec;
+        codec = spdif_dit_codec;
+
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                dev_err(codec->dev, "failed to create pcms: %d\n", ret);
+                goto err_create_pcms;
+        }
+
+        return 0;
+
+err_create_pcms:
+        return ret;
+}
+
+static int spdif_dit_codec_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_spdif_dit = {
+        .probe          = spdif_dit_codec_probe,
+        .remove         = spdif_dit_codec_remove,
+}; EXPORT_SYMBOL_GPL(soc_codec_dev_spdif_dit);
+
 struct snd_soc_dai dit_stub_dai = {
         .name           = "DIT",
         .playback       = {
@@ -40,13 +84,61 @@ EXPORT_SYMBOL_GPL(dit_stub_dai);
 
 static int spdif_dit_probe(struct platform_device *pdev)
 {
+        struct snd_soc_codec *codec;
+        int ret;
+
+        if (spdif_dit_codec) {
+                dev_err(&pdev->dev, "Another Codec is registered\n");
+                ret = -EINVAL;
+                goto err_reg_codec;
+        }
+
+        codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
+        if (codec == NULL)
+                return -ENOMEM;
+
+        codec->dev = &pdev->dev;
+
+        mutex_init(&codec->mutex);
+
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        codec->name = "spdif-dit";
+        codec->owner = THIS_MODULE;
+        codec->dai = &dit_stub_dai;
+        codec->num_dai = 1;
+
+        spdif_dit_codec = codec;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                goto err_reg_codec;
+        }
+
         dit_stub_dai.dev = &pdev->dev;
-        return snd_soc_register_dai(&dit_stub_dai);
+        ret = snd_soc_register_dai(&dit_stub_dai);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to register dai: %d\n", ret);
+                goto err_reg_dai;
+        }
+
+        return 0;
+
+err_reg_dai:
+        snd_soc_unregister_codec(codec);
+err_reg_codec:
+        kfree(spdif_dit_codec);
+        return ret;
 }
 
 static int spdif_dit_remove(struct platform_device *pdev)
 {
         snd_soc_unregister_dai(&dit_stub_dai);
+        snd_soc_unregister_codec(spdif_dit_codec);
+        kfree(spdif_dit_codec);
+        spdif_dit_codec = NULL;
         return 0;
 }
 
diff --git a/sound/soc/codecs/spdif_transciever.h b/sound/soc/codecs/spdif_transciever.h
index 296f2eb6c4ef..1e102124f546 100644
--- a/sound/soc/codecs/spdif_transciever.h
+++ b/sound/soc/codecs/spdif_transciever.h
@@ -12,6 +12,7 @@
 #ifndef CODEC_STUBS_H
 #define CODEC_STUBS_H
 
+extern struct snd_soc_codec_device soc_codec_dev_spdif_dit;
 extern struct snd_soc_dai dit_stub_dai;
 
 #endif /* CODEC_STUBS_H */
diff --git a/sound/soc/codecs/tlv320aic23.c b/sound/soc/codecs/tlv320aic23.c
index b0bae3508b29..0a4b0fef3355 100644
--- a/sound/soc/codecs/tlv320aic23.c
+++ b/sound/soc/codecs/tlv320aic23.c
@@ -560,13 +560,16 @@ static int tlv320aic23_set_bias_level(struct snd_soc_codec *codec,
         switch (level) {
         case SND_SOC_BIAS_ON:
                 /* vref/mid, osc on, dac unmute */
+                reg &= ~(TLV320AIC23_DEVICE_PWR_OFF | TLV320AIC23_OSC_OFF | \
+                        TLV320AIC23_DAC_OFF);
                 tlv320aic23_write(codec, TLV320AIC23_PWR, reg);
                 break;
         case SND_SOC_BIAS_PREPARE:
                 break;
         case SND_SOC_BIAS_STANDBY:
                 /* everything off except vref/vmid, */
-                tlv320aic23_write(codec, TLV320AIC23_PWR, reg | 0x0040);
+                tlv320aic23_write(codec, TLV320AIC23_PWR, reg | \
+                        TLV320AIC23_CLK_OFF);
                 break;
         case SND_SOC_BIAS_OFF:
                 /* everything off, dac mute, inactive */
@@ -615,7 +618,6 @@ static int tlv320aic23_suspend(struct platform_device *pdev,
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
         struct snd_soc_codec *codec = socdev->card->codec;
 
-        tlv320aic23_write(codec, TLV320AIC23_ACTIVE, 0x0);
         tlv320aic23_set_bias_level(codec, SND_SOC_BIAS_OFF);
 
         return 0;
@@ -632,7 +634,6 @@ static int tlv320aic23_resume(struct platform_device *pdev)
                 u16 val = tlv320aic23_read_reg_cache(codec, reg);
                 tlv320aic23_write(codec, reg, val);
         }
-
         tlv320aic23_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
         return 0;
diff --git a/sound/soc/codecs/tlv320dac33.c b/sound/soc/codecs/tlv320dac33.c
index 65adc77eada1..8651b01ed223 100644
--- a/sound/soc/codecs/tlv320dac33.c
+++ b/sound/soc/codecs/tlv320dac33.c
@@ -49,8 +49,6 @@
 
 #define NSAMPLE_MAX             5700
 
-#define LATENCY_TIME_MS         20
-
 #define MODE7_LTHR              10
 #define MODE7_UTHR              (DAC33_BUFFER_SIZE_SAMPLES - 10)
 
@@ -62,6 +60,9 @@
 #define US_TO_SAMPLES(rate, us) \
         (rate / (1000000 / us))
 
+#define UTHR_FROM_PERIOD_SIZE(samples, playrate, burstrate) \
+        ((samples * 5000) / ((burstrate * 5000) / (burstrate - playrate)))
+
 static void dac33_calculate_times(struct snd_pcm_substream *substream);
 static int dac33_prepare_chip(struct snd_pcm_substream *substream);
 
@@ -107,6 +108,10 @@ struct tlv320dac33_priv {
                                          * this */
         enum dac33_fifo_modes fifo_mode;/* FIFO mode selection */
         unsigned int nsample;           /* burst read amount from host */
+        int mode1_latency;              /* latency caused by the i2c writes in
+                                         * us */
+        int auto_fifo_config;           /* Configure the FIFO based on the
+                                         * period size */
         u8 burst_bclkdiv;               /* BCLK divider value in burst mode */
         unsigned int burst_rate;        /* Interface speed in Burst modes */
 
@@ -120,6 +125,8 @@ struct tlv320dac33_priv {
                                          * samples */
         unsigned int mode7_us_to_lthr;  /* Time to reach lthr from uthr */
 
+        unsigned int uthr;
+
         enum dac33_state state;
 };
 
@@ -442,6 +449,39 @@ static int dac33_set_nsample(struct snd_kcontrol *kcontrol,
         return ret;
 }
 
+static int dac33_get_uthr(struct snd_kcontrol *kcontrol,
+                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
+
+        ucontrol->value.integer.value[0] = dac33->uthr;
+
+        return 0;
+}
+
+static int dac33_set_uthr(struct snd_kcontrol *kcontrol,
+                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
+        int ret = 0;
+
+        if (dac33->substream)
+                return -EBUSY;
+
+        if (dac33->uthr == ucontrol->value.integer.value[0])
+                return 0;
+
+        if (ucontrol->value.integer.value[0] < (MODE7_LTHR + 10) ||
+            ucontrol->value.integer.value[0] > MODE7_UTHR)
+                ret = -EINVAL;
+        else
+                dac33->uthr = ucontrol->value.integer.value[0];
+
+        return ret;
+}
+
 static int dac33_get_fifo_mode(struct snd_kcontrol *kcontrol,
                          struct snd_ctl_elem_value *ucontrol)
 {
@@ -503,13 +543,18 @@ static const struct snd_kcontrol_new dac33_snd_controls[] = {
                  DAC33_LINEL_TO_LLO_VOL, DAC33_LINER_TO_RLO_VOL, 0, 127, 1),
 };
 
-static const struct snd_kcontrol_new dac33_nsample_snd_controls[] = {
-        SOC_SINGLE_EXT("nSample", 0, 0, 5900, 0,
-                 dac33_get_nsample, dac33_set_nsample),
+static const struct snd_kcontrol_new dac33_mode_snd_controls[] = {
         SOC_ENUM_EXT("FIFO Mode", dac33_fifo_mode_enum,
                  dac33_get_fifo_mode, dac33_set_fifo_mode),
 };
 
+static const struct snd_kcontrol_new dac33_fifo_snd_controls[] = {
+        SOC_SINGLE_EXT("nSample", 0, 0, 5900, 0,
+                dac33_get_nsample, dac33_set_nsample),
+        SOC_SINGLE_EXT("UTHR", 0, 0, MODE7_UTHR, 0,
+                 dac33_get_uthr, dac33_set_uthr),
+};
+
 /* Analog bypass */
 static const struct snd_kcontrol_new dac33_dapm_abypassl_control =
         SOC_DAPM_SINGLE("Switch", DAC33_LINEL_TO_LLO_VOL, 7, 1, 1);
@@ -612,7 +657,7 @@ static inline void dac33_prefill_handler(struct tlv320dac33_priv *dac33)
         switch (dac33->fifo_mode) {
         case DAC33_FIFO_MODE1:
                 dac33_write16(codec, DAC33_NSAMPLE_MSB,
-                        DAC33_THRREG(dac33->nsample + dac33->alarm_threshold));
+                        DAC33_THRREG(dac33->nsample));
 
                 /* Take the timestamps */
                 spin_lock_irq(&dac33->lock);
@@ -761,6 +806,10 @@ static void dac33_shutdown(struct snd_pcm_substream *substream,
         struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
 
         dac33->substream = NULL;
+
+        /* Reset the nSample restrictions */
+        dac33->nsample_min = 0;
+        dac33->nsample_max = NSAMPLE_MAX;
 }
 
 static int dac33_hw_params(struct snd_pcm_substream *substream,
@@ -985,7 +1034,7 @@ static int dac33_prepare_chip(struct snd_pcm_substream *substream)
                  * Configure the threshold levels, and leave 10 sample space
                  * at the bottom, and also at the top of the FIFO
                  */
-                dac33_write16(codec, DAC33_UTHR_MSB, DAC33_THRREG(MODE7_UTHR));
+                dac33_write16(codec, DAC33_UTHR_MSB, DAC33_THRREG(dac33->uthr));
                 dac33_write16(codec, DAC33_LTHR_MSB, DAC33_THRREG(MODE7_LTHR));
                 break;
         default:
@@ -1003,57 +1052,71 @@ static void dac33_calculate_times(struct snd_pcm_substream *substream)
         struct snd_soc_device *socdev = rtd->socdev;
         struct snd_soc_codec *codec = socdev->card->codec;
         struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
+        unsigned int period_size = substream->runtime->period_size;
+        unsigned int rate = substream->runtime->rate;
         unsigned int nsample_limit;
 
         /* In bypass mode we don't need to calculate */
         if (!dac33->fifo_mode)
                 return;
 
-        /* Number of samples (16bit, stereo) in one period */
-        dac33->nsample_min = snd_pcm_lib_period_bytes(substream) / 4;
-
-        /* Number of samples (16bit, stereo) in ALSA buffer */
-        dac33->nsample_max = snd_pcm_lib_buffer_bytes(substream) / 4;
-        /* Subtract one period from the total */
-        dac33->nsample_max -= dac33->nsample_min;
-
-        /* Number of samples for LATENCY_TIME_MS / 2 */
-        dac33->alarm_threshold = substream->runtime->rate /
-                                 (1000 / (LATENCY_TIME_MS / 2));
-
-        /* Find and fix up the lowest nsmaple limit */
-        nsample_limit = substream->runtime->rate / (1000 / LATENCY_TIME_MS);
-
-        if (dac33->nsample_min < nsample_limit)
-                dac33->nsample_min = nsample_limit;
-
-        if (dac33->nsample < dac33->nsample_min)
-                dac33->nsample = dac33->nsample_min;
-
-        /*
-         * Find and fix up the highest nsmaple limit
-         * In order to not overflow the DAC33 buffer substract the
-         * alarm_threshold value from the size of the DAC33 buffer
-         */
-        nsample_limit = DAC33_BUFFER_SIZE_SAMPLES - dac33->alarm_threshold;
-
-        if (dac33->nsample_max > nsample_limit)
-                dac33->nsample_max = nsample_limit;
-
-        if (dac33->nsample > dac33->nsample_max)
-                dac33->nsample = dac33->nsample_max;
-
         switch (dac33->fifo_mode) {
         case DAC33_FIFO_MODE1:
+                /* Number of samples under i2c latency */
+                dac33->alarm_threshold = US_TO_SAMPLES(rate,
+                                                dac33->mode1_latency);
+                if (dac33->auto_fifo_config) {
+                        if (period_size <= dac33->alarm_threshold)
+                                /*
+                                 * Configure nSamaple to number of periods,
+                                 * which covers the latency requironment.
+                                 */
+                                dac33->nsample = period_size *
+                                       ((dac33->alarm_threshold / period_size) +
+                                       (dac33->alarm_threshold % period_size ?
+                                       1 : 0));
+                        else
+                                dac33->nsample = period_size;
+                } else {
+                        /* nSample time shall not be shorter than i2c latency */
+                        dac33->nsample_min = dac33->alarm_threshold;
+                        /*
+                         * nSample should not be bigger than alsa buffer minus
+                         * size of one period to avoid overruns
+                         */
+                        dac33->nsample_max = substream->runtime->buffer_size -
+                                                period_size;
+                        nsample_limit = DAC33_BUFFER_SIZE_SAMPLES -
+                                        dac33->alarm_threshold;
+                        if (dac33->nsample_max > nsample_limit)
+                                dac33->nsample_max = nsample_limit;
+
+                        /* Correct the nSample if it is outside of the ranges */
+                        if (dac33->nsample < dac33->nsample_min)
+                                dac33->nsample = dac33->nsample_min;
+                        if (dac33->nsample > dac33->nsample_max)
+                                dac33->nsample = dac33->nsample_max;
+                }
+
                 dac33->mode1_us_burst = SAMPLES_TO_US(dac33->burst_rate,
                                                       dac33->nsample);
                 dac33->t_stamp1 = 0;
                 dac33->t_stamp2 = 0;
                 break;
         case DAC33_FIFO_MODE7:
+                if (dac33->auto_fifo_config) {
+                        dac33->uthr = UTHR_FROM_PERIOD_SIZE(
+                                        period_size,
+                                        rate,
+                                        dac33->burst_rate) + 9;
+                        if (dac33->uthr > MODE7_UTHR)
+                                dac33->uthr = MODE7_UTHR;
+                        if (dac33->uthr < (MODE7_LTHR + 10))
+                                dac33->uthr = (MODE7_LTHR + 10);
+                }
                 dac33->mode7_us_to_lthr =
-                                        SAMPLES_TO_US(substream->runtime->rate,
-                                                MODE7_UTHR - MODE7_LTHR + 1);
+                                SAMPLES_TO_US(substream->runtime->rate,
+                                        dac33->uthr - MODE7_LTHR + 1);
                 dac33->t_stamp1 = 0;
                 break;
         default:
@@ -1104,7 +1167,7 @@ static snd_pcm_sframes_t dac33_dai_delay(
         struct snd_soc_codec *codec = socdev->card->codec;
         struct tlv320dac33_priv *dac33 = snd_soc_codec_get_drvdata(codec);
         unsigned long long t0, t1, t_now;
-        unsigned int time_delta;
+        unsigned int time_delta, uthr;
         int samples_out, samples_in, samples;
         snd_pcm_sframes_t delay = 0;
 
@@ -1182,6 +1245,7 @@ static snd_pcm_sframes_t dac33_dai_delay(
         case DAC33_FIFO_MODE7:
                 spin_lock(&dac33->lock);
                 t0 = dac33->t_stamp1;
+                uthr = dac33->uthr;
                 spin_unlock(&dac33->lock);
                 t_now = ktime_to_us(ktime_get());
 
@@ -1194,7 +1258,7 @@ static snd_pcm_sframes_t dac33_dai_delay(
                          * Either the timestamps are messed or equal. Report
                          * maximum delay
                          */
-                        delay = MODE7_UTHR;
+                        delay = uthr;
                         goto out;
                 }
 
@@ -1208,8 +1272,8 @@ static snd_pcm_sframes_t dac33_dai_delay(
                                         substream->runtime->rate,
                                         time_delta);
 
-                        if (likely(MODE7_UTHR > samples_out))
-                                delay = MODE7_UTHR - samples_out;
+                        if (likely(uthr > samples_out))
+                                delay = uthr - samples_out;
                         else
                                 delay = 0;
                 } else {
@@ -1227,8 +1291,8 @@ static snd_pcm_sframes_t dac33_dai_delay(
                                         time_delta);
                         delay = MODE7_LTHR + samples_in - samples_out;
 
-                        if (unlikely(delay > MODE7_UTHR))
-                                delay = MODE7_UTHR;
+                        if (unlikely(delay > uthr))
+                                delay = uthr;
                 }
                 break;
         default:
@@ -1347,10 +1411,15 @@ static int dac33_soc_probe(struct platform_device *pdev)
 
         snd_soc_add_controls(codec, dac33_snd_controls,
                              ARRAY_SIZE(dac33_snd_controls));
-        /* Only add the nSample controls, if we have valid IRQ number */
-        if (dac33->irq >= 0)
-                snd_soc_add_controls(codec, dac33_nsample_snd_controls,
-                                     ARRAY_SIZE(dac33_nsample_snd_controls));
+        /* Only add the FIFO controls, if we have valid IRQ number */
+        if (dac33->irq >= 0) {
+                snd_soc_add_controls(codec, dac33_mode_snd_controls,
+                                     ARRAY_SIZE(dac33_mode_snd_controls));
+                /* FIFO usage controls only, if autoio config is not selected */
+                if (!dac33->auto_fifo_config)
+                        snd_soc_add_controls(codec, dac33_fifo_snd_controls,
+                                        ARRAY_SIZE(dac33_fifo_snd_controls));
+        }
 
         dac33_add_widgets(codec);
 
@@ -1481,9 +1550,14 @@ static int __devinit dac33_i2c_probe(struct i2c_client *client,
         /* Pre calculate the burst rate */
         dac33->burst_rate = BURST_BASEFREQ_HZ / dac33->burst_bclkdiv / 32;
         dac33->keep_bclk = pdata->keep_bclk;
+        dac33->auto_fifo_config = pdata->auto_fifo_config;
+        dac33->mode1_latency = pdata->mode1_latency;
+        if (!dac33->mode1_latency)
+                dac33->mode1_latency = 10000; /* 10ms */
         dac33->irq = client->irq;
         dac33->nsample = NSAMPLE_MAX;
         dac33->nsample_max = NSAMPLE_MAX;
+        dac33->uthr = MODE7_UTHR;
         /* Disable FIFO use by default */
         dac33->fifo_mode = DAC33_FIFO_BYPASS;
 
diff --git a/sound/soc/codecs/twl4030.c b/sound/soc/codecs/twl4030.c
index b4fcdb01fc49..7b618bbff884 100644
--- a/sound/soc/codecs/twl4030.c
+++ b/sound/soc/codecs/twl4030.c
@@ -43,37 +43,37 @@
  */
 static const u8 twl4030_reg[TWL4030_CACHEREGNUM] = {
         0x00, /* this register not used         */
-        0x91, /* REG_CODEC_MODE         (0x1)   */
-        0xc3, /* REG_OPTION             (0x2)   */
+        0x00, /* REG_CODEC_MODE         (0x1)   */
+        0x00, /* REG_OPTION             (0x2)   */
         0x00, /* REG_UNKNOWN            (0x3)   */
         0x00, /* REG_MICBIAS_CTL        (0x4)   */
-        0x20, /* REG_ANAMICL            (0x5)   */
+        0x00, /* REG_ANAMICL            (0x5)   */
         0x00, /* REG_ANAMICR            (0x6)   */
         0x00, /* REG_AVADC_CTL          (0x7)   */
         0x00, /* REG_ADCMICSEL          (0x8)   */
         0x00, /* REG_DIGMIXING          (0x9)   */
-        0x0c, /* REG_ATXL1PGA           (0xA)   */
-        0x0c, /* REG_ATXR1PGA           (0xB)   */
-        0x00, /* REG_AVTXL2PGA          (0xC)   */
-        0x00, /* REG_AVTXR2PGA          (0xD)   */
+        0x0f, /* REG_ATXL1PGA           (0xA)   */
+        0x0f, /* REG_ATXR1PGA           (0xB)   */
+        0x0f, /* REG_AVTXL2PGA          (0xC)   */
+        0x0f, /* REG_AVTXR2PGA          (0xD)   */
         0x00, /* REG_AUDIO_IF           (0xE)   */
         0x00, /* REG_VOICE_IF           (0xF)   */
-        0x00, /* REG_ARXR1PGA           (0x10)  */
-        0x00, /* REG_ARXL1PGA           (0x11)  */
-        0x6c, /* REG_ARXR2PGA           (0x12)  */
-        0x6c, /* REG_ARXL2PGA           (0x13)  */
-        0x00, /* REG_VRXPGA             (0x14)  */
+        0x3f, /* REG_ARXR1PGA           (0x10)  */
+        0x3f, /* REG_ARXL1PGA           (0x11)  */
+        0x3f, /* REG_ARXR2PGA           (0x12)  */
+        0x3f, /* REG_ARXL2PGA           (0x13)  */
+        0x25, /* REG_VRXPGA             (0x14)  */
         0x00, /* REG_VSTPGA             (0x15)  */
         0x00, /* REG_VRX2ARXPGA         (0x16)  */
         0x00, /* REG_AVDAC_CTL          (0x17)  */
         0x00, /* REG_ARX2VTXPGA         (0x18)  */
-        0x00, /* REG_ARXL1_APGA_CTL     (0x19)  */
-        0x00, /* REG_ARXR1_APGA_CTL     (0x1A)  */
-        0x4a, /* REG_ARXL2_APGA_CTL     (0x1B)  */
-        0x4a, /* REG_ARXR2_APGA_CTL     (0x1C)  */
+        0x32, /* REG_ARXL1_APGA_CTL     (0x19)  */
+        0x32, /* REG_ARXR1_APGA_CTL     (0x1A)  */
+        0x32, /* REG_ARXL2_APGA_CTL     (0x1B)  */
+        0x32, /* REG_ARXR2_APGA_CTL     (0x1C)  */
         0x00, /* REG_ATX2ARXPGA         (0x1D)  */
         0x00, /* REG_BT_IF              (0x1E)  */
-        0x00, /* REG_BTPGA              (0x1F)  */
+        0x55, /* REG_BTPGA              (0x1F)  */
         0x00, /* REG_BTSTPGA            (0x20)  */
         0x00, /* REG_EAR_CTL            (0x21)  */
         0x00, /* REG_HS_SEL             (0x22)  */
@@ -85,32 +85,32 @@ static const u8 twl4030_reg[TWL4030_CACHEREGNUM] = {
         0x00, /* REG_PRECKR_CTL         (0x28)  */
         0x00, /* REG_HFL_CTL            (0x29)  */
         0x00, /* REG_HFR_CTL            (0x2A)  */
-        0x00, /* REG_ALC_CTL            (0x2B)  */
+        0x05, /* REG_ALC_CTL            (0x2B)  */
         0x00, /* REG_ALC_SET1           (0x2C)  */
         0x00, /* REG_ALC_SET2           (0x2D)  */
         0x00, /* REG_BOOST_CTL          (0x2E)  */
         0x00, /* REG_SOFTVOL_CTL        (0x2F)  */
-        0x00, /* REG_DTMF_FREQSEL       (0x30)  */
+        0x13, /* REG_DTMF_FREQSEL       (0x30)  */
         0x00, /* REG_DTMF_TONEXT1H      (0x31)  */
         0x00, /* REG_DTMF_TONEXT1L      (0x32)  */
         0x00, /* REG_DTMF_TONEXT2H      (0x33)  */
         0x00, /* REG_DTMF_TONEXT2L      (0x34)  */
-        0x00, /* REG_DTMF_TONOFF        (0x35)  */
-        0x00, /* REG_DTMF_WANONOFF      (0x36)  */
+        0x79, /* REG_DTMF_TONOFF        (0x35)  */
+        0x11, /* REG_DTMF_WANONOFF      (0x36)  */
         0x00, /* REG_I2S_RX_SCRAMBLE_H  (0x37)  */
         0x00, /* REG_I2S_RX_SCRAMBLE_M  (0x38)  */
         0x00, /* REG_I2S_RX_SCRAMBLE_L  (0x39)  */
         0x06, /* REG_APLL_CTL           (0x3A)  */
         0x00, /* REG_DTMF_CTL           (0x3B)  */
-        0x00, /* REG_DTMF_PGA_CTL2      (0x3C)  */
-        0x00, /* REG_DTMF_PGA_CTL1      (0x3D)  */
+        0x44, /* REG_DTMF_PGA_CTL2      (0x3C)  */
+        0x69, /* REG_DTMF_PGA_CTL1      (0x3D)  */
         0x00, /* REG_MISC_SET_1         (0x3E)  */
         0x00, /* REG_PCMBTMUX           (0x3F)  */
         0x00, /* not used               (0x40)  */
         0x00, /* not used               (0x41)  */
         0x00, /* not used               (0x42)  */
         0x00, /* REG_RX_PATH_SEL        (0x43)  */
-        0x00, /* REG_VDL_APGA_CTL       (0x44)  */
+        0x32, /* REG_VDL_APGA_CTL       (0x44)  */
         0x00, /* REG_VIBRA_CTL          (0x45)  */
         0x00, /* REG_VIBRA_SET          (0x46)  */
         0x00, /* REG_VIBRA_PWM_SET      (0x47)  */
@@ -143,6 +143,9 @@ struct twl4030_priv {
         u8 earpiece_enabled;
         u8 predrivel_enabled, predriver_enabled;
         u8 carkitl_enabled, carkitr_enabled;
+
+        /* Delay needed after enabling the digimic interface */
+        unsigned int digimic_delay;
 };
 
 /*
@@ -244,58 +247,95 @@ static void twl4030_codec_enable(struct snd_soc_codec *codec, int enable)
         udelay(10);
 }
 
-static void twl4030_init_chip(struct snd_soc_codec *codec)
+static inline void twl4030_check_defaults(struct snd_soc_codec *codec)
 {
-        u8 *cache = codec->reg_cache;
-        int i;
+        int i, difference = 0;
+        u8 val;
+
+        dev_dbg(codec->dev, "Checking TWL audio default configuration\n");
+        for (i = 1; i <= TWL4030_REG_MISC_SET_2; i++) {
+                twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &val, i);
+                if (val != twl4030_reg[i]) {
+                        difference++;
+                        dev_dbg(codec->dev,
+                                 "Reg 0x%02x: chip: 0x%02x driver: 0x%02x\n",
+                                 i, val, twl4030_reg[i]);
+                }
+        }
+        dev_dbg(codec->dev, "Found %d non maching registers. %s\n",
+                 difference, difference ? "Not OK" : "OK");
+}
 
-        /* clear CODECPDZ prior to setting register defaults */
-        twl4030_codec_enable(codec, 0);
+static inline void twl4030_reset_registers(struct snd_soc_codec *codec)
+{
+        int i;
 
         /* set all audio section registers to reasonable defaults */
         for (i = TWL4030_REG_OPTION; i <= TWL4030_REG_MISC_SET_2; i++)
                 if (i != TWL4030_REG_APLL_CTL)
-                        twl4030_write(codec, i, cache[i]);
+                        twl4030_write(codec, i, twl4030_reg[i]);
 
 }
 
-static void twl4030_apll_enable(struct snd_soc_codec *codec, int enable)
+static void twl4030_init_chip(struct platform_device *pdev)
 {
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct twl4030_setup_data *setup = socdev->codec_data;
+        struct snd_soc_codec *codec = socdev->card->codec;
         struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
-        int status = -1;
+        u8 reg, byte;
+        int i = 0;
 
-        if (enable) {
-                twl4030->apll_enabled++;
-                if (twl4030->apll_enabled == 1)
-                        status = twl4030_codec_enable_resource(
-                                                        TWL4030_CODEC_RES_APLL);
-        } else {
-                twl4030->apll_enabled--;
-                if (!twl4030->apll_enabled)
-                        status = twl4030_codec_disable_resource(
-                                                        TWL4030_CODEC_RES_APLL);
-        }
+        /* Check defaults, if instructed before anything else */
+        if (setup && setup->check_defaults)
+                twl4030_check_defaults(codec);
 
-        if (status >= 0)
-                twl4030_write_reg_cache(codec, TWL4030_REG_APLL_CTL, status);
-}
+        /* Reset registers, if no setup data or if instructed to do so */
+        if (!setup || (setup && setup->reset_registers))
+                twl4030_reset_registers(codec);
 
-static void twl4030_power_up(struct snd_soc_codec *codec)
-{
-        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
-        u8 anamicl, regmisc1, byte;
-        int i = 0;
+        /* Refresh APLL_CTL register from HW */
+        twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &byte,
+                            TWL4030_REG_APLL_CTL);
+        twl4030_write_reg_cache(codec, TWL4030_REG_APLL_CTL, byte);
+
+        /* anti-pop when changing analog gain */
+        reg = twl4030_read_reg_cache(codec, TWL4030_REG_MISC_SET_1);
+        twl4030_write(codec, TWL4030_REG_MISC_SET_1,
+                reg | TWL4030_SMOOTH_ANAVOL_EN);
 
-        if (twl4030->codec_powered)
+        twl4030_write(codec, TWL4030_REG_OPTION,
+                TWL4030_ATXL1_EN | TWL4030_ATXR1_EN |
+                TWL4030_ARXL2_EN | TWL4030_ARXR2_EN);
+
+        /* REG_ARXR2_APGA_CTL reset according to the TRM: 0dB, DA_EN */
+        twl4030_write(codec, TWL4030_REG_ARXR2_APGA_CTL, 0x32);
+
+        /* Machine dependent setup */
+        if (!setup)
                 return;
 
-        /* set CODECPDZ to turn on codec */
-        twl4030_codec_enable(codec, 1);
+        twl4030->digimic_delay = setup->digimic_delay;
+
+        /* Configuration for headset ramp delay from setup data */
+        if (setup->sysclk != twl4030->sysclk)
+                dev_warn(codec->dev,
+                                "Mismatch in APLL mclk: %u (configured: %u)\n",
+                                setup->sysclk, twl4030->sysclk);
+
+        reg = twl4030_read_reg_cache(codec, TWL4030_REG_HS_POPN_SET);
+        reg &= ~TWL4030_RAMP_DELAY;
+        reg |= (setup->ramp_delay_value << 2);
+        twl4030_write_reg_cache(codec, TWL4030_REG_HS_POPN_SET, reg);
 
         /* initiate offset cancellation */
-        anamicl = twl4030_read_reg_cache(codec, TWL4030_REG_ANAMICL);
+        twl4030_codec_enable(codec, 1);
+
+        reg = twl4030_read_reg_cache(codec, TWL4030_REG_ANAMICL);
+        reg &= ~TWL4030_OFFSET_CNCL_SEL;
+        reg |= setup->offset_cncl_path;
         twl4030_write(codec, TWL4030_REG_ANAMICL,
-                anamicl | TWL4030_CNCL_OFFSET_START);
+                reg | TWL4030_CNCL_OFFSET_START);
 
         /* wait for offset cancellation to complete */
         do {
@@ -310,23 +350,28 @@ static void twl4030_power_up(struct snd_soc_codec *codec)
         /* Make sure that the reg_cache has the same value as the HW */
         twl4030_write_reg_cache(codec, TWL4030_REG_ANAMICL, byte);
 
-        /* anti-pop when changing analog gain */
-        regmisc1 = twl4030_read_reg_cache(codec, TWL4030_REG_MISC_SET_1);
-        twl4030_write(codec, TWL4030_REG_MISC_SET_1,
-                regmisc1 | TWL4030_SMOOTH_ANAVOL_EN);
-
-        /* toggle CODECPDZ as per TRM */
         twl4030_codec_enable(codec, 0);
-        twl4030_codec_enable(codec, 1);
 }
 
-/*
- * Unconditional power down
- */
-static void twl4030_power_down(struct snd_soc_codec *codec)
+static void twl4030_apll_enable(struct snd_soc_codec *codec, int enable)
 {
-        /* power down */
-        twl4030_codec_enable(codec, 0);
+        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
+        int status = -1;
+
+        if (enable) {
+                twl4030->apll_enabled++;
+                if (twl4030->apll_enabled == 1)
+                        status = twl4030_codec_enable_resource(
+                                                        TWL4030_CODEC_RES_APLL);
+        } else {
+                twl4030->apll_enabled--;
+                if (!twl4030->apll_enabled)
+                        status = twl4030_codec_disable_resource(
+                                                        TWL4030_CODEC_RES_APLL);
+        }
+
+        if (status >= 0)
+                twl4030_write_reg_cache(codec, TWL4030_REG_APLL_CTL, status);
 }
 
 /* Earpiece */
@@ -500,10 +545,11 @@ static const struct snd_kcontrol_new twl4030_dapm_abypassl2_control =
 static const struct snd_kcontrol_new twl4030_dapm_abypassv_control =
         SOC_DAPM_SINGLE("Switch", TWL4030_REG_VDL_APGA_CTL, 2, 1, 0);
 
-/* Digital bypass gain, 0 mutes the bypass */
+/* Digital bypass gain, mute instead of -30dB */
 static const unsigned int twl4030_dapm_dbypass_tlv[] = {
-        TLV_DB_RANGE_HEAD(2),
-        0, 3, TLV_DB_SCALE_ITEM(-2400, 0, 1),
+        TLV_DB_RANGE_HEAD(3),
+        0, 1, TLV_DB_SCALE_ITEM(-3000, 600, 1),
+        2, 3, TLV_DB_SCALE_ITEM(-2400, 0, 0),
         4, 7, TLV_DB_SCALE_ITEM(-1800, 600, 0),
 };
 
@@ -531,36 +577,6 @@ static const struct snd_kcontrol_new twl4030_dapm_dbypassv_control =
                         TWL4030_REG_VSTPGA, 0, 0x29, 0,
                         twl4030_dapm_dbypassv_tlv);
 
-static int micpath_event(struct snd_soc_dapm_widget *w,
-        struct snd_kcontrol *kcontrol, int event)
-{
-        struct soc_enum *e = (struct soc_enum *)w->kcontrols->private_value;
-        unsigned char adcmicsel, micbias_ctl;
-
-        adcmicsel = twl4030_read_reg_cache(w->codec, TWL4030_REG_ADCMICSEL);
-        micbias_ctl = twl4030_read_reg_cache(w->codec, TWL4030_REG_MICBIAS_CTL);
-        /* Prepare the bits for the given TX path:
-         * shift_l == 0: TX1 microphone path
-         * shift_l == 2: TX2 microphone path */
-        if (e->shift_l) {
-                /* TX2 microphone path */
-                if (adcmicsel & TWL4030_TX2IN_SEL)
-                        micbias_ctl |= TWL4030_MICBIAS2_CTL; /* digimic */
-                else
-                        micbias_ctl &= ~TWL4030_MICBIAS2_CTL;
-        } else {
-                /* TX1 microphone path */
-                if (adcmicsel & TWL4030_TX1IN_SEL)
-                        micbias_ctl |= TWL4030_MICBIAS1_CTL; /* digimic */
-                else
-                        micbias_ctl &= ~TWL4030_MICBIAS1_CTL;
-        }
-
-        twl4030_write(w->codec, TWL4030_REG_MICBIAS_CTL, micbias_ctl);
-
-        return 0;
-}
-
 /*
  * Output PGA builder:
  * Handle the muting and unmuting of the given output (turning off the
@@ -814,6 +830,16 @@ static int headsetrpga_event(struct snd_soc_dapm_widget *w,
         return 0;
 }
 
+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);
+
+        if (twl4030->digimic_delay)
+                mdelay(twl4030->digimic_delay);
+        return 0;
+}
+
 /*
  * Some of the gain controls in TWL (mostly those which are associated with
  * the outputs) are implemented in an interesting way:
@@ -1374,14 +1400,10 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
         /* Analog/Digital mic path selection.
            TX1 Left/Right: either analog Left/Right or Digimic0
            TX2 Left/Right: either analog Left/Right or Digimic1 */
-        SND_SOC_DAPM_MUX_E("TX1 Capture Route", SND_SOC_NOPM, 0, 0,
-                &twl4030_dapm_micpathtx1_control, micpath_event,
-                SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD|
-                SND_SOC_DAPM_POST_REG),
-        SND_SOC_DAPM_MUX_E("TX2 Capture Route", SND_SOC_NOPM, 0, 0,
-                &twl4030_dapm_micpathtx2_control, micpath_event,
-                SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD|
-                SND_SOC_DAPM_POST_REG),
+        SND_SOC_DAPM_MUX("TX1 Capture Route", SND_SOC_NOPM, 0, 0,
+                &twl4030_dapm_micpathtx1_control),
+        SND_SOC_DAPM_MUX("TX2 Capture Route", SND_SOC_NOPM, 0, 0,
+                &twl4030_dapm_micpathtx2_control),
 
         /* Analog input mixers for the capture amplifiers */
         SND_SOC_DAPM_MIXER("Analog Left",
@@ -1398,10 +1420,17 @@ static const struct snd_soc_dapm_widget twl4030_dapm_widgets[] = {
         SND_SOC_DAPM_PGA("ADC Physical Right",
                 TWL4030_REG_AVADC_CTL, 1, 0, NULL, 0),
 
-        SND_SOC_DAPM_PGA("Digimic0 Enable",
-                TWL4030_REG_ADCMICSEL, 1, 0, NULL, 0),
-        SND_SOC_DAPM_PGA("Digimic1 Enable",
-                TWL4030_REG_ADCMICSEL, 3, 0, NULL, 0),
+        SND_SOC_DAPM_PGA_E("Digimic0 Enable",
+                TWL4030_REG_ADCMICSEL, 1, 0, NULL, 0,
+                digimic_event, SND_SOC_DAPM_POST_PMU),
+        SND_SOC_DAPM_PGA_E("Digimic1 Enable",
+                TWL4030_REG_ADCMICSEL, 3, 0, NULL, 0,
+                digimic_event, SND_SOC_DAPM_POST_PMU),
+
+        SND_SOC_DAPM_SUPPLY("micbias1 select", TWL4030_REG_MICBIAS_CTL, 5, 0,
+                            NULL, 0),
+        SND_SOC_DAPM_SUPPLY("micbias2 select", TWL4030_REG_MICBIAS_CTL, 6, 0,
+                            NULL, 0),
 
         SND_SOC_DAPM_MICBIAS("Mic Bias 1", TWL4030_REG_MICBIAS_CTL, 0, 0),
         SND_SOC_DAPM_MICBIAS("Mic Bias 2", TWL4030_REG_MICBIAS_CTL, 1, 0),
@@ -1419,8 +1448,11 @@ static const struct snd_soc_dapm_route intercon[] = {
         /* Supply for the digital part (APLL) */
         {"Digital Voice Playback Mixer", NULL, "APLL Enable"},
 
-        {"Digital R1 Playback Mixer", NULL, "AIF Enable"},
-        {"Digital L1 Playback Mixer", NULL, "AIF Enable"},
+        {"DAC Left1", NULL, "AIF Enable"},
+        {"DAC Right1", NULL, "AIF Enable"},
+        {"DAC Left2", NULL, "AIF Enable"},
+        {"DAC Right1", NULL, "AIF Enable"},
+
         {"Digital R2 Playback Mixer", NULL, "AIF Enable"},
         {"Digital L2 Playback Mixer", NULL, "AIF Enable"},
 
@@ -1491,10 +1523,10 @@ static const struct snd_soc_dapm_route intercon[] = {
 
         /* outputs */
         /* Must be always connected (for AIF and APLL) */
-        {"Virtual HiFi OUT", NULL, "Digital L1 Playback Mixer"},
-        {"Virtual HiFi OUT", NULL, "Digital R1 Playback Mixer"},
-        {"Virtual HiFi OUT", NULL, "Digital L2 Playback Mixer"},
-        {"Virtual HiFi OUT", NULL, "Digital R2 Playback Mixer"},
+        {"Virtual HiFi OUT", NULL, "DAC Left1"},
+        {"Virtual HiFi OUT", NULL, "DAC Right1"},
+        {"Virtual HiFi OUT", NULL, "DAC Left2"},
+        {"Virtual HiFi OUT", NULL, "DAC Right2"},
         /* Must be always connected (for APLL) */
         {"Virtual Voice OUT", NULL, "Digital Voice Playback Mixer"},
         /* Physical outputs */
@@ -1531,6 +1563,9 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"Digimic0 Enable", NULL, "DIGIMIC0"},
         {"Digimic1 Enable", NULL, "DIGIMIC1"},
 
+        {"DIGIMIC0", NULL, "micbias1 select"},
+        {"DIGIMIC1", NULL, "micbias2 select"},
+
         /* TX1 Left capture path */
         {"TX1 Capture Route", "Analog", "ADC Physical Left"},
         {"TX1 Capture Route", "Digimic0", "Digimic0 Enable"},
@@ -1605,10 +1640,10 @@ static int twl4030_set_bias_level(struct snd_soc_codec *codec,
                 break;
         case SND_SOC_BIAS_STANDBY:
                 if (codec->bias_level == SND_SOC_BIAS_OFF)
-                        twl4030_power_up(codec);
+                        twl4030_codec_enable(codec, 1);
                 break;
         case SND_SOC_BIAS_OFF:
-                twl4030_power_down(codec);
+                twl4030_codec_enable(codec, 0);
                 break;
         }
         codec->bias_level = level;
@@ -1794,13 +1829,6 @@ static int twl4030_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        if (mode != old_mode) {
-                /* change rate and set CODECPDZ */
-                twl4030_codec_enable(codec, 0);
-                twl4030_write(codec, TWL4030_REG_CODEC_MODE, mode);
-                twl4030_codec_enable(codec, 1);
-        }
-
         /* sample size */
         old_format = twl4030_read_reg_cache(codec, TWL4030_REG_AUDIO_IF);
         format = old_format;
@@ -1818,16 +1846,20 @@ static int twl4030_hw_params(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        if (format != old_format) {
-
-                /* clear CODECPDZ before changing format (codec requirement) */
-                twl4030_codec_enable(codec, 0);
-
-                /* change format */
-                twl4030_write(codec, TWL4030_REG_AUDIO_IF, format);
-
-                /* set CODECPDZ afterwards */
-                twl4030_codec_enable(codec, 1);
+        if (format != old_format || mode != old_mode) {
+                if (twl4030->codec_powered) {
+                        /*
+                         * If the codec is powered, than we need to toggle the
+                         * codec power.
+                         */
+                        twl4030_codec_enable(codec, 0);
+                        twl4030_write(codec, TWL4030_REG_CODEC_MODE, mode);
+                        twl4030_write(codec, TWL4030_REG_AUDIO_IF, format);
+                        twl4030_codec_enable(codec, 1);
+                } else {
+                        twl4030_write(codec, TWL4030_REG_CODEC_MODE, mode);
+                        twl4030_write(codec, TWL4030_REG_AUDIO_IF, format);
+                }
         }
 
         /* Store the important parameters for the DAI configuration and set
@@ -1877,6 +1909,7 @@ static int twl4030_set_dai_fmt(struct snd_soc_dai *codec_dai,
                              unsigned int fmt)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
+        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
         u8 old_format, format;
 
         /* get format */
@@ -1911,15 +1944,17 @@ static int twl4030_set_dai_fmt(struct snd_soc_dai *codec_dai,
         }
 
         if (format != old_format) {
-
-                /* clear CODECPDZ before changing format (codec requirement) */
-                twl4030_codec_enable(codec, 0);
-
-                /* change format */
-                twl4030_write(codec, TWL4030_REG_AUDIO_IF, format);
-
-                /* set CODECPDZ afterwards */
-                twl4030_codec_enable(codec, 1);
+                if (twl4030->codec_powered) {
+                        /*
+                         * If the codec is powered, than we need to toggle the
+                         * codec power.
+                         */
+                        twl4030_codec_enable(codec, 0);
+                        twl4030_write(codec, TWL4030_REG_AUDIO_IF, format);
+                        twl4030_codec_enable(codec, 1);
+                } else {
+                        twl4030_write(codec, TWL4030_REG_AUDIO_IF, format);
+                }
         }
 
         return 0;
@@ -2011,6 +2046,7 @@ static int twl4030_voice_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_device *socdev = rtd->socdev;
         struct snd_soc_codec *codec = socdev->card->codec;
+        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
         u8 old_mode, mode;
 
         /* Enable voice digital filters */
@@ -2035,10 +2071,17 @@ static int twl4030_voice_hw_params(struct snd_pcm_substream *substream,
         }
 
         if (mode != old_mode) {
-                /* change rate and set CODECPDZ */
-                twl4030_codec_enable(codec, 0);
-                twl4030_write(codec, TWL4030_REG_CODEC_MODE, mode);
-                twl4030_codec_enable(codec, 1);
+                if (twl4030->codec_powered) {
+                        /*
+                         * If the codec is powered, than we need to toggle the
+                         * codec power.
+                         */
+                        twl4030_codec_enable(codec, 0);
+                        twl4030_write(codec, TWL4030_REG_CODEC_MODE, mode);
+                        twl4030_codec_enable(codec, 1);
+                } else {
+                        twl4030_write(codec, TWL4030_REG_CODEC_MODE, mode);
+                }
         }
 
         return 0;
@@ -2068,6 +2111,7 @@ static int twl4030_voice_set_dai_fmt(struct snd_soc_dai *codec_dai,
                 unsigned int fmt)
 {
         struct snd_soc_codec *codec = codec_dai->codec;
+        struct twl4030_priv *twl4030 = snd_soc_codec_get_drvdata(codec);
         u8 old_format, format;
 
         /* get format */
@@ -2099,10 +2143,17 @@ static int twl4030_voice_set_dai_fmt(struct snd_soc_dai *codec_dai,
         }
 
         if (format != old_format) {
-                /* change format and set CODECPDZ */
-                twl4030_codec_enable(codec, 0);
-                twl4030_write(codec, TWL4030_REG_VOICE_IF, format);
-                twl4030_codec_enable(codec, 1);
+                if (twl4030->codec_powered) {
+                        /*
+                         * If the codec is powered, than we need to toggle the
+                         * codec power.
+                         */
+                        twl4030_codec_enable(codec, 0);
+                        twl4030_write(codec, TWL4030_REG_VOICE_IF, format);
+                        twl4030_codec_enable(codec, 1);
+                } else {
+                        twl4030_write(codec, TWL4030_REG_VOICE_IF, format);
+                }
         }
 
         return 0;
@@ -2202,31 +2253,15 @@ static struct snd_soc_codec *twl4030_codec;
 static int twl4030_soc_probe(struct platform_device *pdev)
 {
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
-        struct twl4030_setup_data *setup = socdev->codec_data;
         struct snd_soc_codec *codec;
-        struct twl4030_priv *twl4030;
         int ret;
 
         BUG_ON(!twl4030_codec);
 
         codec = twl4030_codec;
-        twl4030 = snd_soc_codec_get_drvdata(codec);
         socdev->card->codec = codec;
 
-        /* Configuration for headset ramp delay from setup data */
-        if (setup) {
-                unsigned char hs_pop;
-
-                if (setup->sysclk != twl4030->sysclk)
-                        dev_warn(&pdev->dev,
-                                 "Mismatch in APLL mclk: %u (configured: %u)\n",
-                                 setup->sysclk, twl4030->sysclk);
-
-                hs_pop = twl4030_read_reg_cache(codec, TWL4030_REG_HS_POPN_SET);
-                hs_pop &= ~TWL4030_RAMP_DELAY;
-                hs_pop |= (setup->ramp_delay_value << 2);
-                twl4030_write_reg_cache(codec, TWL4030_REG_HS_POPN_SET, hs_pop);
-        }
+        twl4030_init_chip(pdev);
 
         /* register pcms */
         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
@@ -2247,6 +2282,8 @@ static int twl4030_soc_remove(struct platform_device *pdev)
         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
         struct snd_soc_codec *codec = socdev->card->codec;
 
+        /* Reset registers to their chip default before leaving */
+        twl4030_reset_registers(codec);
         twl4030_set_bias_level(codec, SND_SOC_BIAS_OFF);
         snd_soc_free_pcms(socdev);
         snd_soc_dapm_free(socdev);
@@ -2287,6 +2324,7 @@ static int __devinit twl4030_codec_probe(struct platform_device *pdev)
         codec->read = twl4030_read_reg_cache;
         codec->write = twl4030_write;
         codec->set_bias_level = twl4030_set_bias_level;
+        codec->idle_bias_off = 1;
         codec->dai = twl4030_dai;
         codec->num_dai = ARRAY_SIZE(twl4030_dai);
         codec->reg_cache_size = sizeof(twl4030_reg);
@@ -2302,9 +2340,7 @@ static int __devinit twl4030_codec_probe(struct platform_device *pdev)
 
         /* Set the defaults, and power up the codec */
         twl4030->sysclk = twl4030_codec_get_mclk() / 1000;
-        twl4030_init_chip(codec);
         codec->bias_level = SND_SOC_BIAS_OFF;
-        twl4030_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
 
         ret = snd_soc_register_codec(codec);
         if (ret != 0) {
@@ -2322,7 +2358,7 @@ static int __devinit twl4030_codec_probe(struct platform_device *pdev)
         return 0;
 
 error_codec:
-        twl4030_power_down(codec);
+        twl4030_codec_enable(codec, 0);
         kfree(codec->reg_cache);
 error_cache:
         kfree(twl4030);
diff --git a/sound/soc/codecs/twl4030.h b/sound/soc/codecs/twl4030.h
index f206d242ca31..6c57430f6e24 100644
--- a/sound/soc/codecs/twl4030.h
+++ b/sound/soc/codecs/twl4030.h
@@ -41,7 +41,11 @@ extern struct snd_soc_codec_device soc_codec_dev_twl4030;
 
 struct twl4030_setup_data {
         unsigned int ramp_delay_value;
+        unsigned int digimic_delay; /* in ms */
         unsigned int sysclk;
+        unsigned int offset_cncl_path;
+        unsigned int check_defaults:1;
+        unsigned int reset_registers:1;
         unsigned int hs_extmute:1;
         void (*set_hs_extmute)(int mute);
 };
diff --git a/sound/soc/codecs/twl6040.c b/sound/soc/codecs/twl6040.c
index af36346ff336..64a807f1a8a1 100644
--- a/sound/soc/codecs/twl6040.c
+++ b/sound/soc/codecs/twl6040.c
@@ -360,6 +360,13 @@ static int headset_power_mode(struct snd_soc_codec *codec, int high_perf)
         return 0;
 }
 
+static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w,
+                        struct snd_kcontrol *kcontrol, int event)
+{
+        msleep(1);
+        return 0;
+}
+
 static int twl6040_power_mode_event(struct snd_soc_dapm_widget *w,
                         struct snd_kcontrol *kcontrol, int event)
 {
@@ -371,6 +378,8 @@ static int twl6040_power_mode_event(struct snd_soc_dapm_widget *w,
         else
                 priv->non_lp--;
 
+        msleep(1);
+
         return 0;
 }
 
@@ -471,20 +480,6 @@ static const struct snd_kcontrol_new hfdacl_switch_controls =
 static const struct snd_kcontrol_new hfdacr_switch_controls =
         SOC_DAPM_SINGLE("Switch", TWL6040_REG_HFRCTL, 2, 1, 0);
 
-/* Headset driver switches */
-static const struct snd_kcontrol_new hsl_driver_switch_controls =
-        SOC_DAPM_SINGLE("Switch", TWL6040_REG_HSLCTL, 2, 1, 0);
-
-static const struct snd_kcontrol_new hsr_driver_switch_controls =
-        SOC_DAPM_SINGLE("Switch", TWL6040_REG_HSRCTL, 2, 1, 0);
-
-/* Handsfree driver switches */
-static const struct snd_kcontrol_new hfl_driver_switch_controls =
-        SOC_DAPM_SINGLE("Switch", TWL6040_REG_HFLCTL, 4, 1, 0);
-
-static const struct snd_kcontrol_new hfr_driver_switch_controls =
-        SOC_DAPM_SINGLE("Switch", TWL6040_REG_HFRCTL, 4, 1, 0);
-
 static const struct snd_kcontrol_new ep_driver_switch_controls =
         SOC_DAPM_SINGLE("Switch", TWL6040_REG_EARCTL, 0, 1, 0);
 
@@ -548,10 +543,14 @@ static const struct snd_soc_dapm_widget twl6040_dapm_widgets[] = {
                         TWL6040_REG_DMICBCTL, 4, 0),
 
         /* DACs */
-        SND_SOC_DAPM_DAC("HSDAC Left", "Headset Playback",
-                        TWL6040_REG_HSLCTL, 0, 0),
-        SND_SOC_DAPM_DAC("HSDAC Right", "Headset Playback",
-                        TWL6040_REG_HSRCTL, 0, 0),
+        SND_SOC_DAPM_DAC_E("HSDAC Left", "Headset Playback",
+                        TWL6040_REG_HSLCTL, 0, 0,
+                        twl6040_hs_dac_event,
+                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_DAC_E("HSDAC Right", "Headset Playback",
+                        TWL6040_REG_HSRCTL, 0, 0,
+                        twl6040_hs_dac_event,
+                        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
         SND_SOC_DAPM_DAC_E("HFDAC Left", "Handsfree Playback",
                         TWL6040_REG_HFLCTL, 0, 0,
                         twl6040_power_mode_event,
@@ -571,18 +570,19 @@ static const struct snd_soc_dapm_widget twl6040_dapm_widgets[] = {
         SND_SOC_DAPM_SWITCH("HFDAC Right Playback",
                         SND_SOC_NOPM, 0, 0, &hfdacr_switch_controls),
 
-        SND_SOC_DAPM_SWITCH("Headset Left Driver",
-                        SND_SOC_NOPM, 0, 0, &hsl_driver_switch_controls),
-        SND_SOC_DAPM_SWITCH("Headset Right Driver",
-                        SND_SOC_NOPM, 0, 0, &hsr_driver_switch_controls),
-        SND_SOC_DAPM_SWITCH_E("Handsfree Left Driver",
-                        SND_SOC_NOPM, 0, 0, &hfl_driver_switch_controls,
+        /* Analog playback drivers */
+        SND_SOC_DAPM_PGA_E("Handsfree Left Driver",
+                        TWL6040_REG_HFLCTL, 4, 0, NULL, 0,
                         twl6040_power_mode_event,
                         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
-        SND_SOC_DAPM_SWITCH_E("Handsfree Right Driver",
-                        SND_SOC_NOPM, 0, 0, &hfr_driver_switch_controls,
+        SND_SOC_DAPM_PGA_E("Handsfree Right Driver",
+                        TWL6040_REG_HFRCTL, 4, 0, NULL, 0,
                         twl6040_power_mode_event,
                         SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
+        SND_SOC_DAPM_PGA("Headset Left Driver",
+                        TWL6040_REG_HSLCTL, 2, 0, NULL, 0),
+        SND_SOC_DAPM_PGA("Headset Right Driver",
+                        TWL6040_REG_HSRCTL, 2, 0, NULL, 0),
         SND_SOC_DAPM_SWITCH_E("Earphone Driver",
                         SND_SOC_NOPM, 0, 0, &ep_driver_switch_controls,
                         twl6040_power_mode_event,
@@ -616,8 +616,8 @@ static const struct snd_soc_dapm_route intercon[] = {
         {"HSDAC Left Playback", "Switch", "HSDAC Left"},
         {"HSDAC Right Playback", "Switch", "HSDAC Right"},
 
-        {"Headset Left Driver", "Switch", "HSDAC Left Playback"},
-        {"Headset Right Driver", "Switch", "HSDAC Right Playback"},
+        {"Headset Left Driver", NULL, "HSDAC Left Playback"},
+        {"Headset Right Driver", NULL, "HSDAC Right Playback"},
 
         {"HSOL", NULL, "Headset Left Driver"},
         {"HSOR", NULL, "Headset Right Driver"},
@@ -928,7 +928,7 @@ static int twl6040_set_dai_sysclk(struct snd_soc_dai *codec_dai,
                 case 19200000:
                         /* mclk input, pll disabled */
                         hppllctl |= TWL6040_MCLK_19200KHZ |
-                                    TWL6040_HPLLSQRBP |
+                                    TWL6040_HPLLSQRENA |
                                     TWL6040_HPLLBP;
                         break;
                 case 26000000:
diff --git a/sound/soc/codecs/uda134x.c b/sound/soc/codecs/uda134x.c
index 28aac53c97bb..f3b4c1d6a82d 100644
--- a/sound/soc/codecs/uda134x.c
+++ b/sound/soc/codecs/uda134x.c
@@ -28,19 +28,6 @@
 #include "uda134x.h"
 
 
-#define POWER_OFF_ON_STANDBY 1
-/*
-  ALSA SOC usually puts the device in standby mode when it's not used
-  for sometime. If you define POWER_OFF_ON_STANDBY the driver will
-  turn off the ADC/DAC when this callback is invoked and turn it back
-  on when needed. Unfortunately this will result in a very light bump
-  (it can be audible only with good earphones). If this bothers you
-  just comment this line, you will have slightly higher power
-  consumption . Please note that sending the L3 command for ADC is
-  enough to make the bump, so it doesn't make difference if you
-  completely take off power from the codec.
- */
-
 #define UDA134X_RATES SNDRV_PCM_RATE_8000_48000
 #define UDA134X_FORMATS (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE | \
                 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S20_3LE)
@@ -58,7 +45,7 @@ static const char uda134x_reg[UDA134X_REGS_NUM] = {
         /* Extended address registers */
         0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
         /* Status, data regs */
-        0x00, 0x83, 0x00, 0x40, 0x80, 0x00,
+        0x00, 0x83, 0x00, 0x40, 0x80, 0xC0, 0x00,
 };
 
 /*
@@ -117,6 +104,7 @@ static int uda134x_write(struct snd_soc_codec *codec, unsigned int reg,
         case UDA134X_DATA000:
         case UDA134X_DATA001:
         case UDA134X_DATA010:
+        case UDA134X_DATA011:
                 addr = UDA134X_DATA0_ADDR;
                 break;
         case UDA134X_DATA1:
@@ -353,8 +341,22 @@ static int uda134x_set_bias_level(struct snd_soc_codec *codec,
         switch (level) {
         case SND_SOC_BIAS_ON:
                 /* ADC, DAC on */
-                reg = uda134x_read_reg_cache(codec, UDA134X_STATUS1);
-                uda134x_write(codec, UDA134X_STATUS1, reg | 0x03);
+                switch (pd->model) {
+                case UDA134X_UDA1340:
+                case UDA134X_UDA1344:
+                case UDA134X_UDA1345:
+                        reg = uda134x_read_reg_cache(codec, UDA134X_DATA011);
+                        uda134x_write(codec, UDA134X_DATA011, reg | 0x03);
+                        break;
+                case UDA134X_UDA1341:
+                        reg = uda134x_read_reg_cache(codec, UDA134X_STATUS1);
+                        uda134x_write(codec, UDA134X_STATUS1, reg | 0x03);
+                        break;
+                default:
+                        printk(KERN_ERR "UDA134X SoC codec: "
+                               "unsupported model %d\n", pd->model);
+                        return -EINVAL;
+                }
                 break;
         case SND_SOC_BIAS_PREPARE:
                 /* power on */
@@ -367,8 +369,22 @@ static int uda134x_set_bias_level(struct snd_soc_codec *codec,
                 break;
         case SND_SOC_BIAS_STANDBY:
                 /* ADC, DAC power off */
-                reg = uda134x_read_reg_cache(codec, UDA134X_STATUS1);
-                uda134x_write(codec, UDA134X_STATUS1, reg & ~(0x03));
+                switch (pd->model) {
+                case UDA134X_UDA1340:
+                case UDA134X_UDA1344:
+                case UDA134X_UDA1345:
+                        reg = uda134x_read_reg_cache(codec, UDA134X_DATA011);
+                        uda134x_write(codec, UDA134X_DATA011, reg & ~(0x03));
+                        break;
+                case UDA134X_UDA1341:
+                        reg = uda134x_read_reg_cache(codec, UDA134X_STATUS1);
+                        uda134x_write(codec, UDA134X_STATUS1, reg & ~(0x03));
+                        break;
+                default:
+                        printk(KERN_ERR "UDA134X SoC codec: "
+                               "unsupported model %d\n", pd->model);
+                        return -EINVAL;
+                }
                 break;
         case SND_SOC_BIAS_OFF:
                 /* power off */
@@ -531,9 +547,7 @@ static int uda134x_soc_probe(struct platform_device *pdev)
         codec->num_dai = 1;
         codec->read = uda134x_read_reg_cache;
         codec->write = uda134x_write;
-#ifdef POWER_OFF_ON_STANDBY
-        codec->set_bias_level = uda134x_set_bias_level;
-#endif
+
         INIT_LIST_HEAD(&codec->dapm_widgets);
         INIT_LIST_HEAD(&codec->dapm_paths);
 
@@ -544,6 +558,14 @@ static int uda134x_soc_probe(struct platform_device *pdev)
 
         uda134x_reset(codec);
 
+        if (pd->is_powered_on_standby) {
+                codec->set_bias_level = NULL;
+                uda134x_set_bias_level(codec, SND_SOC_BIAS_ON);
+        } else {
+                codec->set_bias_level = uda134x_set_bias_level;
+                uda134x_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+        }
+
         /* register pcms */
         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
         if (ret < 0) {
diff --git a/sound/soc/codecs/uda134x.h b/sound/soc/codecs/uda134x.h
index 94f440490b31..205f03b3eaf8 100644
--- a/sound/soc/codecs/uda134x.h
+++ b/sound/soc/codecs/uda134x.h
@@ -23,9 +23,10 @@
 #define UDA134X_DATA000 10
 #define UDA134X_DATA001 11
 #define UDA134X_DATA010 12
-#define UDA134X_DATA1   13
+#define UDA134X_DATA011 13
+#define UDA134X_DATA1   14
 
-#define UDA134X_REGS_NUM 14
+#define UDA134X_REGS_NUM 15
 
 #define STATUS0_DAIFMT_MASK (~(7<<1))
 #define STATUS0_SYSCLK_MASK (~(3<<4))
diff --git a/sound/soc/codecs/wm2000.c b/sound/soc/codecs/wm2000.c
index 002e289d1255..4bcd168794e1 100644
--- a/sound/soc/codecs/wm2000.c
+++ b/sound/soc/codecs/wm2000.c
@@ -795,6 +795,8 @@ static int __devinit wm2000_i2c_probe(struct i2c_client *i2c,
 
         dev_set_drvdata(&i2c->dev, wm2000);
         wm2000->anc_eng_ena = 1;
+        wm2000->anc_active = 1;
+        wm2000->spk_ena = 1;
         wm2000->i2c = i2c;
 
         wm2000_reset(wm2000);
diff --git a/sound/soc/codecs/wm8523.c b/sound/soc/codecs/wm8523.c
index 37242a7d3077..0ad039b4adf5 100644
--- a/sound/soc/codecs/wm8523.c
+++ b/sound/soc/codecs/wm8523.c
@@ -482,7 +482,8 @@ static int wm8523_register(struct wm8523_priv *wm8523,
 
         if (wm8523_codec) {
                 dev_err(codec->dev, "Another WM8523 is registered\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto err;
         }
 
         mutex_init(&codec->mutex);
@@ -570,18 +571,19 @@ static int wm8523_register(struct wm8523_priv *wm8523,
         ret = snd_soc_register_codec(codec);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register codec: %d\n", ret);
-                return ret;
+                goto err_enable;
         }
 
         ret = snd_soc_register_dai(&wm8523_dai);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
-                snd_soc_unregister_codec(codec);
-                return ret;
+                goto err_codec;
         }
 
         return 0;
 
+err_codec:
+        snd_soc_unregister_codec(codec);
 err_enable:
         regulator_bulk_disable(ARRAY_SIZE(wm8523->supplies), wm8523->supplies);
 err_get:
diff --git a/sound/soc/codecs/wm8580.c b/sound/soc/codecs/wm8580.c
index c3571ee5c11b..72deeabef4fe 100644
--- a/sound/soc/codecs/wm8580.c
+++ b/sound/soc/codecs/wm8580.c
@@ -269,9 +269,9 @@ SOC_DOUBLE("DAC2 Invert Switch", WM8580_DAC_CONTROL4,  2, 3, 1, 0),
 SOC_DOUBLE("DAC3 Invert Switch", WM8580_DAC_CONTROL4,  4, 5, 1, 0),
 
 SOC_SINGLE("DAC ZC Switch", WM8580_DAC_CONTROL5, 5, 1, 0),
-SOC_SINGLE("DAC1 Switch", WM8580_DAC_CONTROL5, 0, 1, 0),
-SOC_SINGLE("DAC2 Switch", WM8580_DAC_CONTROL5, 1, 1, 0),
-SOC_SINGLE("DAC3 Switch", WM8580_DAC_CONTROL5, 2, 1, 0),
+SOC_SINGLE("DAC1 Switch", WM8580_DAC_CONTROL5, 0, 1, 1),
+SOC_SINGLE("DAC2 Switch", WM8580_DAC_CONTROL5, 1, 1, 1),
+SOC_SINGLE("DAC3 Switch", WM8580_DAC_CONTROL5, 2, 1, 1),
 
 SOC_DOUBLE("ADC Mute Switch", WM8580_ADC_CONTROL1, 0, 1, 1, 0),
 SOC_SINGLE("ADC High-Pass Filter Switch", WM8580_ADC_CONTROL1, 4, 1, 0),
diff --git a/sound/soc/codecs/wm8711.c b/sound/soc/codecs/wm8711.c
index effb14eee7d4..e2dba07f0260 100644
--- a/sound/soc/codecs/wm8711.c
+++ b/sound/soc/codecs/wm8711.c
@@ -439,7 +439,8 @@ static int wm8711_register(struct wm8711_priv *wm8711,
 
         if (wm8711_codec) {
                 dev_err(codec->dev, "Another WM8711 is registered\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto err;
         }
 
         mutex_init(&codec->mutex);
diff --git a/sound/soc/codecs/wm8741.c b/sound/soc/codecs/wm8741.c
new file mode 100644
index 000000000000..b9ea8904ad4b
--- /dev/null
+++ b/sound/soc/codecs/wm8741.c
@@ -0,0 +1,579 @@
+/*
+ * wm8741.c  --  WM8741 ALSA SoC Audio driver
+ *
+ * Copyright 2010 Wolfson Microelectronics plc
+ *
+ * Author: Ian Lartey <ian@opensource.wolfsonmicro.com>
+ *
+ *
+ * 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/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+#include <sound/tlv.h>
+
+#include "wm8741.h"
+
+static struct snd_soc_codec *wm8741_codec;
+struct snd_soc_codec_device soc_codec_dev_wm8741;
+
+#define WM8741_NUM_SUPPLIES 2
+static const char *wm8741_supply_names[WM8741_NUM_SUPPLIES] = {
+        "AVDD",
+        "DVDD",
+};
+
+#define WM8741_NUM_RATES 4
+
+/* codec private data */
+struct wm8741_priv {
+        struct snd_soc_codec codec;
+        u16 reg_cache[WM8741_REGISTER_COUNT];
+        struct regulator_bulk_data supplies[WM8741_NUM_SUPPLIES];
+        unsigned int sysclk;
+        unsigned int rate_constraint_list[WM8741_NUM_RATES];
+        struct snd_pcm_hw_constraint_list rate_constraint;
+};
+
+static const u16 wm8741_reg_defaults[WM8741_REGISTER_COUNT] = {
+        0x0000,     /* R0  - DACLLSB Attenuation */
+        0x0000,     /* R1  - DACLMSB Attenuation */
+        0x0000,     /* R2  - DACRLSB Attenuation */
+        0x0000,     /* R3  - DACRMSB Attenuation */
+        0x0000,     /* R4  - Volume Control */
+        0x000A,     /* R5  - Format Control */
+        0x0000,     /* R6  - Filter Control */
+        0x0000,     /* R7  - Mode Control 1 */
+        0x0002,     /* R8  - Mode Control 2 */
+        0x0000,     /* R9  - Reset */
+        0x0002,     /* R32 - ADDITONAL_CONTROL_1 */
+};
+
+
+static int wm8741_reset(struct snd_soc_codec *codec)
+{
+        return snd_soc_write(codec, WM8741_RESET, 0);
+}
+
+static const DECLARE_TLV_DB_SCALE(dac_tlv_fine, -12700, 13, 0);
+static const DECLARE_TLV_DB_SCALE(dac_tlv, -12700, 400, 0);
+
+static const struct snd_kcontrol_new wm8741_snd_controls[] = {
+SOC_DOUBLE_R_TLV("Fine Playback Volume", WM8741_DACLLSB_ATTENUATION,
+                 WM8741_DACRLSB_ATTENUATION, 1, 255, 1, dac_tlv_fine),
+SOC_DOUBLE_R_TLV("Playback Volume", WM8741_DACLMSB_ATTENUATION,
+                 WM8741_DACRMSB_ATTENUATION, 0, 511, 1, dac_tlv),
+};
+
+static const struct snd_soc_dapm_widget wm8741_dapm_widgets[] = {
+SND_SOC_DAPM_DAC("DACL", "Playback", SND_SOC_NOPM, 0, 0),
+SND_SOC_DAPM_DAC("DACR", "Playback", SND_SOC_NOPM, 0, 0),
+SND_SOC_DAPM_OUTPUT("VOUTLP"),
+SND_SOC_DAPM_OUTPUT("VOUTLN"),
+SND_SOC_DAPM_OUTPUT("VOUTRP"),
+SND_SOC_DAPM_OUTPUT("VOUTRN"),
+};
+
+static const struct snd_soc_dapm_route intercon[] = {
+        { "VOUTLP", NULL, "DACL" },
+        { "VOUTLN", NULL, "DACL" },
+        { "VOUTRP", NULL, "DACR" },
+        { "VOUTRN", NULL, "DACR" },
+};
+
+static int wm8741_add_widgets(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, wm8741_dapm_widgets,
+                                  ARRAY_SIZE(wm8741_dapm_widgets));
+
+        snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
+
+        return 0;
+}
+
+static struct {
+        int value;
+        int ratio;
+} lrclk_ratios[WM8741_NUM_RATES] = {
+        { 1, 256 },
+        { 2, 384 },
+        { 3, 512 },
+        { 4, 768 },
+};
+
+
+static int wm8741_startup(struct snd_pcm_substream *substream,
+                          struct snd_soc_dai *dai)
+{
+        struct snd_soc_codec *codec = dai->codec;
+        struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
+
+        /* The set of sample rates that can be supported depends on the
+         * MCLK supplied to the CODEC - enforce this.
+         */
+        if (!wm8741->sysclk) {
+                dev_err(codec->dev,
+                        "No MCLK configured, call set_sysclk() on init\n");
+                return -EINVAL;
+        }
+
+        snd_pcm_hw_constraint_list(substream->runtime, 0,
+                                   SNDRV_PCM_HW_PARAM_RATE,
+                                   &wm8741->rate_constraint);
+
+        return 0;
+}
+
+static int wm8741_hw_params(struct snd_pcm_substream *substream,
+                            struct snd_pcm_hw_params *params,
+                            struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_device *socdev = rtd->socdev;
+        struct snd_soc_codec *codec = socdev->card->codec;
+        struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
+        u16 iface = snd_soc_read(codec, WM8741_FORMAT_CONTROL) & 0x1FC;
+        int i;
+
+        /* Find a supported LRCLK ratio */
+        for (i = 0; i < ARRAY_SIZE(lrclk_ratios); i++) {
+                if (wm8741->sysclk / params_rate(params) ==
+                    lrclk_ratios[i].ratio)
+                        break;
+        }
+
+        /* Should never happen, should be handled by constraints */
+        if (i == ARRAY_SIZE(lrclk_ratios)) {
+                dev_err(codec->dev, "MCLK/fs ratio %d unsupported\n",
+                        wm8741->sysclk / params_rate(params));
+                return -EINVAL;
+        }
+
+        /* bit size */
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                break;
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                iface |= 0x0001;
+                break;
+        case SNDRV_PCM_FORMAT_S24_LE:
+                iface |= 0x0002;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                iface |= 0x0003;
+                break;
+        default:
+                dev_dbg(codec->dev, "wm8741_hw_params:    Unsupported bit size param = %d",
+                        params_format(params));
+                return -EINVAL;
+        }
+
+        dev_dbg(codec->dev, "wm8741_hw_params:    bit size param = %d",
+                params_format(params));
+
+        snd_soc_write(codec, WM8741_FORMAT_CONTROL, iface);
+        return 0;
+}
+
+static int wm8741_set_dai_sysclk(struct snd_soc_dai *codec_dai,
+                int clk_id, unsigned int freq, int dir)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec);
+        unsigned int val;
+        int i;
+
+        dev_dbg(codec->dev, "wm8741_set_dai_sysclk info: freq=%dHz\n", freq);
+
+        wm8741->sysclk = freq;
+
+        wm8741->rate_constraint.count = 0;
+
+        for (i = 0; i < ARRAY_SIZE(lrclk_ratios); i++) {
+                dev_dbg(codec->dev, "index = %d, ratio = %d, freq = %d",
+                                i, lrclk_ratios[i].ratio, freq);
+
+                val = freq / lrclk_ratios[i].ratio;
+                /* Check that it's a standard rate since core can't
+                 * cope with others and having the odd rates confuses
+                 * constraint matching.
+                 */
+                switch (val) {
+                case 32000:
+                case 44100:
+                case 48000:
+                case 64000:
+                case 88200:
+                case 96000:
+                        dev_dbg(codec->dev, "Supported sample rate: %dHz\n",
+                                val);
+                        wm8741->rate_constraint_list[i] = val;
+                        wm8741->rate_constraint.count++;
+                        break;
+                default:
+                        dev_dbg(codec->dev, "Skipping sample rate: %dHz\n",
+                                val);
+                }
+        }
+
+        /* Need at least one supported rate... */
+        if (wm8741->rate_constraint.count == 0)
+                return -EINVAL;
+
+        return 0;
+}
+
+static int wm8741_set_dai_fmt(struct snd_soc_dai *codec_dai,
+                unsigned int fmt)
+{
+        struct snd_soc_codec *codec = codec_dai->codec;
+        u16 iface = snd_soc_read(codec, WM8741_FORMAT_CONTROL) & 0x1C3;
+
+        /* check master/slave audio interface */
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* interface format */
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                iface |= 0x0008;
+                break;
+        case SND_SOC_DAIFMT_RIGHT_J:
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                iface |= 0x0004;
+                break;
+        case SND_SOC_DAIFMT_DSP_A:
+                iface |= 0x0003;
+                break;
+        case SND_SOC_DAIFMT_DSP_B:
+                iface |= 0x0013;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /* clock inversion */
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                break;
+        case SND_SOC_DAIFMT_IB_IF:
+                iface |= 0x0010;
+                break;
+        case SND_SOC_DAIFMT_IB_NF:
+                iface |= 0x0020;
+                break;
+        case SND_SOC_DAIFMT_NB_IF:
+                iface |= 0x0030;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+
+        dev_dbg(codec->dev, "wm8741_set_dai_fmt:    Format=%x, Clock Inv=%x\n",
+                                fmt & SND_SOC_DAIFMT_FORMAT_MASK,
+                                ((fmt & SND_SOC_DAIFMT_INV_MASK)));
+
+        snd_soc_write(codec, WM8741_FORMAT_CONTROL, iface);
+        return 0;
+}
+
+#define WM8741_RATES (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \
+                        SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | \
+                        SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 | \
+                        SNDRV_PCM_RATE_192000)
+
+#define WM8741_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
+                        SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
+
+static struct snd_soc_dai_ops wm8741_dai_ops = {
+        .startup        = wm8741_startup,
+        .hw_params      = wm8741_hw_params,
+        .set_sysclk     = wm8741_set_dai_sysclk,
+        .set_fmt        = wm8741_set_dai_fmt,
+};
+
+struct snd_soc_dai wm8741_dai = {
+        .name = "WM8741",
+        .playback = {
+                .stream_name = "Playback",
+                .channels_min = 2,  /* Mono modes not yet supported */
+                .channels_max = 2,
+                .rates = WM8741_RATES,
+                .formats = WM8741_FORMATS,
+        },
+        .ops = &wm8741_dai_ops,
+};
+EXPORT_SYMBOL_GPL(wm8741_dai);
+
+#ifdef CONFIG_PM
+static int wm8741_resume(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec = socdev->card->codec;
+        u16 *cache = codec->reg_cache;
+        int i;
+
+        /* RESTORE REG Cache */
+        for (i = 0; i < WM8741_REGISTER_COUNT; i++) {
+                if (cache[i] == wm8741_reg_defaults[i] || WM8741_RESET == i)
+                        continue;
+                snd_soc_write(codec, i, cache[i]);
+        }
+        return 0;
+}
+#else
+#define wm8741_suspend NULL
+#define wm8741_resume NULL
+#endif
+
+static int wm8741_probe(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+        struct snd_soc_codec *codec;
+        int ret = 0;
+
+        if (wm8741_codec == NULL) {
+                dev_err(&pdev->dev, "Codec device not registered\n");
+                return -ENODEV;
+        }
+
+        socdev->card->codec = wm8741_codec;
+        codec = wm8741_codec;
+
+        /* register pcms */
+        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
+        if (ret < 0) {
+                dev_err(codec->dev, "failed to create pcms: %d\n", ret);
+                goto pcm_err;
+        }
+
+        snd_soc_add_controls(codec, wm8741_snd_controls,
+                             ARRAY_SIZE(wm8741_snd_controls));
+        wm8741_add_widgets(codec);
+
+        return ret;
+
+pcm_err:
+        return ret;
+}
+
+static int wm8741_remove(struct platform_device *pdev)
+{
+        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
+
+        snd_soc_free_pcms(socdev);
+        snd_soc_dapm_free(socdev);
+
+        return 0;
+}
+
+struct snd_soc_codec_device soc_codec_dev_wm8741 = {
+        .probe =        wm8741_probe,
+        .remove =       wm8741_remove,
+        .resume =       wm8741_resume,
+};
+EXPORT_SYMBOL_GPL(soc_codec_dev_wm8741);
+
+static int wm8741_register(struct wm8741_priv *wm8741,
+                           enum snd_soc_control_type control)
+{
+        int ret;
+        struct snd_soc_codec *codec = &wm8741->codec;
+        int i;
+
+        if (wm8741_codec) {
+                dev_err(codec->dev, "Another WM8741 is registered\n");
+                return -EINVAL;
+        }
+
+        mutex_init(&codec->mutex);
+        INIT_LIST_HEAD(&codec->dapm_widgets);
+        INIT_LIST_HEAD(&codec->dapm_paths);
+
+        snd_soc_codec_set_drvdata(codec, wm8741);
+        codec->name = "WM8741";
+        codec->owner = THIS_MODULE;
+        codec->bias_level = SND_SOC_BIAS_OFF;
+        codec->set_bias_level = NULL;
+        codec->dai = &wm8741_dai;
+        codec->num_dai = 1;
+        codec->reg_cache_size = WM8741_REGISTER_COUNT;
+        codec->reg_cache = &wm8741->reg_cache;
+
+        wm8741->rate_constraint.list = &wm8741->rate_constraint_list[0];
+        wm8741->rate_constraint.count =
+                ARRAY_SIZE(wm8741->rate_constraint_list);
+
+        memcpy(codec->reg_cache, wm8741_reg_defaults,
+                sizeof(wm8741->reg_cache));
+
+        ret = snd_soc_codec_set_cache_io(codec, 7, 9, control);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
+                goto err;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++)
+                wm8741->supplies[i].supply = wm8741_supply_names[i];
+
+        ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8741->supplies),
+                                 wm8741->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to request supplies: %d\n", ret);
+                goto err;
+        }
+
+        ret = regulator_bulk_enable(ARRAY_SIZE(wm8741->supplies),
+                                    wm8741->supplies);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to enable supplies: %d\n", ret);
+                goto err_get;
+        }
+
+        ret = wm8741_reset(codec);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to issue reset\n");
+                goto err_enable;
+        }
+
+        wm8741_dai.dev = codec->dev;
+
+        /* Change some default settings - latch VU */
+        wm8741->reg_cache[WM8741_DACLLSB_ATTENUATION] |= WM8741_UPDATELL;
+        wm8741->reg_cache[WM8741_DACLMSB_ATTENUATION] |= WM8741_UPDATELM;
+        wm8741->reg_cache[WM8741_DACRLSB_ATTENUATION] |= WM8741_UPDATERL;
+        wm8741->reg_cache[WM8741_DACRLSB_ATTENUATION] |= WM8741_UPDATERM;
+
+        wm8741_codec = codec;
+
+        ret = snd_soc_register_codec(codec);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register codec: %d\n", ret);
+                return ret;
+        }
+
+        ret = snd_soc_register_dai(&wm8741_dai);
+        if (ret != 0) {
+                dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
+                snd_soc_unregister_codec(codec);
+                return ret;
+        }
+
+        dev_dbg(codec->dev, "Successful registration\n");
+        return 0;
+
+err_enable:
+        regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
+
+err_get:
+        regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
+
+err:
+        kfree(wm8741);
+        return ret;
+}
+
+static void wm8741_unregister(struct wm8741_priv *wm8741)
+{
+        regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies);
+
+        snd_soc_unregister_dai(&wm8741_dai);
+        snd_soc_unregister_codec(&wm8741->codec);
+        kfree(wm8741);
+        wm8741_codec = NULL;
+}
+
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+static __devinit int wm8741_i2c_probe(struct i2c_client *i2c,
+                                      const struct i2c_device_id *id)
+{
+        struct wm8741_priv *wm8741;
+        struct snd_soc_codec *codec;
+
+        wm8741 = kzalloc(sizeof(struct wm8741_priv), GFP_KERNEL);
+        if (wm8741 == NULL)
+                return -ENOMEM;
+
+        codec = &wm8741->codec;
+        codec->hw_write = (hw_write_t)i2c_master_send;
+
+        i2c_set_clientdata(i2c, wm8741);
+        codec->control_data = i2c;
+
+        codec->dev = &i2c->dev;
+
+        return wm8741_register(wm8741, SND_SOC_I2C);
+}
+
+static __devexit int wm8741_i2c_remove(struct i2c_client *client)
+{
+        struct wm8741_priv *wm8741 = i2c_get_clientdata(client);
+        wm8741_unregister(wm8741);
+        return 0;
+}
+
+static const struct i2c_device_id wm8741_i2c_id[] = {
+        { "wm8741", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm8741_i2c_id);
+
+
+static struct i2c_driver wm8741_i2c_driver = {
+        .driver = {
+                .name = "WM8741",
+                .owner = THIS_MODULE,
+        },
+        .probe =    wm8741_i2c_probe,
+        .remove =   __devexit_p(wm8741_i2c_remove),
+        .id_table = wm8741_i2c_id,
+};
+#endif
+
+static int __init wm8741_modinit(void)
+{
+        int ret;
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        ret = i2c_add_driver(&wm8741_i2c_driver);
+        if (ret != 0) {
+                printk(KERN_ERR "Failed to register WM8741 I2C driver: %d\n",
+                       ret);
+        }
+#endif
+        return 0;
+}
+module_init(wm8741_modinit);
+
+static void __exit wm8741_exit(void)
+{
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+        i2c_del_driver(&wm8741_i2c_driver);
+#endif
+}
+module_exit(wm8741_exit);
+
+MODULE_DESCRIPTION("ASoC WM8741 driver");
+MODULE_AUTHOR("Ian Lartey <ian@opensource.wolfsonmicro.com>");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/codecs/wm8741.h b/sound/soc/codecs/wm8741.h
new file mode 100644
index 000000000000..fdef6ecd1f6f
--- /dev/null
+++ b/sound/soc/codecs/wm8741.h
@@ -0,0 +1,214 @@
+/*
+ * wm8741.h  --  WM8423 ASoC driver
+ *
+ * Copyright 2010 Wolfson Microelectronics, plc
+ *
+ * Author: Ian Lartey <ian@opensource.wolfsonmicro.com>
+ *
+ * Based on wm8753.h
+ *
+ * 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.
+ */
+
+#ifndef _WM8741_H
+#define _WM8741_H
+
+/*
+ * Register values.
+ */
+#define WM8741_DACLLSB_ATTENUATION              0x00
+#define WM8741_DACLMSB_ATTENUATION              0x01
+#define WM8741_DACRLSB_ATTENUATION              0x02
+#define WM8741_DACRMSB_ATTENUATION              0x03
+#define WM8741_VOLUME_CONTROL                   0x04
+#define WM8741_FORMAT_CONTROL                   0x05
+#define WM8741_FILTER_CONTROL                   0x06
+#define WM8741_MODE_CONTROL_1                   0x07
+#define WM8741_MODE_CONTROL_2                   0x08
+#define WM8741_RESET                            0x09
+#define WM8741_ADDITIONAL_CONTROL_1             0x20
+
+#define WM8741_REGISTER_COUNT                   11
+#define WM8741_MAX_REGISTER                     0x20
+
+/*
+ * Field Definitions.
+ */
+
+/*
+ * R0 (0x00) - DACLLSB_ATTENUATION
+ */
+#define WM8741_UPDATELL                         0x0020  /* UPDATELL */
+#define WM8741_UPDATELL_MASK                    0x0020  /* UPDATELL */
+#define WM8741_UPDATELL_SHIFT                        5  /* UPDATELL */
+#define WM8741_UPDATELL_WIDTH                        1  /* UPDATELL */
+#define WM8741_LAT_4_0_MASK                     0x001F  /* LAT[4:0] - [4:0] */
+#define WM8741_LAT_4_0_SHIFT                         0  /* LAT[4:0] - [4:0] */
+#define WM8741_LAT_4_0_WIDTH                         5  /* LAT[4:0] - [4:0] */
+
+/*
+ * R1 (0x01) - DACLMSB_ATTENUATION
+ */
+#define WM8741_UPDATELM                         0x0020  /* UPDATELM */
+#define WM8741_UPDATELM_MASK                    0x0020  /* UPDATELM */
+#define WM8741_UPDATELM_SHIFT                        5  /* UPDATELM */
+#define WM8741_UPDATELM_WIDTH                        1  /* UPDATELM */
+#define WM8741_LAT_9_5_0_MASK                   0x001F  /* LAT[9:5] - [4:0] */
+#define WM8741_LAT_9_5_0_SHIFT                       0  /* LAT[9:5] - [4:0] */
+#define WM8741_LAT_9_5_0_WIDTH                       5  /* LAT[9:5] - [4:0] */
+
+/*
+ * R2 (0x02) - DACRLSB_ATTENUATION
+ */
+#define WM8741_UPDATERL                         0x0020  /* UPDATERL */
+#define WM8741_UPDATERL_MASK                    0x0020  /* UPDATERL */
+#define WM8741_UPDATERL_SHIFT                        5  /* UPDATERL */
+#define WM8741_UPDATERL_WIDTH                        1  /* UPDATERL */
+#define WM8741_RAT_4_0_MASK                     0x001F  /* RAT[4:0] - [4:0] */
+#define WM8741_RAT_4_0_SHIFT                         0  /* RAT[4:0] - [4:0] */
+#define WM8741_RAT_4_0_WIDTH                         5  /* RAT[4:0] - [4:0] */
+
+/*
+ * R3 (0x03) - DACRMSB_ATTENUATION
+ */
+#define WM8741_UPDATERM                         0x0020  /* UPDATERM */
+#define WM8741_UPDATERM_MASK                    0x0020  /* UPDATERM */
+#define WM8741_UPDATERM_SHIFT                        5  /* UPDATERM */
+#define WM8741_UPDATERM_WIDTH                        1  /* UPDATERM */
+#define WM8741_RAT_9_5_0_MASK                   0x001F  /* RAT[9:5] - [4:0] */
+#define WM8741_RAT_9_5_0_SHIFT                       0  /* RAT[9:5] - [4:0] */
+#define WM8741_RAT_9_5_0_WIDTH                       5  /* RAT[9:5] - [4:0] */
+
+/*
+ * R4 (0x04) - VOLUME_CONTROL
+ */
+#define WM8741_AMUTE                            0x0080  /* AMUTE */
+#define WM8741_AMUTE_MASK                       0x0080  /* AMUTE */
+#define WM8741_AMUTE_SHIFT                           7  /* AMUTE */
+#define WM8741_AMUTE_WIDTH                           1  /* AMUTE */
+#define WM8741_ZFLAG_MASK                       0x0060  /* ZFLAG - [6:5] */
+#define WM8741_ZFLAG_SHIFT                           5  /* ZFLAG - [6:5] */
+#define WM8741_ZFLAG_WIDTH                           2  /* ZFLAG - [6:5] */
+#define WM8741_IZD                              0x0010  /* IZD */
+#define WM8741_IZD_MASK                         0x0010  /* IZD */
+#define WM8741_IZD_SHIFT                             4  /* IZD */
+#define WM8741_IZD_WIDTH                             1  /* IZD */
+#define WM8741_SOFT                             0x0008  /* SOFT MUTE */
+#define WM8741_SOFT_MASK                        0x0008  /* SOFT MUTE */
+#define WM8741_SOFT_SHIFT                            3  /* SOFT MUTE */
+#define WM8741_SOFT_WIDTH                            1  /* SOFT MUTE */
+#define WM8741_ATC                              0x0004  /* ATC */
+#define WM8741_ATC_MASK                         0x0004  /* ATC */
+#define WM8741_ATC_SHIFT                             2  /* ATC */
+#define WM8741_ATC_WIDTH                             1  /* ATC */
+#define WM8741_ATT2DB                           0x0002  /* ATT2DB */
+#define WM8741_ATT2DB_MASK                      0x0002  /* ATT2DB */
+#define WM8741_ATT2DB_SHIFT                          1  /* ATT2DB */
+#define WM8741_ATT2DB_WIDTH                          1  /* ATT2DB */
+#define WM8741_VOL_RAMP                         0x0001  /* VOL_RAMP */
+#define WM8741_VOL_RAMP_MASK                    0x0001  /* VOL_RAMP */
+#define WM8741_VOL_RAMP_SHIFT                        0  /* VOL_RAMP */
+#define WM8741_VOL_RAMP_WIDTH                        1  /* VOL_RAMP */
+
+/*
+ * R5 (0x05) - FORMAT_CONTROL
+ */
+#define WM8741_PWDN                             0x0080  /* PWDN */
+#define WM8741_PWDN_MASK                        0x0080  /* PWDN */
+#define WM8741_PWDN_SHIFT                            7  /* PWDN */
+#define WM8741_PWDN_WIDTH                            1  /* PWDN */
+#define WM8741_REV                              0x0040  /* REV */
+#define WM8741_REV_MASK                         0x0040  /* REV */
+#define WM8741_REV_SHIFT                             6  /* REV */
+#define WM8741_REV_WIDTH                             1  /* REV */
+#define WM8741_BCP                              0x0020  /* BCP */
+#define WM8741_BCP_MASK                         0x0020  /* BCP */
+#define WM8741_BCP_SHIFT                             5  /* BCP */
+#define WM8741_BCP_WIDTH                             1  /* BCP */
+#define WM8741_LRP                              0x0010  /* LRP */
+#define WM8741_LRP_MASK                         0x0010  /* LRP */
+#define WM8741_LRP_SHIFT                             4  /* LRP */
+#define WM8741_LRP_WIDTH                             1  /* LRP */
+#define WM8741_FMT_MASK                         0x000C  /* FMT - [3:2] */
+#define WM8741_FMT_SHIFT                             2  /* FMT - [3:2] */
+#define WM8741_FMT_WIDTH                             2  /* FMT - [3:2] */
+#define WM8741_IWL_MASK                         0x0003  /* IWL - [1:0] */
+#define WM8741_IWL_SHIFT                             0  /* IWL - [1:0] */
+#define WM8741_IWL_WIDTH                             2  /* IWL - [1:0] */
+
+/*
+ * R6 (0x06) - FILTER_CONTROL
+ */
+#define WM8741_ZFLAG_HI                         0x0080  /* ZFLAG_HI */
+#define WM8741_ZFLAG_HI_MASK                    0x0080  /* ZFLAG_HI */
+#define WM8741_ZFLAG_HI_SHIFT                        7  /* ZFLAG_HI */
+#define WM8741_ZFLAG_HI_WIDTH                        1  /* ZFLAG_HI */
+#define WM8741_DEEMPH_MASK                      0x0060  /* DEEMPH - [6:5] */
+#define WM8741_DEEMPH_SHIFT                          5  /* DEEMPH - [6:5] */
+#define WM8741_DEEMPH_WIDTH                          2  /* DEEMPH - [6:5] */
+#define WM8741_DSDFILT_MASK                     0x0018  /* DSDFILT - [4:3] */
+#define WM8741_DSDFILT_SHIFT                         3  /* DSDFILT - [4:3] */
+#define WM8741_DSDFILT_WIDTH                         2  /* DSDFILT - [4:3] */
+#define WM8741_FIRSEL_MASK                      0x0007  /* FIRSEL - [2:0] */
+#define WM8741_FIRSEL_SHIFT                          0  /* FIRSEL - [2:0] */
+#define WM8741_FIRSEL_WIDTH                          3  /* FIRSEL - [2:0] */
+
+/*
+ * R7 (0x07) - MODE_CONTROL_1
+ */
+#define WM8741_MODE8X                           0x0080  /* MODE8X */
+#define WM8741_MODE8X_MASK                      0x0080  /* MODE8X */
+#define WM8741_MODE8X_SHIFT                          7  /* MODE8X */
+#define WM8741_MODE8X_WIDTH                          1  /* MODE8X */
+#define WM8741_OSR_MASK                         0x0060  /* OSR - [6:5] */
+#define WM8741_OSR_SHIFT                             5  /* OSR - [6:5] */
+#define WM8741_OSR_WIDTH                             2  /* OSR - [6:5] */
+#define WM8741_SR_MASK                          0x001C  /* SR - [4:2] */
+#define WM8741_SR_SHIFT                              2  /* SR - [4:2] */
+#define WM8741_SR_WIDTH                              3  /* SR - [4:2] */
+#define WM8741_MODESEL_MASK                     0x0003  /* MODESEL - [1:0] */
+#define WM8741_MODESEL_SHIFT                         0  /* MODESEL - [1:0] */
+#define WM8741_MODESEL_WIDTH                         2  /* MODESEL - [1:0] */
+
+/*
+ * R8 (0x08) - MODE_CONTROL_2
+ */
+#define WM8741_DSD_GAIN                         0x0040  /* DSD_GAIN */
+#define WM8741_DSD_GAIN_MASK                    0x0040  /* DSD_GAIN */
+#define WM8741_DSD_GAIN_SHIFT                        6  /* DSD_GAIN */
+#define WM8741_DSD_GAIN_WIDTH                        1  /* DSD_GAIN */
+#define WM8741_SDOUT                            0x0020  /* SDOUT */
+#define WM8741_SDOUT_MASK                       0x0020  /* SDOUT */
+#define WM8741_SDOUT_SHIFT                           5  /* SDOUT */
+#define WM8741_SDOUT_WIDTH                           1  /* SDOUT */
+#define WM8741_DOUT                             0x0010  /* DOUT */
+#define WM8741_DOUT_MASK                        0x0010  /* DOUT */
+#define WM8741_DOUT_SHIFT                            4  /* DOUT */
+#define WM8741_DOUT_WIDTH                            1  /* DOUT */
+#define WM8741_DIFF_MASK                        0x000C  /* DIFF - [3:2] */
+#define WM8741_DIFF_SHIFT                            2  /* DIFF - [3:2] */
+#define WM8741_DIFF_WIDTH                            2  /* DIFF - [3:2] */
+#define WM8741_DITHER_MASK                      0x0003  /* DITHER - [1:0] */
+#define WM8741_DITHER_SHIFT                          0  /* DITHER - [1:0] */
+#define WM8741_DITHER_WIDTH                          2  /* DITHER - [1:0] */
+
+/*
+ * R32 (0x20) - ADDITONAL_CONTROL_1
+ */
+#define WM8741_DSD_LEVEL                        0x0002  /* DSD_LEVEL */
+#define WM8741_DSD_LEVEL_MASK                   0x0002  /* DSD_LEVEL */
+#define WM8741_DSD_LEVEL_SHIFT                       1  /* DSD_LEVEL */
+#define WM8741_DSD_LEVEL_WIDTH                       1  /* DSD_LEVEL */
+#define WM8741_DSD_NO_NOTCH                     0x0001  /* DSD_NO_NOTCH */
+#define WM8741_DSD_NO_NOTCH_MASK                0x0001  /* DSD_NO_NOTCH */
+#define WM8741_DSD_NO_NOTCH_SHIFT                    0  /* DSD_NO_NOTCH */
+#define WM8741_DSD_NO_NOTCH_WIDTH                    1  /* DSD_NO_NOTCH */
+
+#define  WM8741_SYSCLK 0
+
+extern struct snd_soc_dai wm8741_dai;
+extern struct snd_soc_codec_device soc_codec_dev_wm8741;
+
+#endif
diff --git a/sound/soc/codecs/wm8750.c b/sound/soc/codecs/wm8750.c
index 9407e193fcc3..e2c05e3e323a 100644
--- a/sound/soc/codecs/wm8750.c
+++ b/sound/soc/codecs/wm8750.c
@@ -884,6 +884,7 @@ static int wm8750_i2c_remove(struct i2c_client *client)
 
 static const struct i2c_device_id wm8750_i2c_id[] = {
         { "wm8750", 0 },
+        { "wm8987", 0 }, /* WM8987 is register compatible with WM8750 */
         { }
 };
 MODULE_DEVICE_TABLE(i2c, wm8750_i2c_id);
@@ -925,14 +926,22 @@ static int __devexit wm8750_spi_remove(struct spi_device *spi)
         return 0;
 }
 
+static const struct spi_device_id wm8750_spi_id[] = {
+        { "wm8750", 0 },
+        { "wm8987", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(spi, wm8750_spi_id);
+
 static struct spi_driver wm8750_spi_driver = {
         .driver = {
-                .name   = "wm8750",
+                .name   = "WM8750 SPI Codec",
                 .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
         },
         .probe          = wm8750_spi_probe,
         .remove         = __devexit_p(wm8750_spi_remove),
+        .id_table       = wm8750_spi_id,
 };
 #endif
 
diff --git a/sound/soc/codecs/wm8776.c b/sound/soc/codecs/wm8776.c
index 4e212ed62ea6..f8154e661524 100644
--- a/sound/soc/codecs/wm8776.c
+++ b/sound/soc/codecs/wm8776.c
@@ -178,13 +178,6 @@ static int wm8776_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
         case SND_SOC_DAIFMT_LEFT_J:
                 iface |= 0x0001;
                 break;
-                /* FIXME: CHECK A/B */
-        case SND_SOC_DAIFMT_DSP_A:
-                iface |= 0x0003;
-                break;
-        case SND_SOC_DAIFMT_DSP_B:
-                iface |= 0x0007;
-                break;
         default:
                 return -EINVAL;
         }
diff --git a/sound/soc/codecs/wm8904.c b/sound/soc/codecs/wm8904.c
index 87f14f8675fa..f7dcabf6283c 100644
--- a/sound/soc/codecs/wm8904.c
+++ b/sound/soc/codecs/wm8904.c
@@ -2433,7 +2433,8 @@ static int wm8904_register(struct wm8904_priv *wm8904,
 
         if (wm8904_codec) {
                 dev_err(codec->dev, "Another WM8904 is registered\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto err;
         }
 
         mutex_init(&codec->mutex);
@@ -2462,7 +2463,8 @@ static int wm8904_register(struct wm8904_priv *wm8904,
         default:
                 dev_err(codec->dev, "Unknown device type %d\n",
                         wm8904->devtype);
-                return -EINVAL;
+                ret = -EINVAL;
+                goto err;
         }
 
         memcpy(codec->reg_cache, wm8904_reg, sizeof(wm8904_reg));
@@ -2566,18 +2568,19 @@ static int wm8904_register(struct wm8904_priv *wm8904,
         ret = snd_soc_register_codec(codec);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register codec: %d\n", ret);
-                return ret;
+                goto err_enable;
         }
 
         ret = snd_soc_register_dai(&wm8904_dai);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
-                snd_soc_unregister_codec(codec);
-                return ret;
+                goto err_codec;
         }
 
         return 0;
 
+err_codec:
+        snd_soc_unregister_codec(codec);
 err_enable:
         regulator_bulk_disable(ARRAY_SIZE(wm8904->supplies), wm8904->supplies);
 err_get:
diff --git a/sound/soc/codecs/wm8940.c b/sound/soc/codecs/wm8940.c
index e3c4bbfaae27..f0c11138e610 100644
--- a/sound/soc/codecs/wm8940.c
+++ b/sound/soc/codecs/wm8940.c
@@ -845,6 +845,7 @@ static void wm8940_unregister(struct wm8940_priv *wm8940)
 static int wm8940_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
+        int ret;
         struct wm8940_priv *wm8940;
         struct snd_soc_codec *codec;
 
@@ -858,7 +859,11 @@ static int wm8940_i2c_probe(struct i2c_client *i2c,
         codec->control_data = i2c;
         codec->dev = &i2c->dev;
 
-        return wm8940_register(wm8940, SND_SOC_I2C);
+        ret = wm8940_register(wm8940, SND_SOC_I2C);
+        if (ret < 0)
+                kfree(wm8940);
+
+        return ret;
 }
 
 static int __devexit wm8940_i2c_remove(struct i2c_client *client)
diff --git a/sound/soc/codecs/wm8955.c b/sound/soc/codecs/wm8955.c
index fedb76452f1b..5f025593d84d 100644
--- a/sound/soc/codecs/wm8955.c
+++ b/sound/soc/codecs/wm8955.c
@@ -964,7 +964,8 @@ static int wm8955_register(struct wm8955_priv *wm8955,
 
         if (wm8955_codec) {
                 dev_err(codec->dev, "Another WM8955 is registered\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto err;
         }
 
         mutex_init(&codec->mutex);
@@ -1047,18 +1048,19 @@ static int wm8955_register(struct wm8955_priv *wm8955,
         ret = snd_soc_register_codec(codec);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register codec: %d\n", ret);
-                return ret;
+                goto err_enable;
         }
 
         ret = snd_soc_register_dai(&wm8955_dai);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
-                snd_soc_unregister_codec(codec);
-                return ret;
+                goto err_codec;
         }
 
         return 0;
 
+err_codec:
+        snd_soc_unregister_codec(codec);
 err_enable:
         regulator_bulk_disable(ARRAY_SIZE(wm8955->supplies), wm8955->supplies);
 err_get:
diff --git a/sound/soc/codecs/wm8960.c b/sound/soc/codecs/wm8960.c
index 7233cc68435a..3c6ee61f6c95 100644
--- a/sound/soc/codecs/wm8960.c
+++ b/sound/soc/codecs/wm8960.c
@@ -79,12 +79,13 @@ struct wm8960_priv {
         struct snd_soc_dapm_widget *lout1;
         struct snd_soc_dapm_widget *rout1;
         struct snd_soc_dapm_widget *out3;
+        bool deemph;
+        int playback_fs;
 };
 
 #define wm8960_reset(c) snd_soc_write(c, WM8960_RESET, 0)
 
 /* enumerated controls */
-static const char *wm8960_deemph[] = {"None", "32Khz", "44.1Khz", "48Khz"};
 static const char *wm8960_polarity[] = {"No Inversion", "Left Inverted",
         "Right Inverted", "Stereo Inversion"};
 static const char *wm8960_3d_upper_cutoff[] = {"High", "Low"};
@@ -93,7 +94,6 @@ static const char *wm8960_alcfunc[] = {"Off", "Right", "Left", "Stereo"};
 static const char *wm8960_alcmode[] = {"ALC", "Limiter"};
 
 static const struct soc_enum wm8960_enum[] = {
-        SOC_ENUM_SINGLE(WM8960_DACCTL1, 1, 4, wm8960_deemph),
         SOC_ENUM_SINGLE(WM8960_DACCTL1, 5, 4, wm8960_polarity),
         SOC_ENUM_SINGLE(WM8960_DACCTL2, 5, 4, wm8960_polarity),
         SOC_ENUM_SINGLE(WM8960_3D, 6, 2, wm8960_3d_upper_cutoff),
@@ -102,6 +102,59 @@ static const struct soc_enum wm8960_enum[] = {
         SOC_ENUM_SINGLE(WM8960_ALC3, 8, 2, wm8960_alcmode),
 };
 
+static const int deemph_settings[] = { 0, 32000, 44100, 48000 };
+
+static int wm8960_set_deemph(struct snd_soc_codec *codec)
+{
+        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
+        int val, i, best;
+
+        /* If we're using deemphasis select the nearest available sample
+         * rate.
+         */
+        if (wm8960->deemph) {
+                best = 1;
+                for (i = 2; i < ARRAY_SIZE(deemph_settings); i++) {
+                        if (abs(deemph_settings[i] - wm8960->playback_fs) <
+                            abs(deemph_settings[best] - wm8960->playback_fs))
+                                best = i;
+                }
+
+                val = best << 1;
+        } else {
+                val = 0;
+        }
+
+        dev_dbg(codec->dev, "Set deemphasis %d\n", val);
+
+        return snd_soc_update_bits(codec, WM8960_DACCTL1,
+                                   0x6, val);
+}
+
+static int wm8960_get_deemph(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
+
+        return wm8960->deemph;
+}
+
+static int wm8960_put_deemph(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
+        int deemph = ucontrol->value.enumerated.item[0];
+
+        if (deemph > 1)
+                return -EINVAL;
+
+        wm8960->deemph = deemph;
+
+        return wm8960_set_deemph(codec);
+}
+
 static const DECLARE_TLV_DB_SCALE(adc_tlv, -9700, 50, 0);
 static const DECLARE_TLV_DB_SCALE(dac_tlv, -12700, 50, 1);
 static const DECLARE_TLV_DB_SCALE(bypass_tlv, -2100, 300, 0);
@@ -131,23 +184,24 @@ SOC_SINGLE("Speaker DC Volume", WM8960_CLASSD3, 3, 5, 0),
 SOC_SINGLE("Speaker AC Volume", WM8960_CLASSD3, 0, 5, 0),
 
 SOC_SINGLE("PCM Playback -6dB Switch", WM8960_DACCTL1, 7, 1, 0),
-SOC_ENUM("ADC Polarity", wm8960_enum[1]),
-SOC_ENUM("Playback De-emphasis", wm8960_enum[0]),
+SOC_ENUM("ADC Polarity", wm8960_enum[0]),
 SOC_SINGLE("ADC High Pass Filter Switch", WM8960_DACCTL1, 0, 1, 0),
 
 SOC_ENUM("DAC Polarity", wm8960_enum[2]),
+SOC_SINGLE_BOOL_EXT("DAC Deemphasis Switch", 0,
+                    wm8960_get_deemph, wm8960_put_deemph),
 
-SOC_ENUM("3D Filter Upper Cut-Off", wm8960_enum[3]),
-SOC_ENUM("3D Filter Lower Cut-Off", wm8960_enum[4]),
+SOC_ENUM("3D Filter Upper Cut-Off", wm8960_enum[2]),
+SOC_ENUM("3D Filter Lower Cut-Off", wm8960_enum[3]),
 SOC_SINGLE("3D Volume", WM8960_3D, 1, 15, 0),
 SOC_SINGLE("3D Switch", WM8960_3D, 0, 1, 0),
 
-SOC_ENUM("ALC Function", wm8960_enum[5]),
+SOC_ENUM("ALC Function", wm8960_enum[4]),
 SOC_SINGLE("ALC Max Gain", WM8960_ALC1, 4, 7, 0),
 SOC_SINGLE("ALC Target", WM8960_ALC1, 0, 15, 1),
 SOC_SINGLE("ALC Min Gain", WM8960_ALC2, 4, 7, 0),
 SOC_SINGLE("ALC Hold Time", WM8960_ALC2, 0, 15, 0),
-SOC_ENUM("ALC Mode", wm8960_enum[6]),
+SOC_ENUM("ALC Mode", wm8960_enum[5]),
 SOC_SINGLE("ALC Decay", WM8960_ALC3, 4, 15, 0),
 SOC_SINGLE("ALC Attack", WM8960_ALC3, 0, 15, 0),
 
@@ -433,6 +487,21 @@ static int wm8960_set_dai_fmt(struct snd_soc_dai *codec_dai,
         return 0;
 }
 
+static struct {
+        int rate;
+        unsigned int val;
+} alc_rates[] = {
+        { 48000, 0 },
+        { 44100, 0 },
+        { 32000, 1 },
+        { 22050, 2 },
+        { 24000, 2 },
+        { 16000, 3 },
+        { 11250, 4 },
+        { 12000, 4 },
+        {  8000, 5 },
+};
+
 static int wm8960_hw_params(struct snd_pcm_substream *substream,
                             struct snd_pcm_hw_params *params,
                             struct snd_soc_dai *dai)
@@ -440,7 +509,9 @@ static int wm8960_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_device *socdev = rtd->socdev;
         struct snd_soc_codec *codec = socdev->card->codec;
+        struct wm8960_priv *wm8960 = snd_soc_codec_get_drvdata(codec);
         u16 iface = snd_soc_read(codec, WM8960_IFACE1) & 0xfff3;
+        int i;
 
         /* bit size */
         switch (params_format(params)) {
@@ -454,6 +525,18 @@ static int wm8960_hw_params(struct snd_pcm_substream *substream,
                 break;
         }
 
+        /* Update filters for the new rate */
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                wm8960->playback_fs = params_rate(params);
+                wm8960_set_deemph(codec);
+        } else {
+                for (i = 0; i < ARRAY_SIZE(alc_rates); i++)
+                        if (alc_rates[i].rate == params_rate(params))
+                                snd_soc_update_bits(codec,
+                                                    WM8960_ADDCTL3, 0x7,
+                                                    alc_rates[i].val);
+        }
+
         /* set iface */
         snd_soc_write(codec, WM8960_IFACE1, iface);
         return 0;
diff --git a/sound/soc/codecs/wm8961.c b/sound/soc/codecs/wm8961.c
index 5b9a756242f1..2549d3a297ab 100644
--- a/sound/soc/codecs/wm8961.c
+++ b/sound/soc/codecs/wm8961.c
@@ -1102,7 +1102,7 @@ static int wm8961_register(struct wm8961_priv *wm8961)
         ret = wm8961_reset(codec);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to issue reset\n");
-                return ret;
+                goto err;
         }
 
         /* Enable class W */
@@ -1147,18 +1147,19 @@ static int wm8961_register(struct wm8961_priv *wm8961)
         ret = snd_soc_register_codec(codec);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register codec: %d\n", ret);
-                return ret;
+                goto err;
         }
 
         ret = snd_soc_register_dai(&wm8961_dai);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
-                snd_soc_unregister_codec(codec);
-                return ret;
+                goto err_codec;
         }
 
         return 0;
 
+err_codec:
+        snd_soc_unregister_codec(codec);
 err:
         kfree(wm8961);
         return ret;
diff --git a/sound/soc/codecs/wm8974.c b/sound/soc/codecs/wm8974.c
index a2c4b2f37cca..1468fe10cbbe 100644
--- a/sound/soc/codecs/wm8974.c
+++ b/sound/soc/codecs/wm8974.c
@@ -670,7 +670,8 @@ static __devinit int wm8974_register(struct wm8974_priv *wm8974)
 
         if (wm8974_codec) {
                 dev_err(codec->dev, "Another WM8974 is registered\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto err;
         }
 
         mutex_init(&codec->mutex);
diff --git a/sound/soc/codecs/wm8978.c b/sound/soc/codecs/wm8978.c
index 51d5f433215c..8a1ad778e7e3 100644
--- a/sound/soc/codecs/wm8978.c
+++ b/sound/soc/codecs/wm8978.c
@@ -1076,7 +1076,6 @@ static __devinit int wm8978_register(struct wm8978_priv *wm8978)
 err_codec:
         snd_soc_unregister_codec(codec);
 err:
-        kfree(wm8978);
         return ret;
 }
 
@@ -1085,13 +1084,13 @@ static __devexit void wm8978_unregister(struct wm8978_priv *wm8978)
         wm8978_set_bias_level(&wm8978->codec, SND_SOC_BIAS_OFF);
         snd_soc_unregister_dai(&wm8978_dai);
         snd_soc_unregister_codec(&wm8978->codec);
-        kfree(wm8978);
         wm8978_codec = NULL;
 }
 
 static __devinit int wm8978_i2c_probe(struct i2c_client *i2c,
                                       const struct i2c_device_id *id)
 {
+        int ret;
         struct wm8978_priv *wm8978;
         struct snd_soc_codec *codec;
 
@@ -1107,13 +1106,18 @@ static __devinit int wm8978_i2c_probe(struct i2c_client *i2c,
 
         codec->dev = &i2c->dev;
 
-        return wm8978_register(wm8978);
+        ret = wm8978_register(wm8978);
+        if (ret < 0)
+                kfree(wm8978);
+
+        return ret;
 }
 
 static __devexit int wm8978_i2c_remove(struct i2c_client *client)
 {
         struct wm8978_priv *wm8978 = i2c_get_clientdata(client);
         wm8978_unregister(wm8978);
+        kfree(wm8978);
         return 0;
 }
 
diff --git a/sound/soc/codecs/wm8990.c b/sound/soc/codecs/wm8990.c
index c018772cc430..dd8d909788c1 100644
--- a/sound/soc/codecs/wm8990.c
+++ b/sound/soc/codecs/wm8990.c
@@ -30,8 +30,6 @@
 
 #include "wm8990.h"
 
-#define WM8990_VERSION "0.2"
-
 /* codec private data */
 struct wm8990_priv {
         unsigned int sysclk;
@@ -1511,8 +1509,6 @@ static int wm8990_probe(struct platform_device *pdev)
         struct wm8990_priv *wm8990;
         int ret;
 
-        pr_info("WM8990 Audio Codec %s\n", WM8990_VERSION);
-
         setup = socdev->codec_data;
         codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
         if (codec == NULL)
diff --git a/sound/soc/codecs/wm8994.c b/sound/soc/codecs/wm8994.c
index e84a1177f350..522249d5c2b4 100644
--- a/sound/soc/codecs/wm8994.c
+++ b/sound/soc/codecs/wm8994.c
@@ -95,6 +95,7 @@ struct wm8994_priv {
 
         struct wm8994_micdet micdet[2];
 
+        int revision;
         struct wm8994_pdata *pdata;
 };
 
@@ -1677,6 +1678,26 @@ static struct {
 
 static int wm8994_readable(unsigned int reg)
 {
+        switch (reg) {
+        case WM8994_GPIO_1:
+        case WM8994_GPIO_2:
+        case WM8994_GPIO_3:
+        case WM8994_GPIO_4:
+        case WM8994_GPIO_5:
+        case WM8994_GPIO_6:
+        case WM8994_GPIO_7:
+        case WM8994_GPIO_8:
+        case WM8994_GPIO_9:
+        case WM8994_GPIO_10:
+        case WM8994_GPIO_11:
+        case WM8994_INTERRUPT_STATUS_1:
+        case WM8994_INTERRUPT_STATUS_2:
+        case WM8994_INTERRUPT_RAW_STATUS_2:
+                return 1;
+        default:
+                break;
+        }
+
         if (reg >= ARRAY_SIZE(access_masks))
                 return 0;
         return access_masks[reg].readable != 0;
@@ -2341,6 +2362,20 @@ SOC_DAPM_SINGLE("AIF2 Switch", WM8994_AIF1_ADC1_RIGHT_MIXER_ROUTING,
                 0, 1, 0),
 };
 
+static const struct snd_kcontrol_new aif1adc2l_mix[] = {
+SOC_DAPM_SINGLE("DMIC Switch", WM8994_AIF1_ADC2_LEFT_MIXER_ROUTING,
+                1, 1, 0),
+SOC_DAPM_SINGLE("AIF2 Switch", WM8994_AIF1_ADC2_LEFT_MIXER_ROUTING,
+                0, 1, 0),
+};
+
+static const struct snd_kcontrol_new aif1adc2r_mix[] = {
+SOC_DAPM_SINGLE("DMIC Switch", WM8994_AIF1_ADC2_RIGHT_MIXER_ROUTING,
+                1, 1, 0),
+SOC_DAPM_SINGLE("AIF2 Switch", WM8994_AIF1_ADC2_RIGHT_MIXER_ROUTING,
+                0, 1, 0),
+};
+
 static const struct snd_kcontrol_new aif2dac2l_mix[] = {
 SOC_DAPM_SINGLE("Right Sidetone Switch", WM8994_DAC2_LEFT_MIXER_ROUTING,
                 5, 1, 0),
@@ -2472,6 +2507,7 @@ static const struct snd_kcontrol_new aif3adc_mux =
 static const struct snd_soc_dapm_widget wm8994_dapm_widgets[] = {
 SND_SOC_DAPM_INPUT("DMIC1DAT"),
 SND_SOC_DAPM_INPUT("DMIC2DAT"),
+SND_SOC_DAPM_INPUT("Clock"),
 
 SND_SOC_DAPM_SUPPLY("CLK_SYS", SND_SOC_NOPM, 0, 0, clk_sys_event,
                     SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
@@ -2506,6 +2542,11 @@ SND_SOC_DAPM_MIXER("AIF1ADC1L Mixer", SND_SOC_NOPM, 0, 0,
 SND_SOC_DAPM_MIXER("AIF1ADC1R Mixer", SND_SOC_NOPM, 0, 0,
                    aif1adc1r_mix, ARRAY_SIZE(aif1adc1r_mix)),
 
+SND_SOC_DAPM_MIXER("AIF1ADC2L Mixer", SND_SOC_NOPM, 0, 0,
+                   aif1adc2l_mix, ARRAY_SIZE(aif1adc2l_mix)),
+SND_SOC_DAPM_MIXER("AIF1ADC2R Mixer", SND_SOC_NOPM, 0, 0,
+                   aif1adc2r_mix, ARRAY_SIZE(aif1adc2r_mix)),
+
 SND_SOC_DAPM_MIXER("AIF2DAC2L Mixer", SND_SOC_NOPM, 0, 0,
                    aif2dac2l_mix, ARRAY_SIZE(aif2dac2l_mix)),
 SND_SOC_DAPM_MIXER("AIF2DAC2R Mixer", SND_SOC_NOPM, 0, 0,
@@ -2668,6 +2709,14 @@ static const struct snd_soc_dapm_route intercon[] = {
         { "AIF1ADC1R Mixer", "ADC/DMIC Switch", "ADCR Mux" },
         { "AIF1ADC1R Mixer", "AIF2 Switch", "AIF2DACR" },
 
+        { "AIF1ADC2L", NULL, "AIF1ADC2L Mixer" },
+        { "AIF1ADC2L Mixer", "DMIC Switch", "DMIC2L" },
+        { "AIF1ADC2L Mixer", "AIF2 Switch", "AIF2DACL" },
+
+        { "AIF1ADC2R", NULL, "AIF1ADC2R Mixer" },
+        { "AIF1ADC2R Mixer", "DMIC Switch", "DMIC2R" },
+        { "AIF1ADC2R Mixer", "AIF2 Switch", "AIF2DACR" },
+
         /* Pin level routing for AIF3 */
         { "AIF1DAC1L", NULL, "AIF1DAC Mux" },
         { "AIF1DAC1R", NULL, "AIF1DAC Mux" },
@@ -2946,11 +2995,14 @@ static int wm8994_set_fll(struct snd_soc_dai *dai, int id, int src,
         return 0;
 }
 
+static int opclk_divs[] = { 10, 20, 30, 40, 55, 60, 80, 120, 160 };
+
 static int wm8994_set_dai_sysclk(struct snd_soc_dai *dai,
                 int clk_id, unsigned int freq, int dir)
 {
         struct snd_soc_codec *codec = dai->codec;
         struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+        int i;
 
         switch (dai->id) {
         case 1:
@@ -2988,6 +3040,25 @@ static int wm8994_set_dai_sysclk(struct snd_soc_dai *dai,
                 dev_dbg(dai->dev, "AIF%d using FLL2\n", dai->id);
                 break;
 
+        case WM8994_SYSCLK_OPCLK:
+                /* Special case - a division (times 10) is given and
+                 * no effect on main clocking. 
+                 */
+                if (freq) {
+                        for (i = 0; i < ARRAY_SIZE(opclk_divs); i++)
+                                if (opclk_divs[i] == freq)
+                                        break;
+                        if (i == ARRAY_SIZE(opclk_divs))
+                                return -EINVAL;
+                        snd_soc_update_bits(codec, WM8994_CLOCKING_2,
+                                            WM8994_OPCLK_DIV_MASK, i);
+                        snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_2,
+                                            WM8994_OPCLK_ENA, WM8994_OPCLK_ENA);
+                } else {
+                        snd_soc_update_bits(codec, WM8994_POWER_MANAGEMENT_2,
+                                            WM8994_OPCLK_ENA, 0);
+                }
+
         default:
                 return -EINVAL;
         }
@@ -3000,6 +3071,8 @@ static int wm8994_set_dai_sysclk(struct snd_soc_dai *dai,
 static int wm8994_set_bias_level(struct snd_soc_codec *codec,
                                  enum snd_soc_bias_level level)
 {
+        struct wm8994_priv *wm8994 = snd_soc_codec_get_drvdata(codec);
+
         switch (level) {
         case SND_SOC_BIAS_ON:
                 break;
@@ -3012,11 +3085,16 @@ static int wm8994_set_bias_level(struct snd_soc_codec *codec,
 
         case SND_SOC_BIAS_STANDBY:
                 if (codec->bias_level == SND_SOC_BIAS_OFF) {
-                        /* Tweak DC servo configuration for improved
-                         * performance. */
-                        snd_soc_write(codec, 0x102, 0x3);
-                        snd_soc_write(codec, 0x56, 0x3);
-                        snd_soc_write(codec, 0x102, 0);
+                        /* Tweak DC servo and DSP configuration for
+                         * improved performance. */
+                        if (wm8994->revision < 4) {
+                                /* Tweak DC servo and DSP configuration for
+                                 * improved performance. */
+                                snd_soc_write(codec, 0x102, 0x3);
+                                snd_soc_write(codec, 0x56, 0x3);
+                                snd_soc_write(codec, 0x817, 0);
+                                snd_soc_write(codec, 0x102, 0);
+                        }
 
                         /* Discharge LINEOUT1 & 2 */
                         snd_soc_update_bits(codec, WM8994_ANTIPOP_1,
@@ -3849,7 +3927,6 @@ static int wm8994_codec_probe(struct platform_device *pdev)
         struct wm8994_priv *wm8994;
         struct snd_soc_codec *codec;
         int i;
-        u16 rev;
 
         if (wm8994_codec) {
                 dev_err(&pdev->dev, "Another WM8994 is registered\n");
@@ -3903,8 +3980,8 @@ static int wm8994_codec_probe(struct platform_device *pdev)
                         wm8994->reg_cache[i] = 0;
 
         /* Set revision-specific configuration */
-        rev = snd_soc_read(codec, WM8994_CHIP_REVISION);
-        switch (rev) {
+        wm8994->revision = snd_soc_read(codec, WM8994_CHIP_REVISION);
+        switch (wm8994->revision) {
         case 2:
         case 3:
                 wm8994->hubs.dcs_codes = -5;
@@ -4004,6 +4081,11 @@ static int wm8994_codec_probe(struct platform_device *pdev)
                             1 << WM8994_AIF2DAC_3D_GAIN_SHIFT,
                             1 << WM8994_AIF2DAC_3D_GAIN_SHIFT);
 
+        /* Unconditionally enable AIF1 ADC TDM mode; it only affects
+         * behaviour on idle TDM clock cycles. */
+        snd_soc_update_bits(codec, WM8994_AIF1_CONTROL_1,
+                            WM8994_AIF1ADC_TDM, WM8994_AIF1ADC_TDM);
+
         wm8994_update_class_w(codec);
 
         ret = snd_soc_register_codec(codec);
diff --git a/sound/soc/codecs/wm8994.h b/sound/soc/codecs/wm8994.h
index 7072dc539354..2e0ca67a8df7 100644
--- a/sound/soc/codecs/wm8994.h
+++ b/sound/soc/codecs/wm8994.h
@@ -20,6 +20,9 @@ extern struct snd_soc_dai wm8994_dai[];
 #define WM8994_SYSCLK_FLL1  3
 #define WM8994_SYSCLK_FLL2  4
 
+/* OPCLK is also configured with set_dai_sysclk, specify division*10 as rate. */
+#define WM8994_SYSCLK_OPCLK 5
+
 #define WM8994_FLL1 1
 #define WM8994_FLL2 2
 
diff --git a/sound/soc/codecs/wm9081.c b/sound/soc/codecs/wm9081.c
index 13186fb4dcb4..76b37ff6c264 100644
--- a/sound/soc/codecs/wm9081.c
+++ b/sound/soc/codecs/wm9081.c
@@ -1356,7 +1356,7 @@ static int wm9081_register(struct wm9081_priv *wm9081,
         ret = snd_soc_codec_set_cache_io(codec, 8, 16, control);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
-                return ret;
+                goto err;
         }
 
         reg = snd_soc_read(codec, WM9081_SOFTWARE_RESET);
@@ -1369,7 +1369,7 @@ static int wm9081_register(struct wm9081_priv *wm9081,
         ret = wm9081_reset(codec);
         if (ret < 0) {
                 dev_err(codec->dev, "Failed to issue reset\n");
-                return ret;
+                goto err;
         }
 
         wm9081_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
@@ -1388,18 +1388,19 @@ static int wm9081_register(struct wm9081_priv *wm9081,
         ret = snd_soc_register_codec(codec);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register codec: %d\n", ret);
-                return ret;
+                goto err;
         }
 
         ret = snd_soc_register_dai(&wm9081_dai);
         if (ret != 0) {
                 dev_err(codec->dev, "Failed to register DAI: %d\n", ret);
-                snd_soc_unregister_codec(codec);
-                return ret;
+                goto err_codec;
         }
 
         return 0;
 
+err_codec:
+        snd_soc_unregister_codec(codec);
 err:
         kfree(wm9081);
         return ret;
diff --git a/sound/soc/codecs/wm_hubs.c b/sound/soc/codecs/wm_hubs.c
index 16f1a57da08a..2cb81538cd91 100644
--- a/sound/soc/codecs/wm_hubs.c
+++ b/sound/soc/codecs/wm_hubs.c
@@ -410,6 +410,8 @@ static int hp_event(struct snd_soc_dapm_widget *w,
                                     WM8993_HPOUT1L_DLY |
                                     WM8993_HPOUT1R_DLY, 0);
 
+                snd_soc_write(codec, WM8993_DC_SERVO_0, 0);
+
                 snd_soc_update_bits(codec, WM8993_POWER_MANAGEMENT_1,
                                     WM8993_HPOUT1L_ENA | WM8993_HPOUT1R_ENA,
                                     0);
diff --git a/sound/soc/davinci/davinci-i2s.c b/sound/soc/davinci/davinci-i2s.c
index adadcd3aa1b1..9e8932abf158 100644
--- a/sound/soc/davinci/davinci-i2s.c
+++ b/sound/soc/davinci/davinci-i2s.c
@@ -26,6 +26,7 @@
 #include <mach/asp.h>
 
 #include "davinci-pcm.h"
+#include "davinci-i2s.h"
 
 
 /*
@@ -68,16 +69,21 @@
 #define DAVINCI_MCBSP_RCR_RDATDLY(v)    ((v) << 16)
 #define DAVINCI_MCBSP_RCR_RFIG          (1 << 18)
 #define DAVINCI_MCBSP_RCR_RWDLEN2(v)    ((v) << 21)
+#define DAVINCI_MCBSP_RCR_RFRLEN2(v)    ((v) << 24)
+#define DAVINCI_MCBSP_RCR_RPHASE        BIT(31)
 
 #define DAVINCI_MCBSP_XCR_XWDLEN1(v)    ((v) << 5)
 #define DAVINCI_MCBSP_XCR_XFRLEN1(v)    ((v) << 8)
 #define DAVINCI_MCBSP_XCR_XDATDLY(v)    ((v) << 16)
 #define DAVINCI_MCBSP_XCR_XFIG          (1 << 18)
 #define DAVINCI_MCBSP_XCR_XWDLEN2(v)    ((v) << 21)
+#define DAVINCI_MCBSP_XCR_XFRLEN2(v)    ((v) << 24)
+#define DAVINCI_MCBSP_XCR_XPHASE        BIT(31)
 
 #define DAVINCI_MCBSP_SRGR_FWID(v)      ((v) << 8)
 #define DAVINCI_MCBSP_SRGR_FPER(v)      ((v) << 16)
 #define DAVINCI_MCBSP_SRGR_FSGM         (1 << 28)
+#define DAVINCI_MCBSP_SRGR_CLKSM        BIT(29)
 
 #define DAVINCI_MCBSP_PCR_CLKRP         (1 << 0)
 #define DAVINCI_MCBSP_PCR_CLKXP         (1 << 1)
@@ -116,6 +122,7 @@ static const unsigned char double_fmt[SNDRV_PCM_FORMAT_S32_LE + 1] = {
 };
 
 struct davinci_mcbsp_dev {
+        struct device *dev;
         struct davinci_pcm_dma_params   dma_params[2];
         void __iomem                    *base;
 #define MOD_DSP_A       0
@@ -144,6 +151,11 @@ struct davinci_mcbsp_dev {
          * won't end up being swapped because of the underrun.
          */
         unsigned enable_channel_combine:1;
+
+        unsigned int fmt;
+        int clk_div;
+        int clk_input_pin;
+        bool i2s_accurate_sck;
 };
 
 static inline void davinci_mcbsp_write_reg(struct davinci_mcbsp_dev *dev,
@@ -254,10 +266,12 @@ static int davinci_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
         struct davinci_mcbsp_dev *dev = cpu_dai->private_data;
         unsigned int pcr;
         unsigned int srgr;
+        /* Attention srgr is updated by hw_params! */
         srgr = DAVINCI_MCBSP_SRGR_FSGM |
                 DAVINCI_MCBSP_SRGR_FPER(DEFAULT_BITPERSAMPLE * 2 - 1) |
                 DAVINCI_MCBSP_SRGR_FWID(DEFAULT_BITPERSAMPLE - 1);
 
+        dev->fmt = fmt;
         /* set master/slave audio interface */
         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
         case SND_SOC_DAIFMT_CBS_CFS:
@@ -268,11 +282,26 @@ static int davinci_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
                         DAVINCI_MCBSP_PCR_CLKRM;
                 break;
         case SND_SOC_DAIFMT_CBM_CFS:
-                /* McBSP CLKR pin is the input for the Sample Rate Generator.
-                 * McBSP FSR and FSX are driven by the Sample Rate Generator. */
-                pcr = DAVINCI_MCBSP_PCR_SCLKME |
-                        DAVINCI_MCBSP_PCR_FSXM |
-                        DAVINCI_MCBSP_PCR_FSRM;
+                pcr = DAVINCI_MCBSP_PCR_FSRM | DAVINCI_MCBSP_PCR_FSXM;
+                /*
+                 * Selection of the clock input pin that is the
+                 * input for the Sample Rate Generator.
+                 * McBSP FSR and FSX are driven by the Sample Rate
+                 * Generator.
+                 */
+                switch (dev->clk_input_pin) {
+                case MCBSP_CLKS:
+                        pcr |= DAVINCI_MCBSP_PCR_CLKXM |
+                                DAVINCI_MCBSP_PCR_CLKRM;
+                        break;
+                case MCBSP_CLKR:
+                        pcr |= DAVINCI_MCBSP_PCR_SCLKME;
+                        break;
+                default:
+                        dev_err(dev->dev, "bad clk_input_pin\n");
+                        return -EINVAL;
+                }
+
                 break;
         case SND_SOC_DAIFMT_CBM_CFM:
                 /* codec is master */
@@ -372,6 +401,18 @@ static int davinci_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
         return 0;
 }
 
+static int davinci_i2s_dai_set_clkdiv(struct snd_soc_dai *cpu_dai,
+                                int div_id, int div)
+{
+        struct davinci_mcbsp_dev *dev = cpu_dai->private_data;
+
+        if (div_id != DAVINCI_MCBSP_CLKGDV)
+                return -ENODEV;
+
+        dev->clk_div = div;
+        return 0;
+}
+
 static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
                                  struct snd_pcm_hw_params *params,
                                  struct snd_soc_dai *dai)
@@ -380,8 +421,8 @@ static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
         struct davinci_pcm_dma_params *dma_params =
                                         &dev->dma_params[substream->stream];
         struct snd_interval *i = NULL;
-        int mcbsp_word_length;
-        unsigned int rcr, xcr, srgr;
+        int mcbsp_word_length, master;
+        unsigned int rcr, xcr, srgr, clk_div, freq, framesize;
         u32 spcr;
         snd_pcm_format_t fmt;
         unsigned element_cnt = 1;
@@ -396,12 +437,59 @@ static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
                 davinci_mcbsp_write_reg(dev, DAVINCI_MCBSP_SPCR_REG, spcr);
         }
 
-        i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
-        srgr = DAVINCI_MCBSP_SRGR_FSGM;
-        srgr |= DAVINCI_MCBSP_SRGR_FWID(snd_interval_value(i) - 1);
+        master = dev->fmt & SND_SOC_DAIFMT_MASTER_MASK;
+        fmt = params_format(params);
+        mcbsp_word_length = asp_word_length[fmt];
 
-        i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_FRAME_BITS);
-        srgr |= DAVINCI_MCBSP_SRGR_FPER(snd_interval_value(i) - 1);
+        switch (master) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                freq = clk_get_rate(dev->clk);
+                srgr = DAVINCI_MCBSP_SRGR_FSGM |
+                       DAVINCI_MCBSP_SRGR_CLKSM;
+                srgr |= DAVINCI_MCBSP_SRGR_FWID(mcbsp_word_length *
+                                                8 - 1);
+                if (dev->i2s_accurate_sck) {
+                        clk_div = 256;
+                        do {
+                                framesize = (freq / (--clk_div)) /
+                                params->rate_num *
+                                        params->rate_den;
+                        } while (((framesize < 33) || (framesize > 4095)) &&
+                                 (clk_div));
+                        clk_div--;
+                        srgr |= DAVINCI_MCBSP_SRGR_FPER(framesize - 1);
+                } else {
+                        /* symmetric waveforms */
+                        clk_div = freq / (mcbsp_word_length * 16) /
+                                  params->rate_num * params->rate_den;
+                        srgr |= DAVINCI_MCBSP_SRGR_FPER(mcbsp_word_length *
+                                                        16 - 1);
+                }
+                clk_div &= 0xFF;
+                srgr |= clk_div;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFS:
+                srgr = DAVINCI_MCBSP_SRGR_FSGM;
+                clk_div = dev->clk_div - 1;
+                srgr |= DAVINCI_MCBSP_SRGR_FWID(mcbsp_word_length * 8 - 1);
+                srgr |= DAVINCI_MCBSP_SRGR_FPER(mcbsp_word_length * 16 - 1);
+                clk_div &= 0xFF;
+                srgr |= clk_div;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                /* Clock and frame sync given from external sources */
+                i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
+                srgr = DAVINCI_MCBSP_SRGR_FSGM;
+                srgr |= DAVINCI_MCBSP_SRGR_FWID(snd_interval_value(i) - 1);
+                pr_debug("%s - %d  FWID set: re-read srgr = %X\n",
+                        __func__, __LINE__, snd_interval_value(i) - 1);
+
+                i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_FRAME_BITS);
+                srgr |= DAVINCI_MCBSP_SRGR_FPER(snd_interval_value(i) - 1);
+                break;
+        default:
+                return -EINVAL;
+        }
         davinci_mcbsp_write_reg(dev, DAVINCI_MCBSP_SRGR_REG, srgr);
 
         rcr = DAVINCI_MCBSP_RCR_RFIG;
@@ -426,12 +514,41 @@ static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
                         element_cnt = 1;
                         fmt = double_fmt[fmt];
                 }
+                switch (master) {
+                case SND_SOC_DAIFMT_CBS_CFS:
+                case SND_SOC_DAIFMT_CBS_CFM:
+                        rcr |= DAVINCI_MCBSP_RCR_RFRLEN2(0);
+                        xcr |= DAVINCI_MCBSP_XCR_XFRLEN2(0);
+                        rcr |= DAVINCI_MCBSP_RCR_RPHASE;
+                        xcr |= DAVINCI_MCBSP_XCR_XPHASE;
+                        break;
+                case SND_SOC_DAIFMT_CBM_CFM:
+                case SND_SOC_DAIFMT_CBM_CFS:
+                        rcr |= DAVINCI_MCBSP_RCR_RFRLEN2(element_cnt - 1);
+                        xcr |= DAVINCI_MCBSP_XCR_XFRLEN2(element_cnt - 1);
+                        break;
+                default:
+                        return -EINVAL;
+                }
         }
         dma_params->acnt = dma_params->data_type = data_type[fmt];
         dma_params->fifo_level = 0;
         mcbsp_word_length = asp_word_length[fmt];
-        rcr |= DAVINCI_MCBSP_RCR_RFRLEN1(element_cnt - 1);
-        xcr |= DAVINCI_MCBSP_XCR_XFRLEN1(element_cnt - 1);
+
+        switch (master) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+        case SND_SOC_DAIFMT_CBS_CFM:
+                rcr |= DAVINCI_MCBSP_RCR_RFRLEN1(0);
+                xcr |= DAVINCI_MCBSP_XCR_XFRLEN1(0);
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+        case SND_SOC_DAIFMT_CBM_CFS:
+                rcr |= DAVINCI_MCBSP_RCR_RFRLEN1(element_cnt - 1);
+                xcr |= DAVINCI_MCBSP_XCR_XFRLEN1(element_cnt - 1);
+                break;
+        default:
+                return -EINVAL;
+        }
 
         rcr |= DAVINCI_MCBSP_RCR_RWDLEN1(mcbsp_word_length) |
                 DAVINCI_MCBSP_RCR_RWDLEN2(mcbsp_word_length);
@@ -442,6 +559,10 @@ static int davinci_i2s_hw_params(struct snd_pcm_substream *substream,
                 davinci_mcbsp_write_reg(dev, DAVINCI_MCBSP_XCR_REG, xcr);
         else
                 davinci_mcbsp_write_reg(dev, DAVINCI_MCBSP_RCR_REG, rcr);
+
+        pr_debug("%s - %d  srgr=%X\n", __func__, __LINE__, srgr);
+        pr_debug("%s - %d  xcr=%X\n", __func__, __LINE__, xcr);
+        pr_debug("%s - %d  rcr=%X\n", __func__, __LINE__, rcr);
         return 0;
 }
 
@@ -500,6 +621,7 @@ static struct snd_soc_dai_ops davinci_i2s_dai_ops = {
         .trigger        = davinci_i2s_trigger,
         .hw_params      = davinci_i2s_hw_params,
         .set_fmt        = davinci_i2s_set_dai_fmt,
+        .set_clkdiv     = davinci_i2s_dai_set_clkdiv,
 
 };
 
@@ -526,6 +648,8 @@ static int davinci_i2s_probe(struct platform_device *pdev)
         struct snd_platform_data *pdata = pdev->dev.platform_data;
         struct davinci_mcbsp_dev *dev;
         struct resource *mem, *ioarea, *res;
+        enum dma_event_q asp_chan_q = EVENTQ_0;
+        enum dma_event_q ram_chan_q = EVENTQ_1;
         int ret;
 
         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -552,7 +676,17 @@ static int davinci_i2s_probe(struct platform_device *pdev)
                         pdata->sram_size_playback;
                 dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].sram_size =
                         pdata->sram_size_capture;
+                dev->clk_input_pin = pdata->clk_input_pin;
+                dev->i2s_accurate_sck = pdata->i2s_accurate_sck;
+                asp_chan_q = pdata->asp_chan_q;
+                ram_chan_q = pdata->ram_chan_q;
         }
+
+        dev->dma_params[SNDRV_PCM_STREAM_PLAYBACK].asp_chan_q   = asp_chan_q;
+        dev->dma_params[SNDRV_PCM_STREAM_PLAYBACK].ram_chan_q   = ram_chan_q;
+        dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].asp_chan_q    = asp_chan_q;
+        dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].ram_chan_q    = ram_chan_q;
+
         dev->clk = clk_get(&pdev->dev, NULL);
         if (IS_ERR(dev->clk)) {
                 ret = -ENODEV;
@@ -584,6 +718,7 @@ static int davinci_i2s_probe(struct platform_device *pdev)
                 goto err_free_mem;
         }
         dev->dma_params[SNDRV_PCM_STREAM_CAPTURE].channel = res->start;
+        dev->dev = &pdev->dev;
 
         davinci_i2s_dai.private_data = dev;
         davinci_i2s_dai.capture.dma_data = dev->dma_params;
diff --git a/sound/soc/davinci/davinci-i2s.h b/sound/soc/davinci/davinci-i2s.h
index 241648ce8873..0b1e77b8c279 100644
--- a/sound/soc/davinci/davinci-i2s.h
+++ b/sound/soc/davinci/davinci-i2s.h
@@ -12,6 +12,11 @@
 #ifndef _DAVINCI_I2S_H
 #define _DAVINCI_I2S_H
 
+/* McBSP dividers */
+enum davinci_mcbsp_div {
+        DAVINCI_MCBSP_CLKGDV,              /* Sample rate generator divider */
+};
+
 extern struct snd_soc_dai davinci_i2s_dai;
 
 #endif
diff --git a/sound/soc/davinci/davinci-mcasp.c b/sound/soc/davinci/davinci-mcasp.c
index d3955096d872..b24720894af6 100644
--- a/sound/soc/davinci/davinci-mcasp.c
+++ b/sound/soc/davinci/davinci-mcasp.c
@@ -890,7 +890,8 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
         dev->rxnumevt = pdata->rxnumevt;
 
         dma_data = &dev->dma_params[SNDRV_PCM_STREAM_PLAYBACK];
-        dma_data->eventq_no = pdata->eventq_no;
+        dma_data->asp_chan_q = pdata->asp_chan_q;
+        dma_data->ram_chan_q = pdata->ram_chan_q;
         dma_data->dma_addr = (dma_addr_t) (pdata->tx_dma_offset +
                                                         io_v2p(dev->base));
 
@@ -904,7 +905,8 @@ static int davinci_mcasp_probe(struct platform_device *pdev)
         dma_data->channel = res->start;
 
         dma_data = &dev->dma_params[SNDRV_PCM_STREAM_CAPTURE];
-        dma_data->eventq_no = pdata->eventq_no;
+        dma_data->asp_chan_q = pdata->asp_chan_q;
+        dma_data->ram_chan_q = pdata->ram_chan_q;
         dma_data->dma_addr = (dma_addr_t)(pdata->rx_dma_offset +
                                                         io_v2p(dev->base));
 
diff --git a/sound/soc/davinci/davinci-pcm.c b/sound/soc/davinci/davinci-pcm.c
index 2dc406f42fe7..a7124116d2e0 100644
--- a/sound/soc/davinci/davinci-pcm.c
+++ b/sound/soc/davinci/davinci-pcm.c
@@ -381,7 +381,7 @@ static int request_ping_pong(struct snd_pcm_substream *substream,
         /* Request ram master channel */
         link = prtd->ram_channel = edma_alloc_channel(EDMA_CHANNEL_ANY,
                                   davinci_pcm_dma_irq, substream,
-                                  EVENTQ_1);
+                                  prtd->params->ram_chan_q);
         if (link < 0)
                 goto exit1;
 
@@ -477,7 +477,8 @@ static int davinci_pcm_dma_request(struct snd_pcm_substream *substream)
 
         /* Request asp master DMA channel */
         link = prtd->asp_channel = edma_alloc_channel(params->channel,
-                        davinci_pcm_dma_irq, substream, EVENTQ_0);
+                        davinci_pcm_dma_irq, substream,
+                        prtd->params->asp_chan_q);
         if (link < 0)
                 goto exit1;
 
@@ -800,7 +801,7 @@ static void davinci_pcm_free(struct snd_pcm *pcm)
                 dma_free_writecombine(pcm->card->dev, buf->bytes,
                                       buf->area, buf->addr);
                 buf->area = NULL;
-                iram_dma = (struct snd_dma_buffer *)buf->private_data;
+                iram_dma = buf->private_data;
                 if (iram_dma) {
                         sram_free(iram_dma->area, iram_dma->bytes);
                         kfree(iram_dma);
diff --git a/sound/soc/davinci/davinci-pcm.h b/sound/soc/davinci/davinci-pcm.h
index 0764944cf10f..b799a02333d8 100644
--- a/sound/soc/davinci/davinci-pcm.h
+++ b/sound/soc/davinci/davinci-pcm.h
@@ -21,7 +21,8 @@ struct davinci_pcm_dma_params {
         unsigned short acnt;
         dma_addr_t dma_addr;            /* device physical address for DMA */
         unsigned sram_size;
-        enum dma_event_q eventq_no;     /* event queue number */
+        enum dma_event_q asp_chan_q;    /* event queue number for ASP channel */
+        enum dma_event_q ram_chan_q;    /* event queue number for RAM channel */
         unsigned char data_type;        /* xfer data type */
         unsigned char convert_mono_stereo;
         unsigned int fifo_level;
diff --git a/sound/soc/davinci/davinci-vcif.c b/sound/soc/davinci/davinci-vcif.c
index 9aa980d38231..48678533da7a 100644
--- a/sound/soc/davinci/davinci-vcif.c
+++ b/sound/soc/davinci/davinci-vcif.c
@@ -203,7 +203,7 @@ static int davinci_vcif_probe(struct platform_device *pdev)
         int ret;
 
         davinci_vcif_dev = kzalloc(sizeof(struct davinci_vcif_dev), GFP_KERNEL);
-        if (!davinci_vc) {
+        if (!davinci_vcif_dev) {
                 dev_dbg(&pdev->dev,
                         "could not allocate memory for private data\n");
                 return -ENOMEM;
diff --git a/sound/soc/ep93xx/Kconfig b/sound/soc/ep93xx/Kconfig
new file mode 100644
index 000000000000..f617f560f46b
--- /dev/null
+++ b/sound/soc/ep93xx/Kconfig
@@ -0,0 +1,18 @@
+config SND_EP93XX_SOC
+        tristate "SoC Audio support for the Cirrus Logic EP93xx series"
+        depends on ARCH_EP93XX && SND_SOC
+        help
+          Say Y or M if you want to add support for codecs attached to
+          the EP93xx I2S interface.
+
+config SND_EP93XX_SOC_I2S
+        tristate
+
+config SND_EP93XX_SOC_SNAPPERCL15
+        tristate "SoC Audio support for Bluewater Systems Snapper CL15 module"
+        depends on SND_EP93XX_SOC && MACH_SNAPPER_CL15
+        select SND_EP93XX_SOC_I2S
+        select SND_SOC_TLV320AIC23
+        help
+          Say Y or M here if you want to add support for I2S audio on the
+          Bluewater Systems Snapper CL15 module.
diff --git a/sound/soc/ep93xx/Makefile b/sound/soc/ep93xx/Makefile
new file mode 100644
index 000000000000..272e60f57b9a
--- /dev/null
+++ b/sound/soc/ep93xx/Makefile
@@ -0,0 +1,11 @@
+# EP93xx Platform Support
+snd-soc-ep93xx-objs                             := ep93xx-pcm.o
+snd-soc-ep93xx-i2s-objs                         := ep93xx-i2s.o
+
+obj-$(CONFIG_SND_EP93XX_SOC)                    += snd-soc-ep93xx.o
+obj-$(CONFIG_SND_EP93XX_SOC_I2S)                += snd-soc-ep93xx-i2s.o
+
+# EP93XX Machine Support
+snd-soc-snappercl15-objs                        := snappercl15.o
+
+obj-$(CONFIG_SND_EP93XX_SOC_SNAPPERCL15)        += snd-soc-snappercl15.o
diff --git a/sound/soc/ep93xx/ep93xx-i2s.c b/sound/soc/ep93xx/ep93xx-i2s.c
new file mode 100644
index 000000000000..00b946632184
--- /dev/null
+++ b/sound/soc/ep93xx/ep93xx-i2s.c
@@ -0,0 +1,487 @@
+/*
+ * linux/sound/soc/ep93xx-i2s.c
+ * EP93xx I2S driver
+ *
+ * Copyright (C) 2010 Ryan Mallon <ryan@bluewatersys.com>
+ *
+ * Based on the original driver by:
+ *   Copyright (C) 2007 Chase Douglas <chasedouglas@gmail>
+ *   Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
+ *
+ * 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/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/initval.h>
+#include <sound/soc.h>
+
+#include <mach/hardware.h>
+#include <mach/ep93xx-regs.h>
+#include <mach/dma.h>
+
+#include "ep93xx-pcm.h"
+#include "ep93xx-i2s.h"
+
+#define EP93XX_I2S_TXCLKCFG             0x00
+#define EP93XX_I2S_RXCLKCFG             0x04
+#define EP93XX_I2S_GLCTRL               0x0C
+
+#define EP93XX_I2S_TXLINCTRLDATA        0x28
+#define EP93XX_I2S_TXCTRL               0x2C
+#define EP93XX_I2S_TXWRDLEN             0x30
+#define EP93XX_I2S_TX0EN                0x34
+
+#define EP93XX_I2S_RXLINCTRLDATA        0x58
+#define EP93XX_I2S_RXCTRL               0x5C
+#define EP93XX_I2S_RXWRDLEN             0x60
+#define EP93XX_I2S_RX0EN                0x64
+
+#define EP93XX_I2S_WRDLEN_16            (0 << 0)
+#define EP93XX_I2S_WRDLEN_24            (1 << 0)
+#define EP93XX_I2S_WRDLEN_32            (2 << 0)
+
+#define EP93XX_I2S_LINCTRLDATA_R_JUST   (1 << 2) /* Right justify */
+
+#define EP93XX_I2S_CLKCFG_LRS           (1 << 0) /* lrclk polarity */
+#define EP93XX_I2S_CLKCFG_CKP           (1 << 1) /* Bit clock polarity */
+#define EP93XX_I2S_CLKCFG_REL           (1 << 2) /* First bit transition */
+#define EP93XX_I2S_CLKCFG_MASTER        (1 << 3) /* Master mode */
+#define EP93XX_I2S_CLKCFG_NBCG          (1 << 4) /* Not bit clock gating */
+
+struct ep93xx_i2s_info {
+        struct clk                      *mclk;
+        struct clk                      *sclk;
+        struct clk                      *lrclk;
+        struct ep93xx_pcm_dma_params    *dma_params;
+        struct resource                 *mem;
+        void __iomem                    *regs;
+};
+
+struct ep93xx_pcm_dma_params ep93xx_i2s_dma_params[] = {
+        [SNDRV_PCM_STREAM_PLAYBACK] = {
+                .name           = "i2s-pcm-out",
+                .dma_port       = EP93XX_DMA_M2P_PORT_I2S1,
+        },
+        [SNDRV_PCM_STREAM_CAPTURE] = {
+                .name           = "i2s-pcm-in",
+                .dma_port       = EP93XX_DMA_M2P_PORT_I2S1,
+        },
+};
+
+static inline void ep93xx_i2s_write_reg(struct ep93xx_i2s_info *info,
+                                        unsigned reg, unsigned val)
+{
+        __raw_writel(val, info->regs + reg);
+}
+
+static inline unsigned ep93xx_i2s_read_reg(struct ep93xx_i2s_info *info,
+                                           unsigned reg)
+{
+        return __raw_readl(info->regs + reg);
+}
+
+static void ep93xx_i2s_enable(struct ep93xx_i2s_info *info, int stream)
+{
+        unsigned base_reg;
+        int i;
+
+        if ((ep93xx_i2s_read_reg(info, EP93XX_I2S_TX0EN) & 0x1) == 0 &&
+            (ep93xx_i2s_read_reg(info, EP93XX_I2S_RX0EN) & 0x1) == 0) {
+                /* Enable clocks */
+                clk_enable(info->mclk);
+                clk_enable(info->sclk);
+                clk_enable(info->lrclk);
+
+                /* Enable i2s */
+                ep93xx_i2s_write_reg(info, EP93XX_I2S_GLCTRL, 1);
+        }
+
+        /* Enable fifos */
+        if (stream == SNDRV_PCM_STREAM_PLAYBACK)
+                base_reg = EP93XX_I2S_TX0EN;
+        else
+                base_reg = EP93XX_I2S_RX0EN;
+        for (i = 0; i < 3; i++)
+                ep93xx_i2s_write_reg(info, base_reg + (i * 4), 1);
+}
+
+static void ep93xx_i2s_disable(struct ep93xx_i2s_info *info, int stream)
+{
+        unsigned base_reg;
+        int i;
+
+        /* Disable fifos */
+        if (stream == SNDRV_PCM_STREAM_PLAYBACK)
+                base_reg = EP93XX_I2S_TX0EN;
+        else
+                base_reg = EP93XX_I2S_RX0EN;
+        for (i = 0; i < 3; i++)
+                ep93xx_i2s_write_reg(info, base_reg + (i * 4), 0);
+
+        if ((ep93xx_i2s_read_reg(info, EP93XX_I2S_TX0EN) & 0x1) == 0 &&
+            (ep93xx_i2s_read_reg(info, EP93XX_I2S_RX0EN) & 0x1) == 0) {
+                /* Disable i2s */
+                ep93xx_i2s_write_reg(info, EP93XX_I2S_GLCTRL, 0);
+
+                /* Disable clocks */
+                clk_disable(info->lrclk);
+                clk_disable(info->sclk);
+                clk_disable(info->mclk);
+        }
+}
+
+static int ep93xx_i2s_startup(struct snd_pcm_substream *substream,
+                              struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct ep93xx_i2s_info *info = rtd->dai->cpu_dai->private_data;
+
+        snd_soc_dai_set_dma_data(cpu_dai, substream,
+                                 &info->dma_params[substream->stream]);
+        return 0;
+}
+
+static void ep93xx_i2s_shutdown(struct snd_pcm_substream *substream,
+                                struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct ep93xx_i2s_info *info = rtd->dai->cpu_dai->private_data;
+
+        ep93xx_i2s_disable(info, substream->stream);
+}
+
+static int ep93xx_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
+                                  unsigned int fmt)
+{
+        struct ep93xx_i2s_info *info = cpu_dai->private_data;
+        unsigned int clk_cfg, lin_ctrl;
+
+        clk_cfg  = ep93xx_i2s_read_reg(info, EP93XX_I2S_RXCLKCFG);
+        lin_ctrl = ep93xx_i2s_read_reg(info, EP93XX_I2S_RXLINCTRLDATA);
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_I2S:
+                clk_cfg |= EP93XX_I2S_CLKCFG_REL;
+                lin_ctrl &= ~EP93XX_I2S_LINCTRLDATA_R_JUST;
+                break;
+
+        case SND_SOC_DAIFMT_LEFT_J:
+                clk_cfg &= ~EP93XX_I2S_CLKCFG_REL;
+                lin_ctrl &= ~EP93XX_I2S_LINCTRLDATA_R_JUST;
+                break;
+
+        case SND_SOC_DAIFMT_RIGHT_J:
+                clk_cfg &= ~EP93XX_I2S_CLKCFG_REL;
+                lin_ctrl |= EP93XX_I2S_LINCTRLDATA_R_JUST;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                /* CPU is master */
+                clk_cfg |= EP93XX_I2S_CLKCFG_MASTER;
+                break;
+
+        case SND_SOC_DAIFMT_CBM_CFM:
+                /* Codec is master */
+                clk_cfg &= ~EP93XX_I2S_CLKCFG_MASTER;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                /* Negative bit clock, lrclk low on left word */
+                clk_cfg &= ~(EP93XX_I2S_CLKCFG_CKP | EP93XX_I2S_CLKCFG_REL);
+                break;
+
+        case SND_SOC_DAIFMT_NB_IF:
+                /* Negative bit clock, lrclk low on right word */
+                clk_cfg &= ~EP93XX_I2S_CLKCFG_CKP;
+                clk_cfg |= EP93XX_I2S_CLKCFG_REL;
+                break;
+
+        case SND_SOC_DAIFMT_IB_NF:
+                /* Positive bit clock, lrclk low on left word */
+                clk_cfg |= EP93XX_I2S_CLKCFG_CKP;
+                clk_cfg &= ~EP93XX_I2S_CLKCFG_REL;
+                break;
+
+        case SND_SOC_DAIFMT_IB_IF:
+                /* Positive bit clock, lrclk low on right word */
+                clk_cfg |= EP93XX_I2S_CLKCFG_CKP | EP93XX_I2S_CLKCFG_REL;
+                break;
+        }
+
+        /* Write new register values */
+        ep93xx_i2s_write_reg(info, EP93XX_I2S_RXCLKCFG, clk_cfg);
+        ep93xx_i2s_write_reg(info, EP93XX_I2S_TXCLKCFG, clk_cfg);
+        ep93xx_i2s_write_reg(info, EP93XX_I2S_RXLINCTRLDATA, lin_ctrl);
+        ep93xx_i2s_write_reg(info, EP93XX_I2S_TXLINCTRLDATA, lin_ctrl);
+        return 0;
+}
+
+static int ep93xx_i2s_hw_params(struct snd_pcm_substream *substream,
+                                struct snd_pcm_hw_params *params,
+                                struct snd_soc_dai *dai)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct ep93xx_i2s_info *info = cpu_dai->private_data;
+        unsigned word_len, div, sdiv, lrdiv;
+        int found = 0, err;
+
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                word_len = EP93XX_I2S_WRDLEN_16;
+                break;
+
+        case SNDRV_PCM_FORMAT_S24_LE:
+                word_len = EP93XX_I2S_WRDLEN_24;
+                break;
+
+        case SNDRV_PCM_FORMAT_S32_LE:
+                word_len = EP93XX_I2S_WRDLEN_32;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                ep93xx_i2s_write_reg(info, EP93XX_I2S_TXWRDLEN, word_len);
+        else
+                ep93xx_i2s_write_reg(info, EP93XX_I2S_RXWRDLEN, word_len);
+
+        /*
+         * Calculate the sdiv (bit clock) and lrdiv (left/right clock) values.
+         * If the lrclk is pulse length is larger than the word size, then the
+         * bit clock will be gated for the unused bits.
+         */
+        div = (clk_get_rate(info->mclk) / params_rate(params)) *
+                params_channels(params);
+        for (sdiv = 2; sdiv <= 4; sdiv += 2)
+                for (lrdiv = 32; lrdiv <= 128; lrdiv <<= 1)
+                        if (sdiv * lrdiv == div) {
+                                found = 1;
+                                goto out;
+                        }
+out:
+        if (!found)
+                return -EINVAL;
+
+        err = clk_set_rate(info->sclk, clk_get_rate(info->mclk) / sdiv);
+        if (err)
+                return err;
+
+        err = clk_set_rate(info->lrclk, clk_get_rate(info->sclk) / lrdiv);
+        if (err)
+                return err;
+
+        ep93xx_i2s_enable(info, substream->stream);
+        return 0;
+}
+
+static int ep93xx_i2s_set_sysclk(struct snd_soc_dai *cpu_dai, int clk_id,
+                                 unsigned int freq, int dir)
+{
+        struct ep93xx_i2s_info *info = cpu_dai->private_data;
+
+        if (dir == SND_SOC_CLOCK_IN || clk_id != 0)
+                return -EINVAL;
+
+        return clk_set_rate(info->mclk, freq);
+}
+
+#ifdef CONFIG_PM
+static int ep93xx_i2s_suspend(struct snd_soc_dai *dai)
+{
+        struct ep93xx_i2s_info *info = dai->private_data;
+
+        if (!dai->active)
+                return;
+
+        ep93xx_i2s_disable(info, SNDRV_PCM_STREAM_PLAYBACK);
+        ep93xx_i2s_disable(info, SNDRV_PCM_STREAM_CAPTURE);
+}
+
+static int ep93xx_i2s_resume(struct snd_soc_dai *dai)
+{
+        struct ep93xx_i2s_info *info = dai->private_data;
+
+        if (!dai->active)
+                return;
+
+        ep93xx_i2s_enable(info, SNDRV_PCM_STREAM_PLAYBACK);
+        ep93xx_i2s_enable(info, SNDRV_PCM_STREAM_CAPTURE);
+}
+#else
+#define ep93xx_i2s_suspend      NULL
+#define ep93xx_i2s_resume       NULL
+#endif
+
+static struct snd_soc_dai_ops ep93xx_i2s_dai_ops = {
+        .startup        = ep93xx_i2s_startup,
+        .shutdown       = ep93xx_i2s_shutdown,
+        .hw_params      = ep93xx_i2s_hw_params,
+        .set_sysclk     = ep93xx_i2s_set_sysclk,
+        .set_fmt        = ep93xx_i2s_set_dai_fmt,
+};
+
+#define EP93XX_I2S_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \
+                            SNDRV_PCM_FMTBIT_S24_LE | \
+                            SNDRV_PCM_FMTBIT_S32_LE)
+
+struct snd_soc_dai ep93xx_i2s_dai = {
+        .name           = "ep93xx-i2s",
+        .id             = 0,
+        .symmetric_rates= 1,
+        .suspend        = ep93xx_i2s_suspend,
+        .resume         = ep93xx_i2s_resume,
+        .playback       = {
+                .channels_min   = 2,
+                .channels_max   = 2,
+                .rates          = SNDRV_PCM_RATE_8000_48000,
+                .formats        = EP93XX_I2S_FORMATS,
+        },
+        .capture        = {
+                 .channels_min  = 2,
+                 .channels_max  = 2,
+                 .rates         = SNDRV_PCM_RATE_8000_48000,
+                 .formats       = EP93XX_I2S_FORMATS,
+        },
+        .ops            = &ep93xx_i2s_dai_ops,
+};
+EXPORT_SYMBOL_GPL(ep93xx_i2s_dai);
+
+static int ep93xx_i2s_probe(struct platform_device *pdev)
+{
+        struct ep93xx_i2s_info *info;
+        struct resource *res;
+        int err;
+
+        info = kzalloc(sizeof(struct ep93xx_i2s_info), GFP_KERNEL);
+        if (!info) {
+                err = -ENOMEM;
+                goto fail;
+        }
+
+        ep93xx_i2s_dai.dev = &pdev->dev;
+        ep93xx_i2s_dai.private_data = info;
+        info->dma_params = ep93xx_i2s_dma_params;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                err = -ENODEV;
+                goto fail;
+        }
+
+        info->mem = request_mem_region(res->start, resource_size(res),
+                                       pdev->name);
+        if (!info->mem) {
+                err = -EBUSY;
+                goto fail;
+        }
+
+        info->regs = ioremap(info->mem->start, resource_size(info->mem));
+        if (!info->regs) {
+                err = -ENXIO;
+                goto fail_release_mem;
+        }
+
+        info->mclk = clk_get(&pdev->dev, "mclk");
+        if (IS_ERR(info->mclk)) {
+                err = PTR_ERR(info->mclk);
+                goto fail_unmap_mem;
+        }
+
+        info->sclk = clk_get(&pdev->dev, "sclk");
+        if (IS_ERR(info->sclk)) {
+                err = PTR_ERR(info->sclk);
+                goto fail_put_mclk;
+        }
+
+        info->lrclk = clk_get(&pdev->dev, "lrclk");
+        if (IS_ERR(info->lrclk)) {
+                err = PTR_ERR(info->lrclk);
+                goto fail_put_sclk;
+        }
+
+        err = snd_soc_register_dai(&ep93xx_i2s_dai);
+        if (err)
+                goto fail_put_lrclk;
+
+        return 0;
+
+fail_put_lrclk:
+        clk_put(info->lrclk);
+fail_put_sclk:
+        clk_put(info->sclk);
+fail_put_mclk:
+        clk_put(info->mclk);
+fail_unmap_mem:
+        iounmap(info->regs);
+fail_release_mem:
+        release_mem_region(info->mem->start, resource_size(info->mem));
+        kfree(info);
+fail:
+        return err;
+}
+
+static int __devexit ep93xx_i2s_remove(struct platform_device *pdev)
+{
+        struct ep93xx_i2s_info *info = ep93xx_i2s_dai.private_data;
+
+        snd_soc_unregister_dai(&ep93xx_i2s_dai);
+        clk_put(info->lrclk);
+        clk_put(info->sclk);
+        clk_put(info->mclk);
+        iounmap(info->regs);
+        release_mem_region(info->mem->start, resource_size(info->mem));
+        kfree(info);
+        return 0;
+}
+
+static struct platform_driver ep93xx_i2s_driver = {
+        .probe  = ep93xx_i2s_probe,
+        .remove = __devexit_p(ep93xx_i2s_remove),
+        .driver = {
+                .name   = "ep93xx-i2s",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init ep93xx_i2s_init(void)
+{
+        return platform_driver_register(&ep93xx_i2s_driver);
+}
+
+static void __exit ep93xx_i2s_exit(void)
+{
+        platform_driver_unregister(&ep93xx_i2s_driver);
+}
+
+module_init(ep93xx_i2s_init);
+module_exit(ep93xx_i2s_exit);
+
+MODULE_ALIAS("platform:ep93xx-i2s");
+MODULE_AUTHOR("Ryan Mallon <ryan@bluewatersys.com>");
+MODULE_DESCRIPTION("EP93XX I2S driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/ep93xx/ep93xx-i2s.h b/sound/soc/ep93xx/ep93xx-i2s.h
new file mode 100644
index 000000000000..3bd4ebfaa1de
--- /dev/null
+++ b/sound/soc/ep93xx/ep93xx-i2s.h
@@ -0,0 +1,18 @@
+/*
+ * linux/sound/soc/ep93xx-i2s.h
+ * EP93xx I2S driver
+ *
+ * Copyright (C) 2010 Ryan Mallon <ryan@bluewatersys.com>
+ *  
+ * 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.
+ *
+ */
+
+#ifndef _EP93XX_SND_SOC_I2S_H
+#define _EP93XX_SND_SOC_I2S_H
+
+extern struct snd_soc_dai ep93xx_i2s_dai;
+
+#endif /* _EP93XX_SND_SOC_I2S_H */
diff --git a/sound/soc/ep93xx/ep93xx-pcm.c b/sound/soc/ep93xx/ep93xx-pcm.c
new file mode 100644
index 000000000000..4ba938400791
--- /dev/null
+++ b/sound/soc/ep93xx/ep93xx-pcm.c
@@ -0,0 +1,319 @@
+/*
+ * linux/sound/arm/ep93xx-pcm.c - EP93xx ALSA PCM interface
+ *
+ * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
+ * Copyright (C) 2006 Applied Data Systems
+ *
+ * Rewritten for the SoC audio subsystem (Based on PXA2xx code):
+ *   Copyright (c) 2008 Ryan Mallon <ryan@bluewatersys.com>
+ *
+ * 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/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/slab.h>
+#include <linux/dma-mapping.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+
+#include <mach/dma.h>
+#include <mach/hardware.h>
+#include <mach/ep93xx-regs.h>
+
+#include "ep93xx-pcm.h"
+
+static const struct snd_pcm_hardware ep93xx_pcm_hardware = {
+        .info                   = (SNDRV_PCM_INFO_MMAP          |
+                                   SNDRV_PCM_INFO_MMAP_VALID    |
+                                   SNDRV_PCM_INFO_INTERLEAVED   |
+                                   SNDRV_PCM_INFO_BLOCK_TRANSFER),
+                                   
+        .rates                  = SNDRV_PCM_RATE_8000_48000,
+        .rate_min               = SNDRV_PCM_RATE_8000,
+        .rate_max               = SNDRV_PCM_RATE_48000,
+        
+        .formats                = (SNDRV_PCM_FMTBIT_S16_LE |
+                                   SNDRV_PCM_FMTBIT_S24_LE |
+                                   SNDRV_PCM_FMTBIT_S32_LE),
+        
+        .buffer_bytes_max       = 131072,
+        .period_bytes_min       = 32,
+        .period_bytes_max       = 32768,
+        .periods_min            = 1,
+        .periods_max            = 32,
+        .fifo_size              = 32,
+};
+
+struct ep93xx_runtime_data
+{
+        struct ep93xx_dma_m2p_client    cl;
+        struct ep93xx_pcm_dma_params    *params;
+        int                             pointer_bytes;
+        struct tasklet_struct           period_tasklet;
+        int                             periods;
+        struct ep93xx_dma_buffer        buf[32];
+};
+
+static void ep93xx_pcm_period_elapsed(unsigned long data)
+{
+        struct snd_pcm_substream *substream = (struct snd_pcm_substream *)data;
+        snd_pcm_period_elapsed(substream);
+}
+
+static void ep93xx_pcm_buffer_started(void *cookie,
+                                      struct ep93xx_dma_buffer *buf)
+{
+}
+
+static void ep93xx_pcm_buffer_finished(void *cookie, 
+                                       struct ep93xx_dma_buffer *buf, 
+                                       int bytes, int error)
+{
+        struct snd_pcm_substream *substream = cookie;
+        struct ep93xx_runtime_data *rtd = substream->runtime->private_data;
+
+        if (buf == rtd->buf + rtd->periods - 1)
+                rtd->pointer_bytes = 0;
+        else
+                rtd->pointer_bytes += buf->size;
+
+        if (!error) {
+                ep93xx_dma_m2p_submit_recursive(&rtd->cl, buf);
+                tasklet_schedule(&rtd->period_tasklet);
+        } else {
+                snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
+        }
+}
+
+static int ep93xx_pcm_open(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *soc_rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = soc_rtd->dai->cpu_dai;
+        struct ep93xx_pcm_dma_params *dma_params;
+        struct ep93xx_runtime_data *rtd;    
+        int ret;
+
+        dma_params = snd_soc_dai_get_dma_data(cpu_dai, substream);
+        snd_soc_set_runtime_hwparams(substream, &ep93xx_pcm_hardware);
+
+        rtd = kmalloc(sizeof(*rtd), GFP_KERNEL);
+        if (!rtd) 
+                return -ENOMEM;
+
+        memset(&rtd->period_tasklet, 0, sizeof(rtd->period_tasklet));
+        rtd->period_tasklet.func = ep93xx_pcm_period_elapsed;
+        rtd->period_tasklet.data = (unsigned long)substream;
+
+        rtd->cl.name = dma_params->name;
+        rtd->cl.flags = dma_params->dma_port | EP93XX_DMA_M2P_IGNORE_ERROR |
+                ((substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
+                 EP93XX_DMA_M2P_TX : EP93XX_DMA_M2P_RX);
+        rtd->cl.cookie = substream;
+        rtd->cl.buffer_started = ep93xx_pcm_buffer_started;
+        rtd->cl.buffer_finished = ep93xx_pcm_buffer_finished;
+        ret = ep93xx_dma_m2p_client_register(&rtd->cl);
+        if (ret < 0) {
+                kfree(rtd);
+                return ret;
+        }
+        
+        substream->runtime->private_data = rtd;
+        return 0;
+}
+
+static int ep93xx_pcm_close(struct snd_pcm_substream *substream)
+{
+        struct ep93xx_runtime_data *rtd = substream->runtime->private_data;
+
+        ep93xx_dma_m2p_client_unregister(&rtd->cl);
+        kfree(rtd);
+        return 0;
+}
+
+static int ep93xx_pcm_hw_params(struct snd_pcm_substream *substream,
+                                struct snd_pcm_hw_params *params)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct ep93xx_runtime_data *rtd = runtime->private_data;
+        size_t totsize = params_buffer_bytes(params);
+        size_t period = params_period_bytes(params);
+        int i;
+
+        snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
+        runtime->dma_bytes = totsize;
+
+        rtd->periods = (totsize + period - 1) / period;
+        for (i = 0; i < rtd->periods; i++) {
+                rtd->buf[i].bus_addr = runtime->dma_addr + (i * period);
+                rtd->buf[i].size = period;
+                if ((i + 1) * period > totsize)
+                        rtd->buf[i].size = totsize - (i * period);
+        }
+
+        return 0;
+}
+
+static int ep93xx_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+        snd_pcm_set_runtime_buffer(substream, NULL);
+        return 0;
+}
+
+static int ep93xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct ep93xx_runtime_data *rtd = substream->runtime->private_data;
+        int ret;
+        int i;
+
+        ret = 0;
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                rtd->pointer_bytes = 0;
+                for (i = 0; i < rtd->periods; i++)
+                        ep93xx_dma_m2p_submit(&rtd->cl, rtd->buf + i);
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                ep93xx_dma_m2p_flush(&rtd->cl);
+                break;
+
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+        return ret;
+}
+
+static snd_pcm_uframes_t ep93xx_pcm_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct ep93xx_runtime_data *rtd = substream->runtime->private_data;
+
+        /* FIXME: implement this with sub-period granularity */
+        return bytes_to_frames(runtime, rtd->pointer_bytes);
+}
+
+static int ep93xx_pcm_mmap(struct snd_pcm_substream *substream,
+                           struct vm_area_struct *vma)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+
+        return dma_mmap_writecombine(substream->pcm->card->dev, vma,
+                                     runtime->dma_area,
+                                     runtime->dma_addr,
+                                     runtime->dma_bytes);
+}
+
+static struct snd_pcm_ops ep93xx_pcm_ops = {
+        .open           = ep93xx_pcm_open,
+        .close          = ep93xx_pcm_close,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = ep93xx_pcm_hw_params,
+        .hw_free        = ep93xx_pcm_hw_free,
+        .trigger        = ep93xx_pcm_trigger,
+        .pointer        = ep93xx_pcm_pointer,
+        .mmap           = ep93xx_pcm_mmap,
+};
+
+static int ep93xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
+{
+        struct snd_pcm_substream *substream = pcm->streams[stream].substream;
+        struct snd_dma_buffer *buf = &substream->dma_buffer;
+        size_t size = ep93xx_pcm_hardware.buffer_bytes_max;
+
+        buf->dev.type = SNDRV_DMA_TYPE_DEV;
+        buf->dev.dev = pcm->card->dev;
+        buf->private_data = NULL;
+        buf->area = dma_alloc_writecombine(pcm->card->dev, size,
+                                           &buf->addr, GFP_KERNEL);
+        buf->bytes = size;
+
+        return (buf->area == NULL) ? -ENOMEM : 0;
+}
+
+static void ep93xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
+{
+        struct snd_pcm_substream *substream;
+        struct snd_dma_buffer *buf;
+        int stream;
+
+        for (stream = 0; stream < 2; stream++) {                
+                substream = pcm->streams[stream].substream;
+                if (!substream)
+                        continue;
+                
+                buf = &substream->dma_buffer;
+                if (!buf->area)
+                        continue;
+
+                dma_free_writecombine(pcm->card->dev, buf->bytes, buf->area,
+                                      buf->addr);
+                buf->area = NULL;
+        }
+}
+
+static u64 ep93xx_pcm_dmamask = 0xffffffff;
+
+static int ep93xx_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
+                          struct snd_pcm *pcm)
+{
+        int ret = 0;
+
+        if (!card->dev->dma_mask)
+                card->dev->dma_mask = &ep93xx_pcm_dmamask;
+        if (!card->dev->coherent_dma_mask)
+                card->dev->coherent_dma_mask = 0xffffffff;
+
+        if (dai->playback.channels_min) {
+                ret = ep93xx_pcm_preallocate_dma_buffer(pcm,
+                                        SNDRV_PCM_STREAM_PLAYBACK);
+                if (ret)
+                        return ret;
+        }
+
+        if (dai->capture.channels_min) {
+                ret = ep93xx_pcm_preallocate_dma_buffer(pcm,
+                                        SNDRV_PCM_STREAM_CAPTURE);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+struct snd_soc_platform ep93xx_soc_platform = {
+        .name           = "ep93xx-audio",
+        .pcm_ops        = &ep93xx_pcm_ops,
+        .pcm_new        = &ep93xx_pcm_new,
+        .pcm_free       = &ep93xx_pcm_free_dma_buffers,
+};
+EXPORT_SYMBOL_GPL(ep93xx_soc_platform);
+
+static int __init ep93xx_soc_platform_init(void)
+{
+        return snd_soc_register_platform(&ep93xx_soc_platform);
+}
+
+static void __exit ep93xx_soc_platform_exit(void)
+{
+        snd_soc_unregister_platform(&ep93xx_soc_platform);
+}
+
+module_init(ep93xx_soc_platform_init);
+module_exit(ep93xx_soc_platform_exit);
+
+MODULE_AUTHOR("Ryan Mallon <ryan@bluewatersys.com>");
+MODULE_DESCRIPTION("EP93xx ALSA PCM interface");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/ep93xx/ep93xx-pcm.h b/sound/soc/ep93xx/ep93xx-pcm.h
new file mode 100644
index 000000000000..4ffdd3f62fe9
--- /dev/null
+++ b/sound/soc/ep93xx/ep93xx-pcm.h
@@ -0,0 +1,22 @@
+/*
+ * sound/soc/ep93xx/ep93xx-pcm.h - EP93xx ALSA PCM interface
+ *
+ * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
+ * Copyright (C) 2006 Applied Data Systems
+ *
+ * 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.
+ */
+
+#ifndef _EP93XX_SND_SOC_PCM_H
+#define _EP93XX_SND_SOC_PCM_H
+
+struct ep93xx_pcm_dma_params {
+        char    *name;
+        int     dma_port;
+};
+
+extern struct snd_soc_platform ep93xx_soc_platform;
+
+#endif /* _EP93XX_SND_SOC_PCM_H */
diff --git a/sound/soc/ep93xx/snappercl15.c b/sound/soc/ep93xx/snappercl15.c
new file mode 100644
index 000000000000..64955340ff75
--- /dev/null
+++ b/sound/soc/ep93xx/snappercl15.c
@@ -0,0 +1,150 @@
+/*
+ * snappercl15.c -- SoC audio for Bluewater Systems Snapper CL15 module
+ *
+ * Copyright (C) 2008 Bluewater Systems Ltd
+ * Author: Ryan Mallon <ryan@bluewatersys.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/platform_device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+#include <asm/mach-types.h>
+#include <mach/hardware.h>
+
+#include "../codecs/tlv320aic23.h"
+#include "ep93xx-pcm.h"
+#include "ep93xx-i2s.h"
+
+#define CODEC_CLOCK 5644800
+
+static int snappercl15_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->dai->codec_dai;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        int err;
+
+        err = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
+                                  SND_SOC_DAIFMT_NB_IF |
+                                  SND_SOC_DAIFMT_CBS_CFS);
+
+        err = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S | 
+                                  SND_SOC_DAIFMT_NB_IF |                  
+                                  SND_SOC_DAIFMT_CBS_CFS);
+        if (err)
+                return err;
+
+        err = snd_soc_dai_set_sysclk(codec_dai, 0, CODEC_CLOCK, 
+                                     SND_SOC_CLOCK_IN);
+        if (err)
+                return err;
+
+        err = snd_soc_dai_set_sysclk(cpu_dai, 0, CODEC_CLOCK, 
+                                     SND_SOC_CLOCK_OUT);
+        if (err)
+                return err;
+
+        return 0;
+}
+
+static struct snd_soc_ops snappercl15_ops = {
+        .hw_params      = snappercl15_hw_params,
+};
+
+static const struct snd_soc_dapm_widget tlv320aic23_dapm_widgets[] = {
+        SND_SOC_DAPM_HP("Headphone Jack", NULL),
+        SND_SOC_DAPM_LINE("Line In", NULL),
+        SND_SOC_DAPM_MIC("Mic Jack", NULL),
+};
+
+static const struct snd_soc_dapm_route audio_map[] = {
+        {"Headphone Jack", NULL, "LHPOUT"},
+        {"Headphone Jack", NULL, "RHPOUT"},
+
+        {"LLINEIN", NULL, "Line In"},
+        {"RLINEIN", NULL, "Line In"},
+
+        {"MICIN", NULL, "Mic Jack"},
+};
+
+static int snappercl15_tlv320aic23_init(struct snd_soc_codec *codec)
+{
+        snd_soc_dapm_new_controls(codec, tlv320aic23_dapm_widgets,
+                                  ARRAY_SIZE(tlv320aic23_dapm_widgets));
+
+        snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
+        return 0;
+}
+
+static struct snd_soc_dai_link snappercl15_dai = {
+        .name           = "tlv320aic23",
+        .stream_name    = "AIC23",
+        .cpu_dai        = &ep93xx_i2s_dai,
+        .codec_dai      = &tlv320aic23_dai,
+        .init           = snappercl15_tlv320aic23_init,
+        .ops            = &snappercl15_ops,
+};
+
+static struct snd_soc_card snd_soc_snappercl15 = {
+        .name           = "Snapper CL15",
+        .platform       = &ep93xx_soc_platform,
+        .dai_link       = &snappercl15_dai,
+        .num_links      = 1,
+};
+
+static struct snd_soc_device snappercl15_snd_devdata = {
+        .card           = &snd_soc_snappercl15,
+        .codec_dev      = &soc_codec_dev_tlv320aic23,
+};
+
+static struct platform_device *snappercl15_snd_device;
+
+static int __init snappercl15_init(void)
+{
+        int ret;
+
+        if (!machine_is_snapper_cl15())
+                return -ENODEV;
+
+        ret = ep93xx_i2s_acquire(EP93XX_SYSCON_DEVCFG_I2SONAC97,
+                                 EP93XX_SYSCON_I2SCLKDIV_ORIDE |
+                                 EP93XX_SYSCON_I2SCLKDIV_SPOL);
+        if (ret)
+                return ret;
+
+        snappercl15_snd_device = platform_device_alloc("soc-audio", -1);
+        if (!snappercl15_snd_device)
+                return -ENOMEM;
+        
+        platform_set_drvdata(snappercl15_snd_device, &snappercl15_snd_devdata);
+        snappercl15_snd_devdata.dev = &snappercl15_snd_device->dev;
+        ret = platform_device_add(snappercl15_snd_device);
+        if (ret)
+                platform_device_put(snappercl15_snd_device);
+
+        return ret;
+}
+
+static void __exit snappercl15_exit(void)
+{
+        platform_device_unregister(snappercl15_snd_device);
+        ep93xx_i2s_release();
+}
+
+module_init(snappercl15_init);
+module_exit(snappercl15_exit);
+
+MODULE_AUTHOR("Ryan Mallon <ryan@bluewatersys.com>");
+MODULE_DESCRIPTION("ALSA SoC Snapper CL15");
+MODULE_LICENSE("GPL");
+
diff --git a/sound/soc/fsl/mpc5200_dma.c b/sound/soc/fsl/mpc5200_dma.c
index 1d4e7164e80a..3dcd1469f283 100644
--- a/sound/soc/fsl/mpc5200_dma.c
+++ b/sound/soc/fsl/mpc5200_dma.c
@@ -369,7 +369,7 @@ struct snd_soc_platform mpc5200_audio_dma_platform = {
 };
 EXPORT_SYMBOL_GPL(mpc5200_audio_dma_platform);
 
-int mpc5200_audio_dma_create(struct of_device *op)
+int mpc5200_audio_dma_create(struct platform_device *op)
 {
         phys_addr_t fifo;
         struct psc_dma *psc_dma;
@@ -488,7 +488,7 @@ out_unmap:
 }
 EXPORT_SYMBOL_GPL(mpc5200_audio_dma_create);
 
-int mpc5200_audio_dma_destroy(struct of_device *op)
+int mpc5200_audio_dma_destroy(struct platform_device *op)
 {
         struct psc_dma *psc_dma = dev_get_drvdata(&op->dev);
 
diff --git a/sound/soc/fsl/mpc5200_dma.h b/sound/soc/fsl/mpc5200_dma.h
index e1ec6d91ea38..ca99586f2ad9 100644
--- a/sound/soc/fsl/mpc5200_dma.h
+++ b/sound/soc/fsl/mpc5200_dma.h
@@ -81,8 +81,8 @@ to_psc_dma_stream(struct snd_pcm_substream *substream, struct psc_dma *psc_dma)
         return &psc_dma->playback;
 }
 
-int mpc5200_audio_dma_create(struct of_device *op);
-int mpc5200_audio_dma_destroy(struct of_device *op);
+int mpc5200_audio_dma_create(struct platform_device *op);
+int mpc5200_audio_dma_destroy(struct platform_device *op);
 
 extern struct snd_soc_platform mpc5200_audio_dma_platform;
 
diff --git a/sound/soc/fsl/mpc5200_psc_ac97.c b/sound/soc/fsl/mpc5200_psc_ac97.c
index e2ee220bfb7e..a9560235daee 100644
--- a/sound/soc/fsl/mpc5200_psc_ac97.c
+++ b/sound/soc/fsl/mpc5200_psc_ac97.c
@@ -20,6 +20,7 @@
 
 #include <asm/time.h>
 #include <asm/delay.h>
+#include <asm/mpc52xx.h>
 #include <asm/mpc52xx_psc.h>
 
 #include "mpc5200_dma.h"
@@ -100,19 +101,32 @@ static void psc_ac97_warm_reset(struct snd_ac97 *ac97)
 {
         struct mpc52xx_psc __iomem *regs = psc_dma->psc_regs;
 
+        mutex_lock(&psc_dma->mutex);
+
         out_be32(&regs->sicr, psc_dma->sicr | MPC52xx_PSC_SICR_AWR);
         udelay(3);
         out_be32(&regs->sicr, psc_dma->sicr);
+
+        mutex_unlock(&psc_dma->mutex);
 }
 
 static void psc_ac97_cold_reset(struct snd_ac97 *ac97)
 {
         struct mpc52xx_psc __iomem *regs = psc_dma->psc_regs;
 
-        /* Do a cold reset */
-        out_8(&regs->op1, MPC52xx_PSC_OP_RES);
-        udelay(10);
-        out_8(&regs->op0, MPC52xx_PSC_OP_RES);
+        mutex_lock(&psc_dma->mutex);
+        dev_dbg(psc_dma->dev, "cold reset\n");
+
+        mpc5200_psc_ac97_gpio_reset(psc_dma->id);
+
+        /* Notify the PSC that a reset has occurred */
+        out_be32(&regs->sicr, psc_dma->sicr | MPC52xx_PSC_SICR_ACRB);
+
+        /* Re-enable RX and TX */
+        out_8(&regs->command, MPC52xx_PSC_TX_ENABLE | MPC52xx_PSC_RX_ENABLE);
+
+        mutex_unlock(&psc_dma->mutex);
+
         msleep(1);
         psc_ac97_warm_reset(ac97);
 }
@@ -263,7 +277,7 @@ EXPORT_SYMBOL_GPL(psc_ac97_dai);
  * - Probe/remove operations
  * - OF device match table
  */
-static int __devinit psc_ac97_of_probe(struct of_device *op,
+static int __devinit psc_ac97_of_probe(struct platform_device *op,
                                       const struct of_device_id *match)
 {
         int rc, i;
@@ -303,7 +317,7 @@ static int __devinit psc_ac97_of_probe(struct of_device *op,
         return 0;
 }
 
-static int __devexit psc_ac97_of_remove(struct of_device *op)
+static int __devexit psc_ac97_of_remove(struct platform_device *op)
 {
         return mpc5200_audio_dma_destroy(op);
 }
diff --git a/sound/soc/fsl/mpc5200_psc_i2s.c b/sound/soc/fsl/mpc5200_psc_i2s.c
index 4f455bd6851f..534f04cb15d7 100644
--- a/sound/soc/fsl/mpc5200_psc_i2s.c
+++ b/sound/soc/fsl/mpc5200_psc_i2s.c
@@ -16,7 +16,6 @@
 
 #include <asm/mpc52xx_psc.h>
 
-#include "mpc5200_psc_i2s.h"
 #include "mpc5200_dma.h"
 
 /**
@@ -153,7 +152,7 @@ EXPORT_SYMBOL_GPL(psc_i2s_dai);
  * - Probe/remove operations
  * - OF device match table
  */
-static int __devinit psc_i2s_of_probe(struct of_device *op,
+static int __devinit psc_i2s_of_probe(struct platform_device *op,
                                       const struct of_device_id *match)
 {
         int rc;
@@ -206,7 +205,7 @@ static int __devinit psc_i2s_of_probe(struct of_device *op,
 
 }
 
-static int __devexit psc_i2s_of_remove(struct of_device *op)
+static int __devexit psc_i2s_of_remove(struct platform_device *op)
 {
         return mpc5200_audio_dma_destroy(op);
 }
diff --git a/sound/soc/fsl/mpc5200_psc_i2s.h b/sound/soc/fsl/mpc5200_psc_i2s.h
deleted file mode 100644
index ce55e070fdf3..000000000000
--- a/sound/soc/fsl/mpc5200_psc_i2s.h
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * Freescale MPC5200 PSC in I2S mode
- * ALSA SoC Digital Audio Interface (DAI) driver
- *
- */
-
-#ifndef __SOUND_SOC_FSL_MPC52xx_PSC_I2S_H__
-#define __SOUND_SOC_FSL_MPC52xx_PSC_I2S_H__
-
-extern struct snd_soc_dai psc_i2s_dai[];
-
-#endif /* __SOUND_SOC_FSL_MPC52xx_PSC_I2S_H__ */
diff --git a/sound/soc/fsl/mpc8610_hpcd.c b/sound/soc/fsl/mpc8610_hpcd.c
index 6a2764ee8203..3b13b8d65262 100644
--- a/sound/soc/fsl/mpc8610_hpcd.c
+++ b/sound/soc/fsl/mpc8610_hpcd.c
@@ -46,7 +46,7 @@ struct mpc8610_hpcd_data {
 };
 
 /**
- * mpc8610_hpcd_machine_probe: initalize the board
+ * mpc8610_hpcd_machine_probe: initialize the board
  *
  * This function is called when platform_device_add() is called.  It is used
  * to initialize the board-specific hardware.
@@ -200,7 +200,7 @@ static struct snd_soc_ops mpc8610_hpcd_ops = {
  * SSI devices.  We also probably aren't compatible with the generic Elo DMA
  * device driver.
  */
-static int mpc8610_hpcd_probe(struct of_device *ofdev,
+static int mpc8610_hpcd_probe(struct platform_device *ofdev,
         const struct of_device_id *match)
 {
         struct device_node *np = ofdev->dev.of_node;
@@ -534,7 +534,7 @@ error:
  *
  * This function is called when the OF device is removed.
  */
-static int mpc8610_hpcd_remove(struct of_device *ofdev)
+static int mpc8610_hpcd_remove(struct platform_device *ofdev)
 {
         struct platform_device *sound_device = dev_get_drvdata(&ofdev->dev);
         struct mpc8610_hpcd_data *machine_data =
diff --git a/sound/soc/imx/Kconfig b/sound/soc/imx/Kconfig
index 252defea93b5..687c76fc0839 100644
--- a/sound/soc/imx/Kconfig
+++ b/sound/soc/imx/Kconfig
@@ -1,4 +1,4 @@
-config SND_IMX_SOC
+menuconfig SND_IMX_SOC
         tristate "SoC Audio for Freescale i.MX CPUs"
         depends on ARCH_MXC
         select SND_PCM
@@ -8,14 +8,12 @@ config SND_IMX_SOC
           Say Y or M if you want to add support for codecs attached to
           the i.MX SSI interface.
 
-config SND_MXC_SOC_SSI
-        tristate
+if SND_IMX_SOC
 
 config SND_MXC_SOC_WM1133_EV1
         tristate "Audio on the the i.MX31ADS with WM1133-EV1 fitted"
-        depends on SND_IMX_SOC && MACH_MX31ADS_WM1133_EV1 && EXPERIMENTAL
+        depends on MACH_MX31ADS_WM1133_EV1 && EXPERIMENTAL
         select SND_SOC_WM8350
-        select SND_MXC_SOC_SSI
         help
           Enable support for audio on the i.MX31ADS with the WM1133-EV1
           PMIC board with WM8835x fitted.
@@ -23,8 +21,19 @@ config SND_MXC_SOC_WM1133_EV1
 config SND_SOC_PHYCORE_AC97
         tristate "SoC Audio support for Phytec phyCORE (and phyCARD) boards"
         depends on MACH_PCM043 || MACH_PCA100
-        select SND_MXC_SOC_SSI
         select SND_SOC_WM9712
         help
           Say Y if you want to add support for SoC audio on Phytec phyCORE
           and phyCARD boards in AC97 mode
+
+config SND_SOC_EUKREA_TLV320
+        tristate "Eukrea TLV320"
+        depends on MACH_EUKREA_MBIMX27_BASEBOARD \
+                || MACH_EUKREA_MBIMXSD25_BASEBOARD \
+                || MACH_EUKREA_MBIMXSD35_BASEBOARD
+        select SND_SOC_TLV320AIC23
+        help
+          Enable I2S based access to the TLV320AIC23B codec attached
+          to the SSI interface
+
+endif   # SND_IMX_SOC
diff --git a/sound/soc/imx/Makefile b/sound/soc/imx/Makefile
index 2d203635ac11..7bc57baf2b0e 100644
--- a/sound/soc/imx/Makefile
+++ b/sound/soc/imx/Makefile
@@ -8,8 +8,10 @@ endif
 obj-$(CONFIG_SND_IMX_SOC) += snd-soc-imx.o
 
 # i.MX Machine Support
+snd-soc-eukrea-tlv320-objs := eukrea-tlv320.o
 snd-soc-phycore-ac97-objs := phycore-ac97.o
 snd-soc-wm1133-ev1-objs := wm1133-ev1.o
 
+obj-$(CONFIG_SND_SOC_EUKREA_TLV320) += snd-soc-eukrea-tlv320.o
 obj-$(CONFIG_SND_SOC_PHYCORE_AC97) += snd-soc-phycore-ac97.o
 obj-$(CONFIG_SND_MXC_SOC_WM1133_EV1) += snd-soc-wm1133-ev1.o
diff --git a/sound/soc/imx/eukrea-tlv320.c b/sound/soc/imx/eukrea-tlv320.c
new file mode 100644
index 000000000000..f15dfbdc47ee
--- /dev/null
+++ b/sound/soc/imx/eukrea-tlv320.c
@@ -0,0 +1,137 @@
+/*
+ * eukrea-tlv320.c  --  SoC audio for eukrea_cpuimxXX in I2S mode
+ *
+ * Copyright 2010 Eric Bénard, Eukréa Electromatique <eric@eukrea.com>
+ *
+ * based on sound/soc/s3c24xx/s3c24xx_simtec_tlv320aic23.c
+ * which is Copyright 2009 Simtec Electronics
+ * and on sound/soc/imx/phycore-ac97.c which is
+ * Copyright 2009 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de>
+ * 
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/device.h>
+#include <linux/i2c.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <asm/mach-types.h>
+
+#include "../codecs/tlv320aic23.h"
+#include "imx-ssi.h"
+
+#define CODEC_CLOCK 12000000
+
+static int eukrea_tlv320_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->dai->codec_dai;
+        struct snd_soc_dai *cpu_dai = rtd->dai->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);
+        if (ret) {
+                pr_err("%s: failed set cpu dai format\n", __func__);
+                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) {
+                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_OUT);
+        if (ret) {
+                pr_err("%s: failed setting codec sysclk\n", __func__);
+                return ret;
+        }
+        snd_soc_dai_set_tdm_slot(cpu_dai, 0xffffffc, 0xffffffc, 2, 0);
+
+        ret = snd_soc_dai_set_sysclk(cpu_dai, IMX_SSP_SYS_CLK, 0,
+                                SND_SOC_CLOCK_IN);
+        if (ret) {
+                pr_err("can't set CPU system clock IMX_SSP_SYS_CLK\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static struct snd_soc_ops eukrea_tlv320_snd_ops = {
+        .hw_params      = eukrea_tlv320_hw_params,
+};
+
+static struct snd_soc_dai_link eukrea_tlv320_dai = {
+        .name           = "tlv320aic23",
+        .stream_name    = "TLV320AIC23",
+        .codec_dai      = &tlv320aic23_dai,
+        .ops            = &eukrea_tlv320_snd_ops,
+};
+
+static struct snd_soc_card eukrea_tlv320 = {
+        .name           = "cpuimx-audio",
+        .platform       = &imx_soc_platform,
+        .dai_link       = &eukrea_tlv320_dai,
+        .num_links      = 1,
+};
+
+static struct snd_soc_device eukrea_tlv320_snd_devdata = {
+        .card           = &eukrea_tlv320,
+        .codec_dev      = &soc_codec_dev_tlv320aic23,
+};
+
+static struct platform_device *eukrea_tlv320_snd_device;
+
+static int __init eukrea_tlv320_init(void)
+{
+        int ret;
+
+        if (!machine_is_eukrea_cpuimx27() && !machine_is_eukrea_cpuimx25sd()
+                && !machine_is_eukrea_cpuimx35sd())
+                /* return happy. We might run on a totally different machine */
+                return 0;
+
+        eukrea_tlv320_snd_device = platform_device_alloc("soc-audio", -1);
+        if (!eukrea_tlv320_snd_device)
+                return -ENOMEM;
+
+        eukrea_tlv320_dai.cpu_dai = &imx_ssi_pcm_dai[0];
+
+        platform_set_drvdata(eukrea_tlv320_snd_device, &eukrea_tlv320_snd_devdata);
+        eukrea_tlv320_snd_devdata.dev = &eukrea_tlv320_snd_device->dev;
+        ret = platform_device_add(eukrea_tlv320_snd_device);
+
+        if (ret) {
+                printk(KERN_ERR "ASoC: Platform device allocation failed\n");
+                platform_device_put(eukrea_tlv320_snd_device);
+        }
+
+        return ret;
+}
+
+static void __exit eukrea_tlv320_exit(void)
+{
+        platform_device_unregister(eukrea_tlv320_snd_device);
+}
+
+module_init(eukrea_tlv320_init);
+module_exit(eukrea_tlv320_exit);
+
+MODULE_AUTHOR("Eric Bénard <eric@eukrea.com>");
+MODULE_DESCRIPTION("CPUIMX ALSA SoC driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/imx/imx-pcm-dma-mx2.c b/sound/soc/imx/imx-pcm-dma-mx2.c
index 05f19c9284f4..0a595da4811d 100644
--- a/sound/soc/imx/imx-pcm-dma-mx2.c
+++ b/sound/soc/imx/imx-pcm-dma-mx2.c
@@ -292,12 +292,16 @@ static int snd_imx_open(struct snd_pcm_substream *substream)
         int ret;
 
         iprtd = kzalloc(sizeof(*iprtd), GFP_KERNEL);
+        if (iprtd == NULL)
+                return -ENOMEM;
         runtime->private_data = iprtd;
 
         ret = snd_pcm_hw_constraint_integer(substream->runtime,
                         SNDRV_PCM_HW_PARAM_PERIODS);
-        if (ret < 0)
+        if (ret < 0) {
+                kfree(iprtd);
                 return ret;
+        }
 
         snd_soc_set_runtime_hwparams(substream, &snd_imx_hardware);
         return 0;
diff --git a/sound/soc/imx/imx-pcm-fiq.c b/sound/soc/imx/imx-pcm-fiq.c
index 6b518e07eea9..b2bf27282cd2 100644
--- a/sound/soc/imx/imx-pcm-fiq.c
+++ b/sound/soc/imx/imx-pcm-fiq.c
@@ -192,6 +192,8 @@ static int snd_imx_open(struct snd_pcm_substream *substream)
         int ret;
 
         iprtd = kzalloc(sizeof(*iprtd), GFP_KERNEL);
+        if (iprtd == NULL)
+                return -ENOMEM;
         runtime->private_data = iprtd;
 
         iprtd->substream = substream;
@@ -202,8 +204,10 @@ static int snd_imx_open(struct snd_pcm_substream *substream)
 
         ret = snd_pcm_hw_constraint_integer(substream->runtime,
                         SNDRV_PCM_HW_PARAM_PERIODS);
-        if (ret < 0)
+        if (ret < 0) {
+                kfree(iprtd);
                 return ret;
+        }
 
         snd_soc_set_runtime_hwparams(substream, &snd_imx_hardware);
         return 0;
diff --git a/sound/soc/imx/imx-ssi.c b/sound/soc/imx/imx-ssi.c
index 80b4fee2442b..c81da05a4f11 100644
--- a/sound/soc/imx/imx-ssi.c
+++ b/sound/soc/imx/imx-ssi.c
@@ -23,7 +23,7 @@
  * between pcm data and GPIO status data changes. Our FIQ handler is not
  * able to handle this, hence this driver only works with 48000Hz sampling
  * rate.
- * Reading and writing AC97 registers is another challange. The core
+ * Reading and writing AC97 registers is another challenge. The core
  * provides us status bits when the read register is updated with *another*
  * value. When we read the same register two times (and the register still
  * contains the same value) these status bits are not set. We work
@@ -83,8 +83,6 @@ static int imx_ssi_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai,
 /*
  * SSI DAI format configuration.
  * Should only be called when port is inactive (i.e. SSIEN = 0).
- * Note: We don't use the I2S modes but instead manually configure the
- * SSI for I2S because the I2S mode is only a register preset.
  */
 static int imx_ssi_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
 {
@@ -99,6 +97,10 @@ static int imx_ssi_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
                 /* data on rising edge of bclk, frame low 1clk before data */
                 strcr |= SSI_STCR_TFSI | SSI_STCR_TEFS | SSI_STCR_TXBIT0;
                 scr |= SSI_SCR_NET;
+                if (ssi->flags & IMX_SSI_USE_I2S_SLAVE) {
+                        scr &= ~SSI_I2S_MODE_MASK;
+                        scr |= SSI_SCR_I2S_MODE_SLAVE;
+                }
                 break;
         case SND_SOC_DAIFMT_LEFT_J:
                 /* data on rising edge of bclk, frame high with data */
@@ -143,6 +145,11 @@ static int imx_ssi_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
 
         strcr |= SSI_STCR_TFEN0;
 
+        if (ssi->flags & IMX_SSI_NET)
+                scr |= SSI_SCR_NET;
+        if (ssi->flags & IMX_SSI_SYN)
+                scr |= SSI_SCR_SYN;
+
         writel(strcr, ssi->base + SSI_STCR);
         writel(strcr, ssi->base + SSI_SRCR);
         writel(scr, ssi->base + SSI_SCR);
@@ -247,6 +254,9 @@ static int imx_ssi_hw_params(struct snd_pcm_substream *substream,
                 dma_data = &ssi->dma_params_rx;
         }
 
+        if (ssi->flags & IMX_SSI_SYN)
+                reg = SSI_STCCR;
+
         snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
 
         sccr = readl(ssi->base + reg) & ~SSI_STCCR_WL_MASK;
diff --git a/sound/soc/jz4740/Kconfig b/sound/soc/jz4740/Kconfig
new file mode 100644
index 000000000000..5351cba66c9e
--- /dev/null
+++ b/sound/soc/jz4740/Kconfig
@@ -0,0 +1,23 @@
+config SND_JZ4740_SOC
+        tristate "SoC Audio for Ingenic JZ4740 SoC"
+        depends on MACH_JZ4740 && SND_SOC
+        help
+          Say Y or M if you want to add support for codecs attached to
+          the JZ4740 I2S interface. You will also need to select the audio
+          interfaces to support below.
+
+config SND_JZ4740_SOC_I2S
+        depends on SND_JZ4740_SOC
+        tristate "SoC Audio (I2S protocol) for Ingenic JZ4740 SoC"
+        help
+          Say Y if you want to use I2S protocol and I2S codec on Ingenic JZ4740
+          based boards.
+
+config SND_JZ4740_SOC_QI_LB60
+        tristate "SoC Audio support for Qi LB60"
+        depends on SND_JZ4740_SOC && JZ4740_QI_LB60
+        select SND_JZ4740_SOC_I2S
+    select SND_SOC_JZ4740_CODEC
+        help
+          Say Y if you want to add support for ASoC audio on the Qi LB60 board
+          a.k.a Qi Ben NanoNote.
diff --git a/sound/soc/jz4740/Makefile b/sound/soc/jz4740/Makefile
new file mode 100644
index 000000000000..be873c1b0c20
--- /dev/null
+++ b/sound/soc/jz4740/Makefile
@@ -0,0 +1,13 @@
+#
+# Jz4740 Platform Support
+#
+snd-soc-jz4740-objs := jz4740-pcm.o
+snd-soc-jz4740-i2s-objs := jz4740-i2s.o
+
+obj-$(CONFIG_SND_JZ4740_SOC) += snd-soc-jz4740.o
+obj-$(CONFIG_SND_JZ4740_SOC_I2S) += snd-soc-jz4740-i2s.o
+
+# Jz4740 Machine Support
+snd-soc-qi-lb60-objs := qi_lb60.o
+
+obj-$(CONFIG_SND_JZ4740_SOC_QI_LB60) += snd-soc-qi-lb60.o
diff --git a/sound/soc/jz4740/jz4740-i2s.c b/sound/soc/jz4740/jz4740-i2s.c
new file mode 100644
index 000000000000..eb518f0c5e01
--- /dev/null
+++ b/sound/soc/jz4740/jz4740-i2s.c
@@ -0,0 +1,540 @@
+/*
+ *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.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.
+ *
+ *  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.
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+
+#include <linux/dma-mapping.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+
+#include "jz4740-i2s.h"
+#include "jz4740-pcm.h"
+
+#define JZ_REG_AIC_CONF         0x00
+#define JZ_REG_AIC_CTRL         0x04
+#define JZ_REG_AIC_I2S_FMT      0x10
+#define JZ_REG_AIC_FIFO_STATUS  0x14
+#define JZ_REG_AIC_I2S_STATUS   0x1c
+#define JZ_REG_AIC_CLK_DIV      0x30
+#define JZ_REG_AIC_FIFO         0x34
+
+#define JZ_AIC_CONF_FIFO_RX_THRESHOLD_MASK (0xf << 12)
+#define JZ_AIC_CONF_FIFO_TX_THRESHOLD_MASK (0xf <<  8)
+#define JZ_AIC_CONF_OVERFLOW_PLAY_LAST BIT(6)
+#define JZ_AIC_CONF_INTERNAL_CODEC BIT(5)
+#define JZ_AIC_CONF_I2S BIT(4)
+#define JZ_AIC_CONF_RESET BIT(3)
+#define JZ_AIC_CONF_BIT_CLK_MASTER BIT(2)
+#define JZ_AIC_CONF_SYNC_CLK_MASTER BIT(1)
+#define JZ_AIC_CONF_ENABLE BIT(0)
+
+#define JZ_AIC_CONF_FIFO_RX_THRESHOLD_OFFSET 12
+#define JZ_AIC_CONF_FIFO_TX_THRESHOLD_OFFSET 8
+
+#define JZ_AIC_CTRL_OUTPUT_SAMPLE_SIZE_MASK (0x7 << 19)
+#define JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_MASK (0x7 << 16)
+#define JZ_AIC_CTRL_ENABLE_RX_DMA BIT(15)
+#define JZ_AIC_CTRL_ENABLE_TX_DMA BIT(14)
+#define JZ_AIC_CTRL_MONO_TO_STEREO BIT(11)
+#define JZ_AIC_CTRL_SWITCH_ENDIANNESS BIT(10)
+#define JZ_AIC_CTRL_SIGNED_TO_UNSIGNED BIT(9)
+#define JZ_AIC_CTRL_FLUSH               BIT(8)
+#define JZ_AIC_CTRL_ENABLE_ROR_INT BIT(6)
+#define JZ_AIC_CTRL_ENABLE_TUR_INT BIT(5)
+#define JZ_AIC_CTRL_ENABLE_RFS_INT BIT(4)
+#define JZ_AIC_CTRL_ENABLE_TFS_INT BIT(3)
+#define JZ_AIC_CTRL_ENABLE_LOOPBACK BIT(2)
+#define JZ_AIC_CTRL_ENABLE_PLAYBACK BIT(1)
+#define JZ_AIC_CTRL_ENABLE_CAPTURE BIT(0)
+
+#define JZ_AIC_CTRL_OUTPUT_SAMPLE_SIZE_OFFSET 19
+#define JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_OFFSET  16
+
+#define JZ_AIC_I2S_FMT_DISABLE_BIT_CLK BIT(12)
+#define JZ_AIC_I2S_FMT_ENABLE_SYS_CLK BIT(4)
+#define JZ_AIC_I2S_FMT_MSB BIT(0)
+
+#define JZ_AIC_I2S_STATUS_BUSY BIT(2)
+
+#define JZ_AIC_CLK_DIV_MASK 0xf
+
+struct jz4740_i2s {
+        struct resource *mem;
+        void __iomem *base;
+        dma_addr_t phys_base;
+
+        struct clk *clk_aic;
+        struct clk *clk_i2s;
+
+        struct jz4740_pcm_config pcm_config_playback;
+        struct jz4740_pcm_config pcm_config_capture;
+};
+
+static inline uint32_t jz4740_i2s_read(const struct jz4740_i2s *i2s,
+        unsigned int reg)
+{
+        return readl(i2s->base + reg);
+}
+
+static inline void jz4740_i2s_write(const struct jz4740_i2s *i2s,
+        unsigned int reg, uint32_t value)
+{
+        writel(value, i2s->base + reg);
+}
+
+static inline struct jz4740_i2s *jz4740_dai_to_i2s(struct snd_soc_dai *dai)
+{
+        return dai->private_data;
+}
+
+static int jz4740_i2s_startup(struct snd_pcm_substream *substream,
+        struct snd_soc_dai *dai)
+{
+        struct jz4740_i2s *i2s = jz4740_dai_to_i2s(dai);
+        uint32_t conf, ctrl;
+
+        if (dai->active)
+                return 0;
+
+        ctrl = jz4740_i2s_read(i2s, JZ_REG_AIC_CTRL);
+        ctrl |= JZ_AIC_CTRL_FLUSH;
+        jz4740_i2s_write(i2s, JZ_REG_AIC_CTRL, ctrl);
+
+        clk_enable(i2s->clk_i2s);
+
+        conf = jz4740_i2s_read(i2s, JZ_REG_AIC_CONF);
+        conf |= JZ_AIC_CONF_ENABLE;
+        jz4740_i2s_write(i2s, JZ_REG_AIC_CONF, conf);
+
+        return 0;
+}
+
+static void jz4740_i2s_shutdown(struct snd_pcm_substream *substream,
+        struct snd_soc_dai *dai)
+{
+        struct jz4740_i2s *i2s = jz4740_dai_to_i2s(dai);
+        uint32_t conf;
+
+        if (!dai->active)
+                return;
+
+        conf = jz4740_i2s_read(i2s, JZ_REG_AIC_CONF);
+        conf &= ~JZ_AIC_CONF_ENABLE;
+        jz4740_i2s_write(i2s, JZ_REG_AIC_CONF, conf);
+
+        clk_disable(i2s->clk_i2s);
+}
+
+static int jz4740_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
+        struct snd_soc_dai *dai)
+{
+        struct jz4740_i2s *i2s = jz4740_dai_to_i2s(dai);
+
+        uint32_t ctrl;
+        uint32_t mask;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                mask = JZ_AIC_CTRL_ENABLE_PLAYBACK | JZ_AIC_CTRL_ENABLE_TX_DMA;
+        else
+                mask = JZ_AIC_CTRL_ENABLE_CAPTURE | JZ_AIC_CTRL_ENABLE_RX_DMA;
+
+        ctrl = jz4740_i2s_read(i2s, JZ_REG_AIC_CTRL);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                ctrl |= mask;
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                ctrl &= ~mask;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        jz4740_i2s_write(i2s, JZ_REG_AIC_CTRL, ctrl);
+
+        return 0;
+}
+
+static int jz4740_i2s_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
+{
+        struct jz4740_i2s *i2s = jz4740_dai_to_i2s(dai);
+
+        uint32_t format = 0;
+        uint32_t conf;
+
+        conf = jz4740_i2s_read(i2s, JZ_REG_AIC_CONF);
+
+        conf &= ~(JZ_AIC_CONF_BIT_CLK_MASTER | JZ_AIC_CONF_SYNC_CLK_MASTER);
+
+        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+        case SND_SOC_DAIFMT_CBS_CFS:
+                conf |= JZ_AIC_CONF_BIT_CLK_MASTER | JZ_AIC_CONF_SYNC_CLK_MASTER;
+                format |= JZ_AIC_I2S_FMT_ENABLE_SYS_CLK;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFS:
+                conf |= JZ_AIC_CONF_SYNC_CLK_MASTER;
+                break;
+        case SND_SOC_DAIFMT_CBS_CFM:
+                conf |= JZ_AIC_CONF_BIT_CLK_MASTER;
+                break;
+        case SND_SOC_DAIFMT_CBM_CFM:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_MSB:
+                format |= JZ_AIC_I2S_FMT_MSB;
+                break;
+        case SND_SOC_DAIFMT_I2S:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+        case SND_SOC_DAIFMT_NB_NF:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        jz4740_i2s_write(i2s, JZ_REG_AIC_CONF, conf);
+        jz4740_i2s_write(i2s, JZ_REG_AIC_I2S_FMT, format);
+
+        return 0;
+}
+
+static int jz4740_i2s_hw_params(struct snd_pcm_substream *substream,
+        struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
+{
+        struct jz4740_i2s *i2s = jz4740_dai_to_i2s(dai);
+        enum jz4740_dma_width dma_width;
+        struct jz4740_pcm_config *pcm_config;
+        unsigned int sample_size;
+        uint32_t ctrl;
+
+        ctrl = jz4740_i2s_read(i2s, JZ_REG_AIC_CTRL);
+
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S8:
+                sample_size = 0;
+                dma_width = JZ4740_DMA_WIDTH_8BIT;
+                break;
+        case SNDRV_PCM_FORMAT_S16:
+                sample_size = 1;
+                dma_width = JZ4740_DMA_WIDTH_16BIT;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                ctrl &= ~JZ_AIC_CTRL_OUTPUT_SAMPLE_SIZE_MASK;
+                ctrl |= sample_size << JZ_AIC_CTRL_OUTPUT_SAMPLE_SIZE_OFFSET;
+                if (params_channels(params) == 1)
+                        ctrl |= JZ_AIC_CTRL_MONO_TO_STEREO;
+                else
+                        ctrl &= ~JZ_AIC_CTRL_MONO_TO_STEREO;
+
+                pcm_config = &i2s->pcm_config_playback;
+                pcm_config->dma_config.dst_width = dma_width;
+
+        } else {
+                ctrl &= ~JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_MASK;
+                ctrl |= sample_size << JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_OFFSET;
+
+                pcm_config = &i2s->pcm_config_capture;
+                pcm_config->dma_config.src_width = dma_width;
+        }
+
+        jz4740_i2s_write(i2s, JZ_REG_AIC_CTRL, ctrl);
+
+        snd_soc_dai_set_dma_data(dai, substream, pcm_config);
+
+        return 0;
+}
+
+static int jz4740_i2s_set_sysclk(struct snd_soc_dai *dai, int clk_id,
+        unsigned int freq, int dir)
+{
+        struct jz4740_i2s *i2s = jz4740_dai_to_i2s(dai);
+        struct clk *parent;
+        int ret = 0;
+
+        switch (clk_id) {
+        case JZ4740_I2S_CLKSRC_EXT:
+                parent = clk_get(NULL, "ext");
+                clk_set_parent(i2s->clk_i2s, parent);
+                break;
+        case JZ4740_I2S_CLKSRC_PLL:
+                parent = clk_get(NULL, "pll half");
+                clk_set_parent(i2s->clk_i2s, parent);
+                ret = clk_set_rate(i2s->clk_i2s, freq);
+                break;
+        default:
+                return -EINVAL;
+        }
+        clk_put(parent);
+
+        return ret;
+}
+
+static int jz4740_i2s_suspend(struct snd_soc_dai *dai)
+{
+        struct jz4740_i2s *i2s = jz4740_dai_to_i2s(dai);
+        uint32_t conf;
+
+        if (dai->active) {
+                conf = jz4740_i2s_read(i2s, JZ_REG_AIC_CONF);
+                conf &= ~JZ_AIC_CONF_ENABLE;
+                jz4740_i2s_write(i2s, JZ_REG_AIC_CONF, conf);
+
+                clk_disable(i2s->clk_i2s);
+        }
+
+        clk_disable(i2s->clk_aic);
+
+        return 0;
+}
+
+static int jz4740_i2s_resume(struct snd_soc_dai *dai)
+{
+        struct jz4740_i2s *i2s = jz4740_dai_to_i2s(dai);
+        uint32_t conf;
+
+        clk_enable(i2s->clk_aic);
+
+        if (dai->active) {
+                clk_enable(i2s->clk_i2s);
+
+                conf = jz4740_i2s_read(i2s, JZ_REG_AIC_CONF);
+                conf |= JZ_AIC_CONF_ENABLE;
+                jz4740_i2s_write(i2s, JZ_REG_AIC_CONF, conf);
+        }
+
+        return 0;
+}
+
+static int jz4740_i2s_probe(struct platform_device *pdev, struct snd_soc_dai *dai)
+{
+        struct jz4740_i2s *i2s = jz4740_dai_to_i2s(dai);
+        uint32_t conf;
+
+        conf = (7 << JZ_AIC_CONF_FIFO_RX_THRESHOLD_OFFSET) |
+                (8 << JZ_AIC_CONF_FIFO_TX_THRESHOLD_OFFSET) |
+                JZ_AIC_CONF_OVERFLOW_PLAY_LAST |
+                JZ_AIC_CONF_I2S |
+                JZ_AIC_CONF_INTERNAL_CODEC;
+
+        jz4740_i2s_write(i2s, JZ_REG_AIC_CONF, JZ_AIC_CONF_RESET);
+        jz4740_i2s_write(i2s, JZ_REG_AIC_CONF, conf);
+
+        return 0;
+}
+
+static struct snd_soc_dai_ops jz4740_i2s_dai_ops = {
+        .startup = jz4740_i2s_startup,
+        .shutdown = jz4740_i2s_shutdown,
+        .trigger = jz4740_i2s_trigger,
+        .hw_params = jz4740_i2s_hw_params,
+        .set_fmt = jz4740_i2s_set_fmt,
+        .set_sysclk = jz4740_i2s_set_sysclk,
+};
+
+#define JZ4740_I2S_FMTS (SNDRV_PCM_FMTBIT_S8 | \
+                SNDRV_PCM_FMTBIT_S16_LE)
+
+struct snd_soc_dai jz4740_i2s_dai = {
+        .name = "jz4740-i2s",
+        .probe = jz4740_i2s_probe,
+        .playback = {
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+                .formats = JZ4740_I2S_FMTS,
+        },
+        .capture = {
+                .channels_min = 2,
+                .channels_max = 2,
+                .rates = SNDRV_PCM_RATE_8000_48000,
+                .formats = JZ4740_I2S_FMTS,
+        },
+        .symmetric_rates = 1,
+        .ops = &jz4740_i2s_dai_ops,
+        .suspend = jz4740_i2s_suspend,
+        .resume = jz4740_i2s_resume,
+};
+EXPORT_SYMBOL_GPL(jz4740_i2s_dai);
+
+static void __devinit jz4740_i2c_init_pcm_config(struct jz4740_i2s *i2s)
+{
+        struct jz4740_dma_config *dma_config;
+
+        /* Playback */
+        dma_config = &i2s->pcm_config_playback.dma_config;
+        dma_config->src_width = JZ4740_DMA_WIDTH_32BIT,
+        dma_config->transfer_size = JZ4740_DMA_TRANSFER_SIZE_16BYTE;
+        dma_config->request_type = JZ4740_DMA_TYPE_AIC_TRANSMIT;
+        dma_config->flags = JZ4740_DMA_SRC_AUTOINC;
+        dma_config->mode = JZ4740_DMA_MODE_SINGLE;
+        i2s->pcm_config_playback.fifo_addr = i2s->phys_base + JZ_REG_AIC_FIFO;
+
+        /* Capture */
+        dma_config = &i2s->pcm_config_capture.dma_config;
+        dma_config->dst_width = JZ4740_DMA_WIDTH_32BIT,
+        dma_config->transfer_size = JZ4740_DMA_TRANSFER_SIZE_16BYTE;
+        dma_config->request_type = JZ4740_DMA_TYPE_AIC_RECEIVE;
+        dma_config->flags = JZ4740_DMA_DST_AUTOINC;
+        dma_config->mode = JZ4740_DMA_MODE_SINGLE;
+        i2s->pcm_config_capture.fifo_addr = i2s->phys_base + JZ_REG_AIC_FIFO;
+}
+
+static int __devinit jz4740_i2s_dev_probe(struct platform_device *pdev)
+{
+        struct jz4740_i2s *i2s;
+        int ret;
+
+        i2s = kzalloc(sizeof(*i2s), GFP_KERNEL);
+
+        if (!i2s)
+                return -ENOMEM;
+
+        i2s->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!i2s->mem) {
+                ret = -ENOENT;
+                goto err_free;
+        }
+
+        i2s->mem = request_mem_region(i2s->mem->start, resource_size(i2s->mem),
+                                pdev->name);
+        if (!i2s->mem) {
+                ret = -EBUSY;
+                goto err_free;
+        }
+
+        i2s->base = ioremap_nocache(i2s->mem->start, resource_size(i2s->mem));
+        if (!i2s->base) {
+                ret = -EBUSY;
+                goto err_release_mem_region;
+        }
+
+        i2s->phys_base = i2s->mem->start;
+
+        i2s->clk_aic = clk_get(&pdev->dev, "aic");
+        if (IS_ERR(i2s->clk_aic)) {
+                ret = PTR_ERR(i2s->clk_aic);
+                goto err_iounmap;
+        }
+
+        i2s->clk_i2s = clk_get(&pdev->dev, "i2s");
+        if (IS_ERR(i2s->clk_i2s)) {
+                ret = PTR_ERR(i2s->clk_i2s);
+                goto err_clk_put_aic;
+        }
+
+        clk_enable(i2s->clk_aic);
+
+        jz4740_i2c_init_pcm_config(i2s);
+
+        jz4740_i2s_dai.private_data = i2s;
+        ret = snd_soc_register_dai(&jz4740_i2s_dai);
+
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to register DAI\n");
+                goto err_clk_put_i2s;
+        }
+
+        platform_set_drvdata(pdev, i2s);
+
+        return 0;
+
+err_clk_put_i2s:
+        clk_disable(i2s->clk_aic);
+        clk_put(i2s->clk_i2s);
+err_clk_put_aic:
+        clk_put(i2s->clk_aic);
+err_iounmap:
+        iounmap(i2s->base);
+err_release_mem_region:
+        release_mem_region(i2s->mem->start, resource_size(i2s->mem));
+err_free:
+        kfree(i2s);
+
+        return ret;
+}
+
+static int __devexit jz4740_i2s_dev_remove(struct platform_device *pdev)
+{
+        struct jz4740_i2s *i2s = platform_get_drvdata(pdev);
+
+        snd_soc_unregister_dai(&jz4740_i2s_dai);
+
+        clk_disable(i2s->clk_aic);
+        clk_put(i2s->clk_i2s);
+        clk_put(i2s->clk_aic);
+
+        iounmap(i2s->base);
+        release_mem_region(i2s->mem->start, resource_size(i2s->mem));
+
+        platform_set_drvdata(pdev, NULL);
+        kfree(i2s);
+
+        return 0;
+}
+
+static struct platform_driver jz4740_i2s_driver = {
+        .probe = jz4740_i2s_dev_probe,
+        .remove = __devexit_p(jz4740_i2s_dev_remove),
+        .driver = {
+                .name = "jz4740-i2s",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init jz4740_i2s_init(void)
+{
+        return platform_driver_register(&jz4740_i2s_driver);
+}
+module_init(jz4740_i2s_init);
+
+static void __exit jz4740_i2s_exit(void)
+{
+        platform_driver_unregister(&jz4740_i2s_driver);
+}
+module_exit(jz4740_i2s_exit);
+
+MODULE_AUTHOR("Lars-Peter Clausen, <lars@metafoo.de>");
+MODULE_DESCRIPTION("Ingenic JZ4740 SoC I2S driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:jz4740-i2s");
diff --git a/sound/soc/jz4740/jz4740-i2s.h b/sound/soc/jz4740/jz4740-i2s.h
new file mode 100644
index 000000000000..da22ed88a589
--- /dev/null
+++ b/sound/soc/jz4740/jz4740-i2s.h
@@ -0,0 +1,18 @@
+/*
+ * 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.
+ */
+
+#ifndef _JZ4740_I2S_H
+#define _JZ4740_I2S_H
+
+/* I2S clock source */
+#define JZ4740_I2S_CLKSRC_EXT 0
+#define JZ4740_I2S_CLKSRC_PLL 1
+
+#define JZ4740_I2S_BIT_CLK              0
+
+extern struct snd_soc_dai jz4740_i2s_dai;
+
+#endif
diff --git a/sound/soc/jz4740/jz4740-pcm.c b/sound/soc/jz4740/jz4740-pcm.c
new file mode 100644
index 000000000000..ee68d850c8dd
--- /dev/null
+++ b/sound/soc/jz4740/jz4740-pcm.c
@@ -0,0 +1,373 @@
+/*
+ *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.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.
+ *
+ *  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.
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#include <linux/dma-mapping.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+
+#include <asm/mach-jz4740/dma.h>
+#include "jz4740-pcm.h"
+
+struct jz4740_runtime_data {
+        unsigned long dma_period;
+        dma_addr_t dma_start;
+        dma_addr_t dma_pos;
+        dma_addr_t dma_end;
+
+        struct jz4740_dma_chan *dma;
+
+        dma_addr_t fifo_addr;
+};
+
+/* identify hardware playback capabilities */
+static const struct snd_pcm_hardware jz4740_pcm_hardware = {
+        .info = SNDRV_PCM_INFO_MMAP |
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_INTERLEAVED |
+                SNDRV_PCM_INFO_BLOCK_TRANSFER,
+        .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8,
+
+        .rates                  = SNDRV_PCM_RATE_8000_48000,
+        .channels_min           = 1,
+        .channels_max           = 2,
+        .period_bytes_min       = 16,
+        .period_bytes_max       = 2 * PAGE_SIZE,
+        .periods_min            = 2,
+        .periods_max            = 128,
+        .buffer_bytes_max       = 128 * 2 * PAGE_SIZE,
+        .fifo_size              = 32,
+};
+
+static void jz4740_pcm_start_transfer(struct jz4740_runtime_data *prtd,
+        struct snd_pcm_substream *substream)
+{
+        unsigned long count;
+
+        if (prtd->dma_pos == prtd->dma_end)
+                prtd->dma_pos = prtd->dma_start;
+
+        if (prtd->dma_pos + prtd->dma_period > prtd->dma_end)
+                count = prtd->dma_end - prtd->dma_pos;
+        else
+                count = prtd->dma_period;
+
+        jz4740_dma_disable(prtd->dma);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                jz4740_dma_set_src_addr(prtd->dma, prtd->dma_pos);
+                jz4740_dma_set_dst_addr(prtd->dma, prtd->fifo_addr);
+        } else {
+                jz4740_dma_set_src_addr(prtd->dma, prtd->fifo_addr);
+                jz4740_dma_set_dst_addr(prtd->dma, prtd->dma_pos);
+        }
+
+        jz4740_dma_set_transfer_count(prtd->dma, count);
+
+        prtd->dma_pos += count;
+
+        jz4740_dma_enable(prtd->dma);
+}
+
+static void jz4740_pcm_dma_transfer_done(struct jz4740_dma_chan *dma, int err,
+        void *dev_id)
+{
+        struct snd_pcm_substream *substream = dev_id;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct jz4740_runtime_data *prtd = runtime->private_data;
+
+        snd_pcm_period_elapsed(substream);
+
+        jz4740_pcm_start_transfer(prtd, substream);
+}
+
+static int jz4740_pcm_hw_params(struct snd_pcm_substream *substream,
+        struct snd_pcm_hw_params *params)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct jz4740_runtime_data *prtd = runtime->private_data;
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct jz4740_pcm_config *config;
+
+        config = snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
+
+        if (!config)
+                return 0;
+
+        if (!prtd->dma) {
+                if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                        prtd->dma = jz4740_dma_request(substream, "PCM Capture");
+                else
+                        prtd->dma = jz4740_dma_request(substream, "PCM Playback");
+        }
+
+        if (!prtd->dma)
+                return -EBUSY;
+
+        jz4740_dma_configure(prtd->dma, &config->dma_config);
+        prtd->fifo_addr = config->fifo_addr;
+
+        jz4740_dma_set_complete_cb(prtd->dma, jz4740_pcm_dma_transfer_done);
+
+        snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
+        runtime->dma_bytes = params_buffer_bytes(params);
+
+        prtd->dma_period = params_period_bytes(params);
+        prtd->dma_start = runtime->dma_addr;
+        prtd->dma_pos = prtd->dma_start;
+        prtd->dma_end = prtd->dma_start + runtime->dma_bytes;
+
+        return 0;
+}
+
+static int jz4740_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+        struct jz4740_runtime_data *prtd = substream->runtime->private_data;
+
+        snd_pcm_set_runtime_buffer(substream, NULL);
+        if (prtd->dma) {
+                jz4740_dma_free(prtd->dma);
+                prtd->dma = NULL;
+        }
+
+        return 0;
+}
+
+static int jz4740_pcm_prepare(struct snd_pcm_substream *substream)
+{
+        struct jz4740_runtime_data *prtd = substream->runtime->private_data;
+
+        if (!prtd->dma)
+                return -EBUSY;
+
+        prtd->dma_pos = prtd->dma_start;
+
+        return 0;
+}
+
+static int jz4740_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct jz4740_runtime_data *prtd = runtime->private_data;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                jz4740_pcm_start_transfer(prtd, substream);
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                jz4740_dma_disable(prtd->dma);
+                break;
+        default:
+                break;
+        }
+
+        return 0;
+}
+
+static snd_pcm_uframes_t jz4740_pcm_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct jz4740_runtime_data *prtd = runtime->private_data;
+        unsigned long byte_offset;
+        snd_pcm_uframes_t offset;
+        struct jz4740_dma_chan *dma = prtd->dma;
+
+        /* prtd->dma_pos points to the end of the current transfer. So by
+         * subtracting prdt->dma_start we get the offset to the end of the
+         * current period in bytes. By subtracting the residue of the transfer
+         * we get the current offset in bytes. */
+        byte_offset = prtd->dma_pos - prtd->dma_start;
+        byte_offset -= jz4740_dma_get_residue(dma);
+
+        offset = bytes_to_frames(runtime, byte_offset);
+        if (offset >= runtime->buffer_size)
+                offset = 0;
+
+        return offset;
+}
+
+static int jz4740_pcm_open(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct jz4740_runtime_data *prtd;
+
+        prtd = kzalloc(sizeof(*prtd), GFP_KERNEL);
+        if (prtd == NULL)
+                return -ENOMEM;
+
+        snd_soc_set_runtime_hwparams(substream, &jz4740_pcm_hardware);
+
+        runtime->private_data = prtd;
+
+        return 0;
+}
+
+static int jz4740_pcm_close(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct jz4740_runtime_data *prtd = runtime->private_data;
+
+        kfree(prtd);
+
+        return 0;
+}
+
+static int jz4740_pcm_mmap(struct snd_pcm_substream *substream,
+        struct vm_area_struct *vma)
+{
+        return remap_pfn_range(vma, vma->vm_start,
+                        substream->dma_buffer.addr >> PAGE_SHIFT,
+                        vma->vm_end - vma->vm_start, vma->vm_page_prot);
+}
+
+static struct snd_pcm_ops jz4740_pcm_ops = {
+        .open           = jz4740_pcm_open,
+        .close          = jz4740_pcm_close,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = jz4740_pcm_hw_params,
+        .hw_free        = jz4740_pcm_hw_free,
+        .prepare        = jz4740_pcm_prepare,
+        .trigger        = jz4740_pcm_trigger,
+        .pointer        = jz4740_pcm_pointer,
+        .mmap           = jz4740_pcm_mmap,
+};
+
+static int jz4740_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
+{
+        struct snd_pcm_substream *substream = pcm->streams[stream].substream;
+        struct snd_dma_buffer *buf = &substream->dma_buffer;
+        size_t size = jz4740_pcm_hardware.buffer_bytes_max;
+
+        buf->dev.type = SNDRV_DMA_TYPE_DEV;
+        buf->dev.dev = pcm->card->dev;
+        buf->private_data = NULL;
+
+        buf->area = dma_alloc_noncoherent(pcm->card->dev, size,
+                                          &buf->addr, GFP_KERNEL);
+        if (!buf->area)
+                return -ENOMEM;
+
+        buf->bytes = size;
+
+        return 0;
+}
+
+static void jz4740_pcm_free(struct snd_pcm *pcm)
+{
+        struct snd_pcm_substream *substream;
+        struct snd_dma_buffer *buf;
+        int stream;
+
+        for (stream = 0; stream < SNDRV_PCM_STREAM_LAST; ++stream) {
+                substream = pcm->streams[stream].substream;
+                if (!substream)
+                        continue;
+
+                buf = &substream->dma_buffer;
+                if (!buf->area)
+                        continue;
+
+                dma_free_noncoherent(pcm->card->dev, buf->bytes, buf->area,
+                                buf->addr);
+                buf->area = NULL;
+        }
+}
+
+static u64 jz4740_pcm_dmamask = DMA_BIT_MASK(32);
+
+int jz4740_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
+        struct snd_pcm *pcm)
+{
+        int ret = 0;
+
+        if (!card->dev->dma_mask)
+                card->dev->dma_mask = &jz4740_pcm_dmamask;
+
+        if (!card->dev->coherent_dma_mask)
+                card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
+
+        if (dai->playback.channels_min) {
+                ret = jz4740_pcm_preallocate_dma_buffer(pcm,
+                        SNDRV_PCM_STREAM_PLAYBACK);
+                if (ret)
+                        goto err;
+        }
+
+        if (dai->capture.channels_min) {
+                ret = jz4740_pcm_preallocate_dma_buffer(pcm,
+                        SNDRV_PCM_STREAM_CAPTURE);
+                if (ret)
+                        goto err;
+        }
+
+err:
+        return ret;
+}
+
+struct snd_soc_platform jz4740_soc_platform = {
+                .name           = "jz4740-pcm",
+                .pcm_ops        = &jz4740_pcm_ops,
+                .pcm_new        = jz4740_pcm_new,
+                .pcm_free       = jz4740_pcm_free,
+};
+EXPORT_SYMBOL_GPL(jz4740_soc_platform);
+
+static int __devinit jz4740_pcm_probe(struct platform_device *pdev)
+{
+        return snd_soc_register_platform(&jz4740_soc_platform);
+}
+
+static int __devexit jz4740_pcm_remove(struct platform_device *pdev)
+{
+        snd_soc_unregister_platform(&jz4740_soc_platform);
+        return 0;
+}
+
+static struct platform_driver jz4740_pcm_driver = {
+        .probe = jz4740_pcm_probe,
+        .remove = __devexit_p(jz4740_pcm_remove),
+        .driver = {
+                .name = "jz4740-pcm",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init jz4740_soc_platform_init(void)
+{
+        return platform_driver_register(&jz4740_pcm_driver);
+}
+module_init(jz4740_soc_platform_init);
+
+static void __exit jz4740_soc_platform_exit(void)
+{
+        return platform_driver_unregister(&jz4740_pcm_driver);
+}
+module_exit(jz4740_soc_platform_exit);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("Ingenic SoC JZ4740 PCM driver");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/jz4740/jz4740-pcm.h b/sound/soc/jz4740/jz4740-pcm.h
new file mode 100644
index 000000000000..e3f221e2779c
--- /dev/null
+++ b/sound/soc/jz4740/jz4740-pcm.h
@@ -0,0 +1,22 @@
+/*
+ *
+ * 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.
+ */
+
+#ifndef _JZ4740_PCM_H
+#define _JZ4740_PCM_H
+
+#include <linux/dma-mapping.h>
+#include <asm/mach-jz4740/dma.h>
+
+/* platform data */
+extern struct snd_soc_platform jz4740_soc_platform;
+
+struct jz4740_pcm_config {
+        struct jz4740_dma_config dma_config;
+        phys_addr_t fifo_addr;
+};
+
+#endif
diff --git a/sound/soc/jz4740/qi_lb60.c b/sound/soc/jz4740/qi_lb60.c
new file mode 100644
index 000000000000..f15f4918f15f
--- /dev/null
+++ b/sound/soc/jz4740/qi_lb60.c
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2009, Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * 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.
+ *
+ *  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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/timer.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <linux/gpio.h>
+
+#include "../codecs/jz4740.h"
+#include "jz4740-pcm.h"
+#include "jz4740-i2s.h"
+
+
+#define QI_LB60_SND_GPIO JZ_GPIO_PORTB(29)
+#define QI_LB60_AMP_GPIO JZ_GPIO_PORTD(4)
+
+static int qi_lb60_spk_event(struct snd_soc_dapm_widget *widget,
+                             struct snd_kcontrol *ctrl, int event)
+{
+        int on = 0;
+        if (event & SND_SOC_DAPM_POST_PMU)
+                on = 1;
+        else if (event & SND_SOC_DAPM_PRE_PMD)
+                on = 0;
+
+        gpio_set_value(QI_LB60_SND_GPIO, on);
+        gpio_set_value(QI_LB60_AMP_GPIO, on);
+
+        return 0;
+}
+
+static const struct snd_soc_dapm_widget qi_lb60_widgets[] = {
+        SND_SOC_DAPM_SPK("Speaker", qi_lb60_spk_event),
+        SND_SOC_DAPM_MIC("Mic", NULL),
+};
+
+static const struct snd_soc_dapm_route qi_lb60_routes[] = {
+        {"Mic", NULL, "MIC"},
+        {"Speaker", NULL, "LOUT"},
+        {"Speaker", NULL, "ROUT"},
+};
+
+#define QI_LB60_DAIFMT (SND_SOC_DAIFMT_I2S | \
+                        SND_SOC_DAIFMT_NB_NF | \
+                        SND_SOC_DAIFMT_CBM_CFM)
+
+static int qi_lb60_codec_init(struct snd_soc_codec *codec)
+{
+        int ret;
+        struct snd_soc_dai *cpu_dai = codec->socdev->card->dai_link->cpu_dai;
+
+        snd_soc_dapm_nc_pin(codec, "LIN");
+        snd_soc_dapm_nc_pin(codec, "RIN");
+
+        ret = snd_soc_dai_set_fmt(cpu_dai, QI_LB60_DAIFMT);
+        if (ret < 0) {
+                dev_err(codec->dev, "Failed to set cpu dai format: %d\n", ret);
+                return ret;
+        }
+
+        snd_soc_dapm_new_controls(codec, qi_lb60_widgets, ARRAY_SIZE(qi_lb60_widgets));
+        snd_soc_dapm_add_routes(codec, qi_lb60_routes, ARRAY_SIZE(qi_lb60_routes));
+        snd_soc_dapm_sync(codec);
+
+        return 0;
+}
+
+static struct snd_soc_dai_link qi_lb60_dai = {
+        .name = "jz4740",
+        .stream_name = "jz4740",
+        .cpu_dai = &jz4740_i2s_dai,
+        .codec_dai = &jz4740_codec_dai,
+        .init = qi_lb60_codec_init,
+};
+
+static struct snd_soc_card qi_lb60 = {
+        .name = "QI LB60",
+        .dai_link = &qi_lb60_dai,
+        .num_links = 1,
+        .platform = &jz4740_soc_platform,
+};
+
+static struct snd_soc_device qi_lb60_snd_devdata = {
+        .card = &qi_lb60,
+        .codec_dev = &soc_codec_dev_jz4740_codec,
+};
+
+static struct platform_device *qi_lb60_snd_device;
+
+static int __init qi_lb60_init(void)
+{
+        int ret;
+
+        qi_lb60_snd_device = platform_device_alloc("soc-audio", -1);
+
+        if (!qi_lb60_snd_device)
+                return -ENOMEM;
+
+        ret = gpio_request(QI_LB60_SND_GPIO, "SND");
+        if (ret) {
+                pr_err("qi_lb60 snd: Failed to request SND GPIO(%d): %d\n",
+                                QI_LB60_SND_GPIO, ret);
+                goto err_device_put;
+        }
+
+        ret = gpio_request(QI_LB60_AMP_GPIO, "AMP");
+        if (ret) {
+                pr_err("qi_lb60 snd: Failed to request AMP GPIO(%d): %d\n",
+                                QI_LB60_AMP_GPIO, ret);
+                goto err_gpio_free_snd;
+        }
+
+        gpio_direction_output(QI_LB60_SND_GPIO, 0);
+        gpio_direction_output(QI_LB60_AMP_GPIO, 0);
+
+        platform_set_drvdata(qi_lb60_snd_device, &qi_lb60_snd_devdata);
+        qi_lb60_snd_devdata.dev = &qi_lb60_snd_device->dev;
+
+        ret = platform_device_add(qi_lb60_snd_device);
+        if (ret) {
+                pr_err("qi_lb60 snd: Failed to add snd soc device: %d\n", ret);
+                goto err_unset_pdata;
+        }
+
+         return 0;
+
+err_unset_pdata:
+        platform_set_drvdata(qi_lb60_snd_device, NULL);
+/*err_gpio_free_amp:*/
+        gpio_free(QI_LB60_AMP_GPIO);
+err_gpio_free_snd:
+        gpio_free(QI_LB60_SND_GPIO);
+err_device_put:
+        platform_device_put(qi_lb60_snd_device);
+
+        return ret;
+}
+module_init(qi_lb60_init);
+
+static void __exit qi_lb60_exit(void)
+{
+        gpio_free(QI_LB60_AMP_GPIO);
+        gpio_free(QI_LB60_SND_GPIO);
+        platform_device_unregister(qi_lb60_snd_device);
+}
+module_exit(qi_lb60_exit);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("ALSA SoC QI LB60 Audio support");
+MODULE_LICENSE("GPL v2");
diff --git a/sound/soc/kirkwood/Kconfig b/sound/soc/kirkwood/Kconfig
new file mode 100644
index 000000000000..16ec2a2dba4d
--- /dev/null
+++ b/sound/soc/kirkwood/Kconfig
@@ -0,0 +1,20 @@
+config SND_KIRKWOOD_SOC
+        tristate "SoC Audio for the Marvell Kirkwood chip"
+        depends on ARCH_KIRKWOOD
+        help
+          Say Y or M if you want to add support for codecs attached to
+          the Kirkwood I2S interface. You will also need to select the
+          audio interfaces to support below.
+
+config SND_KIRKWOOD_SOC_I2S
+        tristate
+
+config SND_KIRKWOOD_SOC_OPENRD
+        tristate "SoC Audio support for Kirkwood Openrd Client"
+        depends on SND_KIRKWOOD_SOC && MACH_OPENRD_CLIENT
+        select SND_KIRKWOOD_SOC_I2S
+        select SND_SOC_CS42L51
+        help
+          Say Y if you want to add support for SoC audio on
+          Openrd Client.
+
diff --git a/sound/soc/kirkwood/Makefile b/sound/soc/kirkwood/Makefile
new file mode 100644
index 000000000000..33a16dcab5b5
--- /dev/null
+++ b/sound/soc/kirkwood/Makefile
@@ -0,0 +1,9 @@
+snd-soc-kirkwood-objs := kirkwood-dma.o
+snd-soc-kirkwood-i2s-objs := kirkwood-i2s.o
+
+obj-$(CONFIG_SND_KIRKWOOD_SOC) += snd-soc-kirkwood.o
+obj-$(CONFIG_SND_KIRKWOOD_SOC_I2S) += snd-soc-kirkwood-i2s.o
+
+snd-soc-openrd-objs := kirkwood-openrd.o
+
+obj-$(CONFIG_SND_KIRKWOOD_SOC_OPENRD) += snd-soc-openrd.o
diff --git a/sound/soc/kirkwood/kirkwood-dma.c b/sound/soc/kirkwood/kirkwood-dma.c
new file mode 100644
index 000000000000..a30205be3e2b
--- /dev/null
+++ b/sound/soc/kirkwood/kirkwood-dma.c
@@ -0,0 +1,383 @@
+/*
+ * kirkwood-dma.c
+ *
+ * (c) 2010 Arnaud Patard <apatard@mandriva.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/init.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
+#include <linux/mbus.h>
+#include <sound/soc.h>
+#include "kirkwood-dma.h"
+#include "kirkwood.h"
+
+#define KIRKWOOD_RATES \
+        (SNDRV_PCM_RATE_44100 | \
+         SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000)
+#define KIRKWOOD_FORMATS \
+        (SNDRV_PCM_FMTBIT_S16_LE | \
+         SNDRV_PCM_FMTBIT_S24_LE | \
+         SNDRV_PCM_FMTBIT_S32_LE)
+
+struct kirkwood_dma_priv {
+        struct snd_pcm_substream *play_stream;
+        struct snd_pcm_substream *rec_stream;
+        struct kirkwood_dma_data *data;
+};
+
+static struct snd_pcm_hardware kirkwood_dma_snd_hw = {
+        .info = (SNDRV_PCM_INFO_INTERLEAVED |
+                 SNDRV_PCM_INFO_MMAP |
+                 SNDRV_PCM_INFO_MMAP_VALID |
+                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                 SNDRV_PCM_INFO_PAUSE),
+        .formats                = KIRKWOOD_FORMATS,
+        .rates                  = KIRKWOOD_RATES,
+        .rate_min               = 44100,
+        .rate_max               = 96000,
+        .channels_min           = 1,
+        .channels_max           = 2,
+        .buffer_bytes_max       = KIRKWOOD_SND_MAX_PERIOD_BYTES * KIRKWOOD_SND_MAX_PERIODS,
+        .period_bytes_min       = KIRKWOOD_SND_MIN_PERIOD_BYTES,
+        .period_bytes_max       = KIRKWOOD_SND_MAX_PERIOD_BYTES,
+        .periods_min            = KIRKWOOD_SND_MIN_PERIODS,
+        .periods_max            = KIRKWOOD_SND_MAX_PERIODS,
+        .fifo_size              = 0,
+};
+
+static u64 kirkwood_dma_dmamask = 0xFFFFFFFFUL;
+
+static irqreturn_t kirkwood_dma_irq(int irq, void *dev_id)
+{
+        struct kirkwood_dma_priv *prdata = dev_id;
+        struct kirkwood_dma_data *priv = prdata->data;
+        unsigned long mask, status, cause;
+
+        mask = readl(priv->io + KIRKWOOD_INT_MASK);
+        status = readl(priv->io + KIRKWOOD_INT_CAUSE) & mask;
+
+        cause = readl(priv->io + KIRKWOOD_ERR_CAUSE);
+        if (unlikely(cause)) {
+                printk(KERN_WARNING "%s: got err interrupt 0x%lx\n",
+                                __func__, cause);
+                writel(cause, priv->io + KIRKWOOD_ERR_CAUSE);
+                return IRQ_HANDLED;
+        }
+
+        /* we've enabled only bytes interrupts ... */
+        if (status & ~(KIRKWOOD_INT_CAUSE_PLAY_BYTES | \
+                        KIRKWOOD_INT_CAUSE_REC_BYTES)) {
+                printk(KERN_WARNING "%s: unexpected interrupt %lx\n",
+                        __func__, status);
+                return IRQ_NONE;
+        }
+
+        /* ack int */
+        writel(status, priv->io + KIRKWOOD_INT_CAUSE);
+
+        if (status & KIRKWOOD_INT_CAUSE_PLAY_BYTES)
+                snd_pcm_period_elapsed(prdata->play_stream);
+
+        if (status & KIRKWOOD_INT_CAUSE_REC_BYTES)
+                snd_pcm_period_elapsed(prdata->rec_stream);
+
+        return IRQ_HANDLED;
+}
+
+static void kirkwood_dma_conf_mbus_windows(void __iomem *base, int win,
+                                        unsigned long dma,
+                                        struct mbus_dram_target_info *dram)
+{
+        int i;
+
+        /* First disable and clear windows */
+        writel(0, base + KIRKWOOD_AUDIO_WIN_CTRL_REG(win));
+        writel(0, base + KIRKWOOD_AUDIO_WIN_BASE_REG(win));
+
+        /* try to find matching cs for current dma address */
+        for (i = 0; i < dram->num_cs; i++) {
+                struct mbus_dram_window *cs = dram->cs + i;
+                if ((cs->base & 0xffff0000) < (dma & 0xffff0000)) {
+                        writel(cs->base & 0xffff0000,
+                                base + KIRKWOOD_AUDIO_WIN_BASE_REG(win));
+                        writel(((cs->size - 1) & 0xffff0000) |
+                                (cs->mbus_attr << 8) |
+                                (dram->mbus_dram_target_id << 4) | 1,
+                                base + KIRKWOOD_AUDIO_WIN_CTRL_REG(win));
+                }
+        }
+}
+
+static int kirkwood_dma_open(struct snd_pcm_substream *substream)
+{
+        int err;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        struct snd_soc_dai *cpu_dai = soc_runtime->dai->cpu_dai;
+        struct kirkwood_dma_data *priv;
+        struct kirkwood_dma_priv *prdata = cpu_dai->private_data;
+        unsigned long addr;
+
+        priv = snd_soc_dai_get_dma_data(cpu_dai, substream);
+        snd_soc_set_runtime_hwparams(substream, &kirkwood_dma_snd_hw);
+
+        /* Ensure that all constraints linked to dma burst are fullfilled */
+        err = snd_pcm_hw_constraint_minmax(runtime,
+                        SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
+                        priv->burst * 2,
+                        KIRKWOOD_AUDIO_BUF_MAX-1);
+        if (err < 0)
+                return err;
+
+        err = snd_pcm_hw_constraint_step(runtime, 0,
+                        SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
+                        priv->burst);
+        if (err < 0)
+                return err;
+
+        err = snd_pcm_hw_constraint_step(substream->runtime, 0,
+                         SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
+                         priv->burst);
+        if (err < 0)
+                return err;
+
+        if (soc_runtime->dai->cpu_dai->private_data == NULL) {
+                prdata = kzalloc(sizeof(struct kirkwood_dma_priv), GFP_KERNEL);
+                if (prdata == NULL)
+                        return -ENOMEM;
+
+                prdata->data = priv;
+
+                err = request_irq(priv->irq, kirkwood_dma_irq, IRQF_SHARED,
+                                  "kirkwood-i2s", prdata);
+                if (err) {
+                        kfree(prdata);
+                        return -EBUSY;
+                }
+
+                soc_runtime->dai->cpu_dai->private_data = prdata;
+
+                /*
+                 * Enable Error interrupts. We're only ack'ing them but
+                 * it's usefull for diagnostics
+                 */
+                writel((unsigned long)-1, priv->io + KIRKWOOD_ERR_MASK);
+        }
+
+        addr = virt_to_phys(substream->dma_buffer.area);
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                prdata->play_stream = substream;
+                kirkwood_dma_conf_mbus_windows(priv->io,
+                        KIRKWOOD_PLAYBACK_WIN, addr, priv->dram);
+        } else {
+                prdata->rec_stream = substream;
+                kirkwood_dma_conf_mbus_windows(priv->io,
+                        KIRKWOOD_RECORD_WIN, addr, priv->dram);
+        }
+
+        return 0;
+}
+
+static int kirkwood_dma_close(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        struct snd_soc_dai *cpu_dai = soc_runtime->dai->cpu_dai;
+        struct kirkwood_dma_priv *prdata = cpu_dai->private_data;
+        struct kirkwood_dma_data *priv;
+
+        priv = snd_soc_dai_get_dma_data(cpu_dai, substream);
+
+        if (!prdata || !priv)
+                return 0;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                prdata->play_stream = NULL;
+        else
+                prdata->rec_stream = NULL;
+
+        if (!prdata->play_stream && !prdata->rec_stream) {
+                writel(0, priv->io + KIRKWOOD_ERR_MASK);
+                free_irq(priv->irq, prdata);
+                kfree(prdata);
+                soc_runtime->dai->cpu_dai->private_data = NULL;
+        }
+
+        return 0;
+}
+
+static int kirkwood_dma_hw_params(struct snd_pcm_substream *substream,
+                                struct snd_pcm_hw_params *params)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+
+        snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
+        runtime->dma_bytes = params_buffer_bytes(params);
+
+        return 0;
+}
+
+static int kirkwood_dma_hw_free(struct snd_pcm_substream *substream)
+{
+        snd_pcm_set_runtime_buffer(substream, NULL);
+        return 0;
+}
+
+static int kirkwood_dma_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        struct snd_soc_dai *cpu_dai = soc_runtime->dai->cpu_dai;
+        struct kirkwood_dma_data *priv;
+        unsigned long size, count;
+
+        priv = snd_soc_dai_get_dma_data(cpu_dai, substream);
+
+        /* compute buffer size in term of "words" as requested in specs */
+        size = frames_to_bytes(runtime, runtime->buffer_size);
+        size = (size>>2)-1;
+        count = snd_pcm_lib_period_bytes(substream);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                writel(count, priv->io + KIRKWOOD_PLAY_BYTE_INT_COUNT);
+                writel(runtime->dma_addr, priv->io + KIRKWOOD_PLAY_BUF_ADDR);
+                writel(size, priv->io + KIRKWOOD_PLAY_BUF_SIZE);
+        } else {
+                writel(count, priv->io + KIRKWOOD_REC_BYTE_INT_COUNT);
+                writel(runtime->dma_addr, priv->io + KIRKWOOD_REC_BUF_ADDR);
+                writel(size, priv->io + KIRKWOOD_REC_BUF_SIZE);
+        }
+
+
+        return 0;
+}
+
+static snd_pcm_uframes_t kirkwood_dma_pointer(struct snd_pcm_substream
+                                                *substream)
+{
+        struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
+        struct snd_soc_dai *cpu_dai = soc_runtime->dai->cpu_dai;
+        struct kirkwood_dma_data *priv;
+        snd_pcm_uframes_t count;
+
+        priv = snd_soc_dai_get_dma_data(cpu_dai, substream);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                count = bytes_to_frames(substream->runtime,
+                        readl(priv->io + KIRKWOOD_PLAY_BYTE_COUNT));
+        else
+                count = bytes_to_frames(substream->runtime,
+                        readl(priv->io + KIRKWOOD_REC_BYTE_COUNT));
+
+        return count;
+}
+
+struct snd_pcm_ops kirkwood_dma_ops = {
+        .open =         kirkwood_dma_open,
+        .close =        kirkwood_dma_close,
+        .ioctl =        snd_pcm_lib_ioctl,
+        .hw_params =    kirkwood_dma_hw_params,
+        .hw_free =      kirkwood_dma_hw_free,
+        .prepare =      kirkwood_dma_prepare,
+        .pointer =      kirkwood_dma_pointer,
+};
+
+static int kirkwood_dma_preallocate_dma_buffer(struct snd_pcm *pcm,
+                int stream)
+{
+        struct snd_pcm_substream *substream = pcm->streams[stream].substream;
+        struct snd_dma_buffer *buf = &substream->dma_buffer;
+        size_t size = kirkwood_dma_snd_hw.buffer_bytes_max;
+
+        buf->dev.type = SNDRV_DMA_TYPE_DEV;
+        buf->dev.dev = pcm->card->dev;
+        buf->area = dma_alloc_coherent(pcm->card->dev, size,
+                        &buf->addr, GFP_KERNEL);
+        if (!buf->area)
+                return -ENOMEM;
+        buf->bytes = size;
+        buf->private_data = NULL;
+
+        return 0;
+}
+
+static int kirkwood_dma_new(struct snd_card *card,
+                struct snd_soc_dai *dai, struct snd_pcm *pcm)
+{
+        int ret;
+
+        if (!card->dev->dma_mask)
+                card->dev->dma_mask = &kirkwood_dma_dmamask;
+        if (!card->dev->coherent_dma_mask)
+                card->dev->coherent_dma_mask = 0xffffffff;
+
+        if (dai->playback.channels_min) {
+                ret = kirkwood_dma_preallocate_dma_buffer(pcm,
+                                SNDRV_PCM_STREAM_PLAYBACK);
+                if (ret)
+                        return ret;
+        }
+
+        if (dai->capture.channels_min) {
+                ret = kirkwood_dma_preallocate_dma_buffer(pcm,
+                                SNDRV_PCM_STREAM_CAPTURE);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static void kirkwood_dma_free_dma_buffers(struct snd_pcm *pcm)
+{
+        struct snd_pcm_substream *substream;
+        struct snd_dma_buffer *buf;
+        int stream;
+
+        for (stream = 0; stream < 2; stream++) {
+                substream = pcm->streams[stream].substream;
+                if (!substream)
+                        continue;
+                buf = &substream->dma_buffer;
+                if (!buf->area)
+                        continue;
+
+                dma_free_coherent(pcm->card->dev, buf->bytes,
+                                buf->area, buf->addr);
+                buf->area = NULL;
+        }
+}
+
+struct snd_soc_platform kirkwood_soc_platform = {
+        .name           = "kirkwood-dma",
+        .pcm_ops        = &kirkwood_dma_ops,
+        .pcm_new        = kirkwood_dma_new,
+        .pcm_free       = kirkwood_dma_free_dma_buffers,
+};
+EXPORT_SYMBOL_GPL(kirkwood_soc_platform);
+
+static int __init kirkwood_soc_platform_init(void)
+{
+        return snd_soc_register_platform(&kirkwood_soc_platform);
+}
+module_init(kirkwood_soc_platform_init);
+
+static void __exit kirkwood_soc_platform_exit(void)
+{
+        snd_soc_unregister_platform(&kirkwood_soc_platform);
+}
+module_exit(kirkwood_soc_platform_exit);
+
+MODULE_AUTHOR("Arnaud Patard <apatard@mandriva.com>");
+MODULE_DESCRIPTION("Marvell Kirkwood Audio DMA module");
+MODULE_LICENSE("GPL");
+
diff --git a/sound/soc/kirkwood/kirkwood-dma.h b/sound/soc/kirkwood/kirkwood-dma.h
new file mode 100644
index 000000000000..ba4454cd34f1
--- /dev/null
+++ b/sound/soc/kirkwood/kirkwood-dma.h
@@ -0,0 +1,17 @@
+/*
+ * kirkwood-dma.h
+ *
+ * (c) 2010 Arnaud Patard <apatard@mandriva.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.
+ */
+
+#ifndef _KIRKWOOD_DMA_H
+#define _KIRKWOOD_DMA_H
+
+extern struct snd_soc_platform kirkwood_soc_platform;
+
+#endif
diff --git a/sound/soc/kirkwood/kirkwood-i2s.c b/sound/soc/kirkwood/kirkwood-i2s.c
new file mode 100644
index 000000000000..981ffc2a13c8
--- /dev/null
+++ b/sound/soc/kirkwood/kirkwood-i2s.c
@@ -0,0 +1,495 @@
+/*
+ * kirkwood-i2s.c
+ *
+ * (c) 2010 Arnaud Patard <apatard@mandriva.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/init.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include <linux/mbus.h>
+#include <linux/delay.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+#include <plat/audio.h>
+#include "kirkwood-i2s.h"
+#include "kirkwood.h"
+
+#define DRV_NAME        "kirkwood-i2s"
+
+#define KIRKWOOD_I2S_RATES \
+        (SNDRV_PCM_RATE_44100 | \
+         SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000)
+#define KIRKWOOD_I2S_FORMATS \
+        (SNDRV_PCM_FMTBIT_S16_LE | \
+         SNDRV_PCM_FMTBIT_S24_LE | \
+         SNDRV_PCM_FMTBIT_S32_LE)
+
+
+struct snd_soc_dai kirkwood_i2s_dai;
+static struct kirkwood_dma_data *priv;
+
+static int kirkwood_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
+                unsigned int fmt)
+{
+        unsigned long mask;
+        unsigned long value;
+
+        switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+        case SND_SOC_DAIFMT_RIGHT_J:
+                mask = KIRKWOOD_I2S_CTL_RJ;
+                break;
+        case SND_SOC_DAIFMT_LEFT_J:
+                mask = KIRKWOOD_I2S_CTL_LJ;
+                break;
+        case SND_SOC_DAIFMT_I2S:
+                mask = KIRKWOOD_I2S_CTL_I2S;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        /*
+         * Set same format for playback and record
+         * This avoids some troubles.
+         */
+        value = readl(priv->io+KIRKWOOD_I2S_PLAYCTL);
+        value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
+        value |= mask;
+        writel(value, priv->io+KIRKWOOD_I2S_PLAYCTL);
+
+        value = readl(priv->io+KIRKWOOD_I2S_RECCTL);
+        value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
+        value |= mask;
+        writel(value, priv->io+KIRKWOOD_I2S_RECCTL);
+
+        return 0;
+}
+
+static inline void kirkwood_set_dco(void __iomem *io, unsigned long rate)
+{
+        unsigned long value;
+
+        value = KIRKWOOD_DCO_CTL_OFFSET_0;
+        switch (rate) {
+        default:
+        case 44100:
+                value |= KIRKWOOD_DCO_CTL_FREQ_11;
+                break;
+        case 48000:
+                value |= KIRKWOOD_DCO_CTL_FREQ_12;
+                break;
+        case 96000:
+                value |= KIRKWOOD_DCO_CTL_FREQ_24;
+                break;
+        }
+        writel(value, io + KIRKWOOD_DCO_CTL);
+
+        /* wait for dco locked */
+        do {
+                cpu_relax();
+                value = readl(io + KIRKWOOD_DCO_SPCR_STATUS);
+                value &= KIRKWOOD_DCO_SPCR_STATUS;
+        } while (value == 0);
+}
+
+static int kirkwood_i2s_hw_params(struct snd_pcm_substream *substream,
+                                 struct snd_pcm_hw_params *params,
+                                 struct snd_soc_dai *dai)
+{
+        unsigned int i2s_reg, reg;
+        unsigned long i2s_value, value;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                i2s_reg = KIRKWOOD_I2S_PLAYCTL;
+                reg = KIRKWOOD_PLAYCTL;
+        } else {
+                i2s_reg = KIRKWOOD_I2S_RECCTL;
+                reg = KIRKWOOD_RECCTL;
+        }
+
+        /* set dco conf */
+        kirkwood_set_dco(priv->io, params_rate(params));
+
+        i2s_value = readl(priv->io+i2s_reg);
+        i2s_value &= ~KIRKWOOD_I2S_CTL_SIZE_MASK;
+
+        value = readl(priv->io+reg);
+        value &= ~KIRKWOOD_PLAYCTL_SIZE_MASK;
+
+        /*
+         * Size settings in play/rec i2s control regs and play/rec control
+         * regs must be the same.
+         */
+        switch (params_format(params)) {
+        case SNDRV_PCM_FORMAT_S16_LE:
+                i2s_value |= KIRKWOOD_I2S_CTL_SIZE_16;
+                value |= KIRKWOOD_PLAYCTL_SIZE_16_C;
+                break;
+        /*
+         * doesn't work... S20_3LE != kirkwood 20bit format ?
+         *
+        case SNDRV_PCM_FORMAT_S20_3LE:
+                i2s_value |= KIRKWOOD_I2S_CTL_SIZE_20;
+                value |= KIRKWOOD_PLAYCTL_SIZE_20;
+                break;
+        */
+        case SNDRV_PCM_FORMAT_S24_LE:
+                i2s_value |= KIRKWOOD_I2S_CTL_SIZE_24;
+                value |= KIRKWOOD_PLAYCTL_SIZE_24;
+                break;
+        case SNDRV_PCM_FORMAT_S32_LE:
+                i2s_value |= KIRKWOOD_I2S_CTL_SIZE_32;
+                value |= KIRKWOOD_PLAYCTL_SIZE_32;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                value &= ~KIRKWOOD_PLAYCTL_MONO_MASK;
+                if (params_channels(params) == 1)
+                        value |= KIRKWOOD_PLAYCTL_MONO_BOTH;
+                else
+                        value |= KIRKWOOD_PLAYCTL_MONO_OFF;
+        }
+
+        writel(i2s_value, priv->io+i2s_reg);
+        writel(value, priv->io+reg);
+
+        return 0;
+}
+
+static int kirkwood_i2s_play_trigger(struct snd_pcm_substream *substream,
+                                int cmd, struct snd_soc_dai *dai)
+{
+        unsigned long value;
+
+        /*
+         * specs says KIRKWOOD_PLAYCTL must be read 2 times before
+         * changing it. So read 1 time here and 1 later.
+         */
+        value = readl(priv->io + KIRKWOOD_PLAYCTL);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                /* stop audio, enable interrupts */
+                value = readl(priv->io + KIRKWOOD_PLAYCTL);
+                value |= KIRKWOOD_PLAYCTL_PAUSE;
+                writel(value, priv->io + KIRKWOOD_PLAYCTL);
+
+                value = readl(priv->io + KIRKWOOD_INT_MASK);
+                value |= KIRKWOOD_INT_CAUSE_PLAY_BYTES;
+                writel(value, priv->io + KIRKWOOD_INT_MASK);
+
+                /* configure audio & enable i2s playback */
+                value = readl(priv->io + KIRKWOOD_PLAYCTL);
+                value &= ~KIRKWOOD_PLAYCTL_BURST_MASK;
+                value &= ~(KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE
+                                | KIRKWOOD_PLAYCTL_SPDIF_EN);
+
+                if (priv->burst == 32)
+                        value |= KIRKWOOD_PLAYCTL_BURST_32;
+                else
+                        value |= KIRKWOOD_PLAYCTL_BURST_128;
+                value |= KIRKWOOD_PLAYCTL_I2S_EN;
+                writel(value, priv->io + KIRKWOOD_PLAYCTL);
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+                /* stop audio, disable interrupts */
+                value = readl(priv->io + KIRKWOOD_PLAYCTL);
+                value |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE;
+                writel(value, priv->io + KIRKWOOD_PLAYCTL);
+
+                value = readl(priv->io + KIRKWOOD_INT_MASK);
+                value &= ~KIRKWOOD_INT_CAUSE_PLAY_BYTES;
+                writel(value, priv->io + KIRKWOOD_INT_MASK);
+
+                /* disable all playbacks */
+                value = readl(priv->io + KIRKWOOD_PLAYCTL);
+                value &= ~(KIRKWOOD_PLAYCTL_I2S_EN | KIRKWOOD_PLAYCTL_SPDIF_EN);
+                writel(value, priv->io + KIRKWOOD_PLAYCTL);
+                break;
+
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                value = readl(priv->io + KIRKWOOD_PLAYCTL);
+                value |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE;
+                writel(value, priv->io + KIRKWOOD_PLAYCTL);
+                break;
+
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                value = readl(priv->io + KIRKWOOD_PLAYCTL);
+                value &= ~(KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE);
+                writel(value, priv->io + KIRKWOOD_PLAYCTL);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int kirkwood_i2s_rec_trigger(struct snd_pcm_substream *substream,
+                                int cmd, struct snd_soc_dai *dai)
+{
+        unsigned long value;
+
+        value = readl(priv->io + KIRKWOOD_RECCTL);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                /* stop audio, enable interrupts */
+                value = readl(priv->io + KIRKWOOD_RECCTL);
+                value |= KIRKWOOD_RECCTL_PAUSE;
+                writel(value, priv->io + KIRKWOOD_RECCTL);
+
+                value = readl(priv->io + KIRKWOOD_INT_MASK);
+                value |= KIRKWOOD_INT_CAUSE_REC_BYTES;
+                writel(value, priv->io + KIRKWOOD_INT_MASK);
+
+                /* configure audio & enable i2s record */
+                value = readl(priv->io + KIRKWOOD_RECCTL);
+                value &= ~KIRKWOOD_RECCTL_BURST_MASK;
+                value &= ~KIRKWOOD_RECCTL_MONO;
+                value &= ~(KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE
+                        | KIRKWOOD_RECCTL_SPDIF_EN);
+
+                if (priv->burst == 32)
+                        value |= KIRKWOOD_RECCTL_BURST_32;
+                else
+                        value |= KIRKWOOD_RECCTL_BURST_128;
+                value |= KIRKWOOD_RECCTL_I2S_EN;
+
+                writel(value, priv->io + KIRKWOOD_RECCTL);
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+                /* stop audio, disable interrupts */
+                value = readl(priv->io + KIRKWOOD_RECCTL);
+                value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
+                writel(value, priv->io + KIRKWOOD_RECCTL);
+
+                value = readl(priv->io + KIRKWOOD_INT_MASK);
+                value &= ~KIRKWOOD_INT_CAUSE_REC_BYTES;
+                writel(value, priv->io + KIRKWOOD_INT_MASK);
+
+                /* disable all records */
+                value = readl(priv->io + KIRKWOOD_RECCTL);
+                value &= ~(KIRKWOOD_RECCTL_I2S_EN | KIRKWOOD_RECCTL_SPDIF_EN);
+                writel(value, priv->io + KIRKWOOD_RECCTL);
+                break;
+
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                value = readl(priv->io + KIRKWOOD_RECCTL);
+                value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
+                writel(value, priv->io + KIRKWOOD_RECCTL);
+                break;
+
+        case SNDRV_PCM_TRIGGER_RESUME:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                value = readl(priv->io + KIRKWOOD_RECCTL);
+                value &= ~(KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE);
+                writel(value, priv->io + KIRKWOOD_RECCTL);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int kirkwood_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
+                               struct snd_soc_dai *dai)
+{
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                return kirkwood_i2s_play_trigger(substream, cmd, dai);
+        else
+                return kirkwood_i2s_rec_trigger(substream, cmd, dai);
+
+        return 0;
+}
+
+static int kirkwood_i2s_probe(struct platform_device *pdev,
+                             struct snd_soc_dai *dai)
+{
+        unsigned long value;
+        unsigned int reg_data;
+
+        /* put system in a "safe" state : */
+        /* disable audio interrupts */
+        writel(0xffffffff, priv->io + KIRKWOOD_INT_CAUSE);
+        writel(0, priv->io + KIRKWOOD_INT_MASK);
+
+        reg_data = readl(priv->io + 0x1200);
+        reg_data &= (~(0x333FF8));
+        reg_data |= 0x111D18;
+        writel(reg_data, priv->io + 0x1200);
+
+        msleep(500);
+
+        reg_data = readl(priv->io + 0x1200);
+        reg_data &= (~(0x333FF8));
+        reg_data |= 0x111D18;
+        writel(reg_data, priv->io + 0x1200);
+
+        /* disable playback/record */
+        value = readl(priv->io + KIRKWOOD_PLAYCTL);
+        value &= ~(KIRKWOOD_PLAYCTL_I2S_EN|KIRKWOOD_PLAYCTL_SPDIF_EN);
+        writel(value, priv->io + KIRKWOOD_PLAYCTL);
+
+        value = readl(priv->io + KIRKWOOD_RECCTL);
+        value &= ~(KIRKWOOD_RECCTL_I2S_EN | KIRKWOOD_RECCTL_SPDIF_EN);
+        writel(value, priv->io + KIRKWOOD_RECCTL);
+
+        return 0;
+
+}
+
+static void kirkwood_i2s_remove(struct platform_device *pdev,
+                                struct snd_soc_dai *dai)
+{
+}
+
+static struct snd_soc_dai_ops kirkwood_i2s_dai_ops = {
+        .trigger        = kirkwood_i2s_trigger,
+        .hw_params      = kirkwood_i2s_hw_params,
+        .set_fmt        = kirkwood_i2s_set_fmt,
+};
+
+
+struct snd_soc_dai kirkwood_i2s_dai = {
+        .name = DRV_NAME,
+        .id = 0,
+        .probe = kirkwood_i2s_probe,
+        .remove = kirkwood_i2s_remove,
+        .playback = {
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = KIRKWOOD_I2S_RATES,
+                .formats = KIRKWOOD_I2S_FORMATS,},
+        .capture = {
+                .channels_min = 1,
+                .channels_max = 2,
+                .rates = KIRKWOOD_I2S_RATES,
+                .formats = KIRKWOOD_I2S_FORMATS,},
+        .ops = &kirkwood_i2s_dai_ops,
+};
+EXPORT_SYMBOL_GPL(kirkwood_i2s_dai);
+
+static __devinit int kirkwood_i2s_dev_probe(struct platform_device *pdev)
+{
+        struct resource *mem;
+        struct kirkwood_asoc_platform_data *data =
+                pdev->dev.platform_data;
+        int err;
+
+        priv = kzalloc(sizeof(struct kirkwood_dma_data), GFP_KERNEL);
+        if (!priv) {
+                dev_err(&pdev->dev, "allocation failed\n");
+                err = -ENOMEM;
+                goto error;
+        }
+
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem) {
+                dev_err(&pdev->dev, "platform_get_resource failed\n");
+                err = -ENXIO;
+                goto err_alloc;
+        }
+
+        priv->mem = request_mem_region(mem->start, SZ_16K, DRV_NAME);
+        if (!priv->mem) {
+                dev_err(&pdev->dev, "request_mem_region failed\n");
+                err = -EBUSY;
+                goto error;
+        }
+
+        priv->io = ioremap(priv->mem->start, SZ_16K);
+        if (!priv->io) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                err = -ENOMEM;
+                goto err_iomem;
+        }
+
+        priv->irq = platform_get_irq(pdev, 0);
+        if (priv->irq <= 0) {
+                dev_err(&pdev->dev, "platform_get_irq failed\n");
+                err = -ENXIO;
+                goto err_ioremap;
+        }
+
+        if (!data || !data->dram) {
+                dev_err(&pdev->dev, "no platform data ?!\n");
+                err = -EINVAL;
+                goto err_ioremap;
+        }
+
+        priv->dram = data->dram;
+        priv->burst = data->burst;
+
+        kirkwood_i2s_dai.capture.dma_data = priv;
+        kirkwood_i2s_dai.playback.dma_data = priv;
+
+        return snd_soc_register_dai(&kirkwood_i2s_dai);
+
+err_ioremap:
+        iounmap(priv->io);
+err_iomem:
+        release_mem_region(priv->mem->start, SZ_16K);
+err_alloc:
+        kfree(priv);
+error:
+        return err;
+}
+
+static __devexit int kirkwood_i2s_dev_remove(struct platform_device *pdev)
+{
+        if (priv) {
+                iounmap(priv->io);
+                release_mem_region(priv->mem->start, SZ_16K);
+                kfree(priv);
+        }
+        snd_soc_unregister_dai(&kirkwood_i2s_dai);
+        return 0;
+}
+
+static struct platform_driver kirkwood_i2s_driver = {
+        .probe  = kirkwood_i2s_dev_probe,
+        .remove = kirkwood_i2s_dev_remove,
+        .driver = {
+                .name = DRV_NAME,
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init kirkwood_i2s_init(void)
+{
+        return platform_driver_register(&kirkwood_i2s_driver);
+}
+module_init(kirkwood_i2s_init);
+
+static void __exit kirkwood_i2s_exit(void)
+{
+        platform_driver_unregister(&kirkwood_i2s_driver);
+}
+module_exit(kirkwood_i2s_exit);
+
+/* Module information */
+MODULE_AUTHOR("Arnaud Patard, <apatard@mandriva.com>");
+MODULE_DESCRIPTION("Kirkwood I2S SoC Interface");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:kirkwood-i2s");
diff --git a/sound/soc/kirkwood/kirkwood-i2s.h b/sound/soc/kirkwood/kirkwood-i2s.h
new file mode 100644
index 000000000000..c5595c616d7a
--- /dev/null
+++ b/sound/soc/kirkwood/kirkwood-i2s.h
@@ -0,0 +1,17 @@
+/*
+ * kirkwood-i2s.h
+ *
+ * (c) 2010 Arnaud Patard <apatard@mandriva.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.
+ */
+
+#ifndef _KIRKWOOD_I2S_H
+#define _KIRKWOOD_I2S_H
+
+extern struct snd_soc_dai kirkwood_i2s_dai;
+
+#endif
diff --git a/sound/soc/kirkwood/kirkwood-openrd.c b/sound/soc/kirkwood/kirkwood-openrd.c
new file mode 100644
index 000000000000..0353d06bc41a
--- /dev/null
+++ b/sound/soc/kirkwood/kirkwood-openrd.c
@@ -0,0 +1,126 @@
+/*
+ * kirkwood-openrd.c
+ *
+ * (c) 2010 Arnaud Patard <apatard@mandriva.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 <linux/moduleparam.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <sound/soc.h>
+#include <mach/kirkwood.h>
+#include <plat/audio.h>
+#include <asm/mach-types.h>
+#include "kirkwood-i2s.h"
+#include "kirkwood-dma.h"
+#include "../codecs/cs42l51.h"
+
+static int openrd_client_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->dai->codec_dai;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        int ret;
+        unsigned int freq, fmt;
+
+        fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS;
+        ret = snd_soc_dai_set_fmt(cpu_dai, fmt);
+        if (ret < 0)
+                return ret;
+
+        ret = snd_soc_dai_set_fmt(codec_dai, fmt);
+        if (ret < 0)
+                return ret;
+
+        switch (params_rate(params)) {
+        default:
+        case 44100:
+                freq = 11289600;
+                break;
+        case 48000:
+                freq = 12288000;
+                break;
+        case 96000:
+                freq = 24576000;
+                break;
+        }
+
+        return snd_soc_dai_set_sysclk(codec_dai, 0, freq, SND_SOC_CLOCK_IN);
+
+}
+
+static struct snd_soc_ops openrd_client_ops = {
+        .hw_params = openrd_client_hw_params,
+};
+
+
+static struct snd_soc_dai_link openrd_client_dai[] = {
+{
+        .name = "CS42L51",
+        .stream_name = "CS42L51 HiFi",
+        .cpu_dai = &kirkwood_i2s_dai,
+        .codec_dai = &cs42l51_dai,
+        .ops = &openrd_client_ops,
+},
+};
+
+
+static struct snd_soc_card openrd_client = {
+        .name = "OpenRD Client",
+        .platform = &kirkwood_soc_platform,
+        .dai_link = openrd_client_dai,
+        .num_links = ARRAY_SIZE(openrd_client_dai),
+};
+
+static struct snd_soc_device openrd_client_snd_devdata = {
+        .card = &openrd_client,
+        .codec_dev = &soc_codec_device_cs42l51,
+};
+
+static struct platform_device *openrd_client_snd_device;
+
+static int __init openrd_client_init(void)
+{
+        int ret;
+
+        if (!machine_is_openrd_client())
+                return 0;
+
+        openrd_client_snd_device = platform_device_alloc("soc-audio", -1);
+        if (!openrd_client_snd_device)
+                return -ENOMEM;
+
+        platform_set_drvdata(openrd_client_snd_device,
+                        &openrd_client_snd_devdata);
+        openrd_client_snd_devdata.dev = &openrd_client_snd_device->dev;
+
+        ret = platform_device_add(openrd_client_snd_device);
+        if (ret) {
+                printk(KERN_ERR "%s: platform_device_add failed\n", __func__);
+                platform_device_put(openrd_client_snd_device);
+        }
+
+        return ret;
+}
+
+static void __exit openrd_client_exit(void)
+{
+        platform_device_unregister(openrd_client_snd_device);
+}
+
+module_init(openrd_client_init);
+module_exit(openrd_client_exit);
+
+/* Module information */
+MODULE_AUTHOR("Arnaud Patard <apatard@mandriva.com>");
+MODULE_DESCRIPTION("ALSA SoC OpenRD Client");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:soc-audio");
diff --git a/sound/soc/kirkwood/kirkwood.h b/sound/soc/kirkwood/kirkwood.h
new file mode 100644
index 000000000000..bb6e6a5648c9
--- /dev/null
+++ b/sound/soc/kirkwood/kirkwood.h
@@ -0,0 +1,129 @@
+/*
+ * kirkwood.h
+ *
+ * (c) 2010 Arnaud Patard <apatard@mandriva.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.
+ */
+
+#ifndef _KIRKWOOD_AUDIO_H
+#define _KIRKWOOD_AUDIO_H
+
+#define KIRKWOOD_RECORD_WIN                     0
+#define KIRKWOOD_PLAYBACK_WIN                   1
+#define KIRKWOOD_MAX_AUDIO_WIN                  2
+
+#define KIRKWOOD_AUDIO_WIN_BASE_REG(win)        (0xA00 + ((win)<<3))
+#define KIRKWOOD_AUDIO_WIN_CTRL_REG(win)        (0xA04 + ((win)<<3))
+
+
+#define KIRKWOOD_RECCTL                 0x1000
+#define KIRKWOOD_RECCTL_SPDIF_EN                (1<<11)
+#define KIRKWOOD_RECCTL_I2S_EN                  (1<<10)
+#define KIRKWOOD_RECCTL_PAUSE                   (1<<9)
+#define KIRKWOOD_RECCTL_MUTE                    (1<<8)
+#define KIRKWOOD_RECCTL_BURST_MASK              (3<<5)
+#define KIRKWOOD_RECCTL_BURST_128               (2<<5)
+#define KIRKWOOD_RECCTL_BURST_32                (1<<5)
+#define KIRKWOOD_RECCTL_MONO                    (1<<4)
+#define KIRKWOOD_RECCTL_MONO_CHAN_RIGHT (1<<3)
+#define KIRKWOOD_RECCTL_MONO_CHAN_LEFT          (0<<3)
+#define KIRKWOOD_RECCTL_SIZE_MASK               (7<<0)
+#define KIRKWOOD_RECCTL_SIZE_16         (7<<0)
+#define KIRKWOOD_RECCTL_SIZE_16_C               (3<<0)
+#define KIRKWOOD_RECCTL_SIZE_20         (2<<0)
+#define KIRKWOOD_RECCTL_SIZE_24         (1<<0)
+#define KIRKWOOD_RECCTL_SIZE_32         (0<<0)
+
+#define KIRKWOOD_REC_BUF_ADDR                   0x1004
+#define KIRKWOOD_REC_BUF_SIZE                   0x1008
+#define KIRKWOOD_REC_BYTE_COUNT                 0x100C
+
+#define KIRKWOOD_PLAYCTL                        0x1100
+#define KIRKWOOD_PLAYCTL_PLAY_BUSY              (1<<16)
+#define KIRKWOOD_PLAYCTL_BURST_MASK             (3<<11)
+#define KIRKWOOD_PLAYCTL_BURST_128              (2<<11)
+#define KIRKWOOD_PLAYCTL_BURST_32               (1<<11)
+#define KIRKWOOD_PLAYCTL_PAUSE                  (1<<9)
+#define KIRKWOOD_PLAYCTL_SPDIF_MUTE             (1<<8)
+#define KIRKWOOD_PLAYCTL_MONO_MASK              (3<<5)
+#define KIRKWOOD_PLAYCTL_MONO_BOTH              (3<<5)
+#define KIRKWOOD_PLAYCTL_MONO_OFF               (0<<5)
+#define KIRKWOOD_PLAYCTL_I2S_MUTE               (1<<7)
+#define KIRKWOOD_PLAYCTL_SPDIF_EN               (1<<4)
+#define KIRKWOOD_PLAYCTL_I2S_EN         (1<<3)
+#define KIRKWOOD_PLAYCTL_SIZE_MASK              (7<<0)
+#define KIRKWOOD_PLAYCTL_SIZE_16                (7<<0)
+#define KIRKWOOD_PLAYCTL_SIZE_16_C              (3<<0)
+#define KIRKWOOD_PLAYCTL_SIZE_20                (2<<0)
+#define KIRKWOOD_PLAYCTL_SIZE_24                (1<<0)
+#define KIRKWOOD_PLAYCTL_SIZE_32                (0<<0)
+
+#define KIRKWOOD_PLAY_BUF_ADDR                  0x1104
+#define KIRKWOOD_PLAY_BUF_SIZE                  0x1108
+#define KIRKWOOD_PLAY_BYTE_COUNT                0x110C
+
+#define KIRKWOOD_DCO_CTL                        0x1204
+#define KIRKWOOD_DCO_CTL_OFFSET_MASK            (0xFFF<<2)
+#define KIRKWOOD_DCO_CTL_OFFSET_0               (0x800<<2)
+#define KIRKWOOD_DCO_CTL_FREQ_MASK              (3<<0)
+#define KIRKWOOD_DCO_CTL_FREQ_11                (0<<0)
+#define KIRKWOOD_DCO_CTL_FREQ_12                (1<<0)
+#define KIRKWOOD_DCO_CTL_FREQ_24                (2<<0)
+
+#define KIRKWOOD_DCO_SPCR_STATUS                0x120c
+#define KIRKWOOD_DCO_SPCR_STATUS_DCO_LOCK       (1<<16)
+
+#define KIRKWOOD_ERR_CAUSE                      0x1300
+#define KIRKWOOD_ERR_MASK                       0x1304
+
+#define KIRKWOOD_INT_CAUSE                      0x1308
+#define KIRKWOOD_INT_MASK                       0x130C
+#define KIRKWOOD_INT_CAUSE_PLAY_BYTES           (1<<14)
+#define KIRKWOOD_INT_CAUSE_REC_BYTES            (1<<13)
+#define KIRKWOOD_INT_CAUSE_DMA_PLAY_END (1<<7)
+#define KIRKWOOD_INT_CAUSE_DMA_PLAY_3Q          (1<<6)
+#define KIRKWOOD_INT_CAUSE_DMA_PLAY_HALF        (1<<5)
+#define KIRKWOOD_INT_CAUSE_DMA_PLAY_1Q          (1<<4)
+#define KIRKWOOD_INT_CAUSE_DMA_REC_END          (1<<3)
+#define KIRKWOOD_INT_CAUSE_DMA_REC_3Q           (1<<2)
+#define KIRKWOOD_INT_CAUSE_DMA_REC_HALF (1<<1)
+#define KIRKWOOD_INT_CAUSE_DMA_REC_1Q           (1<<0)
+
+#define KIRKWOOD_REC_BYTE_INT_COUNT             0x1310
+#define KIRKWOOD_PLAY_BYTE_INT_COUNT            0x1314
+#define KIRKWOOD_BYTE_INT_COUNT_MASK            0xffffff
+
+#define KIRKWOOD_I2S_PLAYCTL                    0x2508
+#define KIRKWOOD_I2S_RECCTL                     0x2408
+#define KIRKWOOD_I2S_CTL_JUST_MASK              (0xf<<26)
+#define KIRKWOOD_I2S_CTL_LJ                     (0<<26)
+#define KIRKWOOD_I2S_CTL_I2S                    (5<<26)
+#define KIRKWOOD_I2S_CTL_RJ                     (8<<26)
+#define KIRKWOOD_I2S_CTL_SIZE_MASK              (3<<30)
+#define KIRKWOOD_I2S_CTL_SIZE_16                (3<<30)
+#define KIRKWOOD_I2S_CTL_SIZE_20                (2<<30)
+#define KIRKWOOD_I2S_CTL_SIZE_24                (1<<30)
+#define KIRKWOOD_I2S_CTL_SIZE_32                (0<<30)
+
+#define KIRKWOOD_AUDIO_BUF_MAX                  (16*1024*1024)
+
+/* Theses values come from the marvell alsa driver */
+/* need to find where they come from               */
+#define KIRKWOOD_SND_MIN_PERIODS                8
+#define KIRKWOOD_SND_MAX_PERIODS                16
+#define KIRKWOOD_SND_MIN_PERIOD_BYTES           0x4000
+#define KIRKWOOD_SND_MAX_PERIOD_BYTES           0x4000
+
+struct kirkwood_dma_data {
+        struct resource *mem;
+        void __iomem *io;
+        int irq;
+        int burst;
+        struct mbus_dram_target_info *dram;
+};
+
+#endif
diff --git a/sound/soc/nuc900/Kconfig b/sound/soc/nuc900/Kconfig
new file mode 100644
index 000000000000..a0ed1c618f60
--- /dev/null
+++ b/sound/soc/nuc900/Kconfig
@@ -0,0 +1,27 @@
+##
+## NUC900 series AC97 API
+##
+config SND_SOC_NUC900
+        tristate "SoC Audio for NUC900 series"
+        depends on ARCH_W90X900
+        help
+          This option enables support for AC97 mode on the NUC900 SoC.
+
+config SND_SOC_NUC900_AC97
+        tristate
+        select AC97_BUS
+        select SND_AC97_CODEC
+        select SND_SOC_AC97_BUS
+
+
+##
+## Boards
+##
+config SND_SOC_NUC900EVB
+        tristate "NUC900 AC97 support for demo board"
+        depends on SND_SOC_NUC900
+        select SND_SOC_NUC900_AC97
+        select SND_SOC_AC97_CODEC
+        help
+          Select this option to enable audio (AC97) on the
+          NUC900 demoboard.
diff --git a/sound/soc/nuc900/Makefile b/sound/soc/nuc900/Makefile
new file mode 100644
index 000000000000..7e46c7150316
--- /dev/null
+++ b/sound/soc/nuc900/Makefile
@@ -0,0 +1,11 @@
+# NUC900 series audio
+snd-soc-nuc900-pcm-objs := nuc900-pcm.o
+snd-soc-nuc900-ac97-objs := nuc900-ac97.o
+
+obj-$(CONFIG_SND_SOC_NUC900) += snd-soc-nuc900-pcm.o
+obj-$(CONFIG_SND_SOC_NUC900_AC97) += snd-soc-nuc900-ac97.o
+
+# Boards
+snd-soc-nuc900-audio-objs := nuc900-audio.o
+
+obj-$(CONFIG_SND_SOC_NUC900EVB) += snd-soc-nuc900-audio.o
diff --git a/sound/soc/nuc900/nuc900-ac97.c b/sound/soc/nuc900/nuc900-ac97.c
new file mode 100644
index 000000000000..caa7c901bc2e
--- /dev/null
+++ b/sound/soc/nuc900/nuc900-ac97.c
@@ -0,0 +1,430 @@
+/*
+ * Copyright (c) 2009-2010 Nuvoton technology corporation.
+ *
+ * Wan ZongShun <mcuos.com@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 of the License.
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/device.h>
+#include <linux/delay.h>
+#include <linux/mutex.h>
+#include <linux/suspend.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/initval.h>
+#include <sound/soc.h>
+#include <linux/device.h>
+#include <linux/clk.h>
+
+#include <mach/mfp.h>
+
+#include "nuc900-audio.h"
+
+static DEFINE_MUTEX(ac97_mutex);
+struct nuc900_audio *nuc900_ac97_data;
+
+static int nuc900_checkready(void)
+{
+        struct nuc900_audio *nuc900_audio = nuc900_ac97_data;
+
+        if (!(AUDIO_READ(nuc900_audio->mmio + ACTL_ACIS0) & CODEC_READY))
+                return -EPERM;
+
+        return 0;
+}
+
+/* AC97 controller reads codec register */
+static unsigned short nuc900_ac97_read(struct snd_ac97 *ac97,
+                                        unsigned short reg)
+{
+        struct nuc900_audio *nuc900_audio = nuc900_ac97_data;
+        unsigned long timeout = 0x10000, val;
+
+        mutex_lock(&ac97_mutex);
+
+        val = nuc900_checkready();
+        if (!!val) {
+                dev_err(nuc900_audio->dev, "AC97 codec is not ready\n");
+                goto out;
+        }
+
+        /* set the R_WB bit and write register index */
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACOS1, R_WB | reg);
+
+        /* set the valid frame bit and valid slots */
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_ACOS0);
+        val |= (VALID_FRAME | SLOT1_VALID);
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACOS0, val);
+
+        udelay(100);
+
+        /* polling the AC_R_FINISH */
+        while (!(AUDIO_READ(nuc900_audio->mmio + ACTL_ACCON) & AC_R_FINISH)
+                                                                && timeout--)
+                mdelay(1);
+
+        if (!timeout) {
+                dev_err(nuc900_audio->dev, "AC97 read register time out !\n");
+                val = -EPERM;
+                goto out;
+        }
+
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_ACOS0) ;
+        val &= ~SLOT1_VALID;
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACOS0, val);
+
+        if (AUDIO_READ(nuc900_audio->mmio + ACTL_ACIS1) >> 2 != reg) {
+                dev_err(nuc900_audio->dev,
+                                "R_INDEX of REG_ACTL_ACIS1 not match!\n");
+        }
+
+        udelay(100);
+        val = (AUDIO_READ(nuc900_audio->mmio + ACTL_ACIS2) & 0xFFFF);
+
+out:
+        mutex_unlock(&ac97_mutex);
+        return val;
+}
+
+/* AC97 controller writes to codec register */
+static void nuc900_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
+                                unsigned short val)
+{
+        struct nuc900_audio *nuc900_audio = nuc900_ac97_data;
+        unsigned long tmp, timeout = 0x10000;
+
+        mutex_lock(&ac97_mutex);
+
+        tmp = nuc900_checkready();
+        if (!!tmp)
+                dev_err(nuc900_audio->dev, "AC97 codec is not ready\n");
+
+        /* clear the R_WB bit and write register index */
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACOS1, reg);
+
+        /* write register value */
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACOS2, val);
+
+        /* set the valid frame bit and valid slots */
+        tmp = AUDIO_READ(nuc900_audio->mmio + ACTL_ACOS0);
+        tmp |= SLOT1_VALID | SLOT2_VALID | VALID_FRAME;
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACOS0, tmp);
+
+        udelay(100);
+
+        /* polling the AC_W_FINISH */
+        while ((AUDIO_READ(nuc900_audio->mmio + ACTL_ACCON) & AC_W_FINISH)
+                                                                && timeout--)
+                mdelay(1);
+
+        if (!timeout)
+                dev_err(nuc900_audio->dev, "AC97 write register time out !\n");
+
+        tmp = AUDIO_READ(nuc900_audio->mmio + ACTL_ACOS0);
+        tmp &= ~(SLOT1_VALID | SLOT2_VALID);
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACOS0, tmp);
+
+        mutex_unlock(&ac97_mutex);
+
+}
+
+static void nuc900_ac97_warm_reset(struct snd_ac97 *ac97)
+{
+        struct nuc900_audio *nuc900_audio = nuc900_ac97_data;
+        unsigned long val;
+
+        mutex_lock(&ac97_mutex);
+
+        /* warm reset AC 97 */
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_ACCON);
+        val |= AC_W_RES;
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACCON, val);
+
+        udelay(100);
+
+        val = nuc900_checkready();
+        if (!!val)
+                dev_err(nuc900_audio->dev, "AC97 codec is not ready\n");
+
+        mutex_unlock(&ac97_mutex);
+}
+
+static void nuc900_ac97_cold_reset(struct snd_ac97 *ac97)
+{
+        struct nuc900_audio *nuc900_audio = nuc900_ac97_data;
+        unsigned long val;
+
+        mutex_lock(&ac97_mutex);
+
+        /* reset Audio Controller */
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_RESET);
+        val |= ACTL_RESET_BIT;
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
+
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_RESET);
+        val &= (~ACTL_RESET_BIT);
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
+
+        /* reset AC-link interface */
+
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_RESET);
+        val |= AC_RESET;
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
+
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_RESET);
+        val &= ~AC_RESET;
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
+
+        /* cold reset AC 97 */
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_ACCON);
+        val |= AC_C_RES;
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACCON, val);
+
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_ACCON);
+        val &= (~AC_C_RES);
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACCON, val);
+
+        udelay(100);
+
+        mutex_unlock(&ac97_mutex);
+
+}
+
+/* AC97 controller operations */
+struct snd_ac97_bus_ops soc_ac97_ops = {
+        .read           = nuc900_ac97_read,
+        .write          = nuc900_ac97_write,
+        .reset          = nuc900_ac97_cold_reset,
+        .warm_reset     = nuc900_ac97_warm_reset,
+}
+EXPORT_SYMBOL_GPL(soc_ac97_ops);
+
+static int nuc900_ac97_trigger(struct snd_pcm_substream *substream,
+                                int cmd, struct snd_soc_dai *dai)
+{
+        struct nuc900_audio *nuc900_audio = nuc900_ac97_data;
+        int ret;
+        unsigned long val, tmp;
+
+        ret = 0;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+                val = AUDIO_READ(nuc900_audio->mmio + ACTL_RESET);
+                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                        tmp = AUDIO_READ(nuc900_audio->mmio + ACTL_ACOS0);
+                        tmp |= (SLOT3_VALID | SLOT4_VALID | VALID_FRAME);
+                        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACOS0, tmp);
+
+                        tmp = AUDIO_READ(nuc900_audio->mmio + ACTL_PSR);
+                        tmp |= (P_DMA_END_IRQ | P_DMA_MIDDLE_IRQ);
+                        AUDIO_WRITE(nuc900_audio->mmio + ACTL_PSR, tmp);
+                        val |= AC_PLAY;
+                } else {
+                        tmp = AUDIO_READ(nuc900_audio->mmio + ACTL_RSR);
+                        tmp |= (R_DMA_END_IRQ | R_DMA_MIDDLE_IRQ);
+
+                        AUDIO_WRITE(nuc900_audio->mmio + ACTL_RSR, tmp);
+                        val |= AC_RECORD;
+                }
+
+                AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
+
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                val = AUDIO_READ(nuc900_audio->mmio + ACTL_RESET);
+                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                        tmp = AUDIO_READ(nuc900_audio->mmio + ACTL_ACOS0);
+                        tmp &= ~(SLOT3_VALID | SLOT4_VALID);
+                        AUDIO_WRITE(nuc900_audio->mmio + ACTL_ACOS0, tmp);
+
+                        AUDIO_WRITE(nuc900_audio->mmio + ACTL_PSR, RESET_PRSR);
+                        val &= ~AC_PLAY;
+                } else {
+                        AUDIO_WRITE(nuc900_audio->mmio + ACTL_RSR, RESET_PRSR);
+                        val &= ~AC_RECORD;
+                }
+
+                AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
+
+                break;
+        default:
+                ret = -EINVAL;
+        }
+
+        return ret;
+}
+
+static int nuc900_ac97_probe(struct platform_device *pdev,
+                                        struct snd_soc_dai *dai)
+{
+        struct nuc900_audio *nuc900_audio = nuc900_ac97_data;
+        unsigned long val;
+
+        mutex_lock(&ac97_mutex);
+
+        /* enable unit clock */
+        clk_enable(nuc900_audio->clk);
+
+        /* enable audio controller and AC-link interface */
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_CON);
+        val |= (IIS_AC_PIN_SEL | ACLINK_EN);
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val);
+
+        mutex_unlock(&ac97_mutex);
+
+        return 0;
+}
+
+static void nuc900_ac97_remove(struct platform_device *pdev,
+                                                struct snd_soc_dai *dai)
+{
+        struct nuc900_audio *nuc900_audio = nuc900_ac97_data;
+
+        clk_disable(nuc900_audio->clk);
+}
+
+static struct snd_soc_dai_ops nuc900_ac97_dai_ops = {
+        .trigger        = nuc900_ac97_trigger,
+};
+
+struct snd_soc_dai nuc900_ac97_dai = {
+        .name                   = "nuc900-ac97",
+        .probe                  = nuc900_ac97_probe,
+        .remove                 = nuc900_ac97_remove,
+        .ac97_control           = 1,
+        .playback = {
+                .rates          = SNDRV_PCM_RATE_8000_48000,
+                .formats        = SNDRV_PCM_FMTBIT_S16_LE,
+                .channels_min   = 1,
+                .channels_max   = 2,
+        },
+        .capture = {
+                .rates          = SNDRV_PCM_RATE_8000_48000,
+                .formats        = SNDRV_PCM_FMTBIT_S16_LE,
+                .channels_min   = 1,
+                .channels_max   = 2,
+        },
+        .ops = &nuc900_ac97_dai_ops,
+}
+EXPORT_SYMBOL_GPL(nuc900_ac97_dai);
+
+static int __devinit nuc900_ac97_drvprobe(struct platform_device *pdev)
+{
+        struct nuc900_audio *nuc900_audio;
+        int ret;
+
+        if (nuc900_ac97_data)
+                return -EBUSY;
+
+        nuc900_audio = kzalloc(sizeof(struct nuc900_audio), GFP_KERNEL);
+        if (!nuc900_audio)
+                return -ENOMEM;
+
+        spin_lock_init(&nuc900_audio->lock);
+
+        nuc900_audio->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!nuc900_audio->res) {
+                ret = -ENODEV;
+                goto out0;
+        }
+
+        if (!request_mem_region(nuc900_audio->res->start,
+                        resource_size(nuc900_audio->res), pdev->name)) {
+                ret = -EBUSY;
+                goto out0;
+        }
+
+        nuc900_audio->mmio = ioremap(nuc900_audio->res->start,
+                                        resource_size(nuc900_audio->res));
+        if (!nuc900_audio->mmio) {
+                ret = -ENOMEM;
+                goto out1;
+        }
+
+        nuc900_audio->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(nuc900_audio->clk)) {
+                ret = PTR_ERR(nuc900_audio->clk);
+                goto out2;
+        }
+
+        nuc900_audio->irq_num = platform_get_irq(pdev, 0);
+        if (!nuc900_audio->irq_num) {
+                ret = -EBUSY;
+                goto out2;
+        }
+
+        nuc900_ac97_data = nuc900_audio;
+
+        nuc900_audio->dev = nuc900_ac97_dai.dev =  &pdev->dev;
+
+        ret = snd_soc_register_dai(&nuc900_ac97_dai);
+        if (ret)
+                goto out3;
+
+        mfp_set_groupg(nuc900_audio->dev); /* enbale ac97 multifunction pin*/
+
+        return 0;
+
+out3:
+        clk_put(nuc900_audio->clk);
+out2:
+        iounmap(nuc900_audio->mmio);
+out1:
+        release_mem_region(nuc900_audio->res->start,
+                                        resource_size(nuc900_audio->res));
+out0:
+        kfree(nuc900_audio);
+        return ret;
+}
+
+static int __devexit nuc900_ac97_drvremove(struct platform_device *pdev)
+{
+
+        snd_soc_unregister_dai(&nuc900_ac97_dai);
+
+        clk_put(nuc900_ac97_data->clk);
+        iounmap(nuc900_ac97_data->mmio);
+        release_mem_region(nuc900_ac97_data->res->start,
+                                resource_size(nuc900_ac97_data->res));
+
+        nuc900_ac97_data = NULL;
+
+        return 0;
+}
+
+static struct platform_driver nuc900_ac97_driver = {
+        .driver = {
+                .name   = "nuc900-audio",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = nuc900_ac97_drvprobe,
+        .remove         = __devexit_p(nuc900_ac97_drvremove),
+};
+
+static int __init nuc900_ac97_init(void)
+{
+        return platform_driver_register(&nuc900_ac97_driver);
+}
+
+static void __exit nuc900_ac97_exit(void)
+{
+        platform_driver_unregister(&nuc900_ac97_driver);
+}
+
+module_init(nuc900_ac97_init);
+module_exit(nuc900_ac97_exit);
+
+MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
+MODULE_DESCRIPTION("NUC900 AC97 SoC driver!");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:nuc900-ac97");
diff --git a/sound/soc/nuc900/nuc900-audio.c b/sound/soc/nuc900/nuc900-audio.c
new file mode 100644
index 000000000000..72e6f518f7b2
--- /dev/null
+++ b/sound/soc/nuc900/nuc900-audio.c
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2010 Nuvoton technology corporation.
+ *
+ * Wan ZongShun <mcuos.com@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 of the License.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/timer.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+#include "../codecs/ac97.h"
+#include "nuc900-audio.h"
+
+static struct snd_soc_dai_link nuc900evb_ac97_dai = {
+        .name           = "AC97",
+        .stream_name    = "AC97 HiFi",
+        .cpu_dai        = &nuc900_ac97_dai,
+        .codec_dai      = &ac97_dai,
+};
+
+static struct snd_soc_card nuc900evb_audio_machine = {
+        .name           = "NUC900EVB_AC97",
+        .dai_link       = &nuc900evb_ac97_dai,
+        .num_links      = 1,
+        .platform       = &nuc900_soc_platform,
+};
+
+static struct snd_soc_device nuc900evb_ac97_devdata = {
+        .card           = &nuc900evb_audio_machine,
+        .codec_dev      = &soc_codec_dev_ac97,
+};
+
+static struct platform_device *nuc900evb_asoc_dev;
+
+static int __init nuc900evb_audio_init(void)
+{
+        int ret;
+
+        ret = -ENOMEM;
+        nuc900evb_asoc_dev = platform_device_alloc("soc-audio", -1);
+        if (!nuc900evb_asoc_dev)
+                goto out;
+
+        /* nuc900 board audio device */
+        platform_set_drvdata(nuc900evb_asoc_dev, &nuc900evb_ac97_devdata);
+
+        nuc900evb_ac97_devdata.dev = &nuc900evb_asoc_dev->dev;
+        ret = platform_device_add(nuc900evb_asoc_dev);
+
+        if (ret) {
+                platform_device_put(nuc900evb_asoc_dev);
+                nuc900evb_asoc_dev = NULL;
+        }
+
+out:
+        return ret;
+}
+
+static void __exit nuc900evb_audio_exit(void)
+{
+        platform_device_unregister(nuc900evb_asoc_dev);
+}
+
+module_init(nuc900evb_audio_init);
+module_exit(nuc900evb_audio_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("NUC900 Series ASoC audio support");
+MODULE_AUTHOR("Wan ZongShun");
diff --git a/sound/soc/nuc900/nuc900-audio.h b/sound/soc/nuc900/nuc900-audio.h
new file mode 100644
index 000000000000..3038f519729f
--- /dev/null
+++ b/sound/soc/nuc900/nuc900-audio.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2010 Nuvoton technology corporation.
+ *
+ * Wan ZongShun <mcuos.com@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 of the License.
+ *
+ */
+
+#ifndef _NUC900_AUDIO_H
+#define _NUC900_AUDIO_H
+
+#include <linux/io.h>
+
+/* Audio Control Registers */
+#define ACTL_CON                0x00
+#define ACTL_RESET              0x04
+#define ACTL_RDSTB              0x08
+#define ACTL_RDST_LENGTH        0x0C
+#define ACTL_RDSTC              0x10
+#define ACTL_RSR                0x14
+#define ACTL_PDSTB              0x18
+#define ACTL_PDST_LENGTH        0x1C
+#define ACTL_PDSTC              0x20
+#define ACTL_PSR                0x24
+#define ACTL_IISCON             0x28
+#define ACTL_ACCON              0x2C
+#define ACTL_ACOS0              0x30
+#define ACTL_ACOS1              0x34
+#define ACTL_ACOS2              0x38
+#define ACTL_ACIS0              0x3C
+#define ACTL_ACIS1              0x40
+#define ACTL_ACIS2              0x44
+#define ACTL_COUNTER            0x48
+
+/* bit definition of REG_ACTL_CON register */
+#define R_DMA_IRQ               0x1000
+#define T_DMA_IRQ               0x0800
+#define IIS_AC_PIN_SEL          0x0100
+#define FIFO_TH                 0x0080
+#define ADC_EN                  0x0010
+#define M80_EN                  0x0008
+#define ACLINK_EN               0x0004
+#define IIS_EN                  0x0002
+
+/* bit definition of REG_ACTL_RESET register */
+#define W5691_PLAY              0x20000
+#define ACTL_RESET_BIT          0x10000
+#define RECORD_RIGHT_CHNNEL     0x08000
+#define RECORD_LEFT_CHNNEL      0x04000
+#define PLAY_RIGHT_CHNNEL       0x02000
+#define PLAY_LEFT_CHNNEL        0x01000
+#define DAC_PLAY                0x00800
+#define ADC_RECORD              0x00400
+#define M80_PLAY                0x00200
+#define AC_RECORD               0x00100
+#define AC_PLAY                 0x00080
+#define IIS_RECORD              0x00040
+#define IIS_PLAY                0x00020
+#define DAC_RESET               0x00010
+#define ADC_RESET               0x00008
+#define M80_RESET               0x00004
+#define AC_RESET                0x00002
+#define IIS_RESET               0x00001
+
+/* bit definition of REG_ACTL_ACCON register */
+#define AC_BCLK_PU_EN           0x20
+#define AC_R_FINISH             0x10
+#define AC_W_FINISH             0x08
+#define AC_W_RES                0x04
+#define AC_C_RES                0x02
+
+/* bit definition of ACTL_RSR register */
+#define R_FIFO_EMPTY            0x04
+#define R_DMA_END_IRQ           0x02
+#define R_DMA_MIDDLE_IRQ        0x01
+
+/* bit definition of ACTL_PSR register */
+#define P_FIFO_EMPTY            0x04
+#define P_DMA_END_IRQ           0x02
+#define P_DMA_MIDDLE_IRQ        0x01
+
+/* bit definition of ACTL_ACOS0 register */
+#define SLOT1_VALID             0x01
+#define SLOT2_VALID             0x02
+#define SLOT3_VALID             0x04
+#define SLOT4_VALID             0x08
+#define VALID_FRAME             0x10
+
+/* bit definition of ACTL_ACOS1 register */
+#define R_WB                    0x80
+
+#define CODEC_READY             0x10
+#define RESET_PRSR              0x00
+#define AUDIO_WRITE(addr, val)  __raw_writel(val, addr)
+#define AUDIO_READ(addr)        __raw_readl(addr)
+
+struct nuc900_audio {
+        void __iomem *mmio;
+        spinlock_t lock;
+        dma_addr_t dma_addr[2];
+        unsigned long buffersize[2];
+        unsigned long irq_num;
+        struct snd_pcm_substream *substream;
+        struct resource *res;
+        struct clk *clk;
+        struct device *dev;
+
+};
+
+extern struct nuc900_audio *nuc900_ac97_data;
+extern struct snd_soc_dai nuc900_ac97_dai;
+extern struct snd_soc_platform nuc900_soc_platform;
+
+#endif /*end _NUC900_AUDIO_H */
diff --git a/sound/soc/nuc900/nuc900-pcm.c b/sound/soc/nuc900/nuc900-pcm.c
new file mode 100644
index 000000000000..e81e803b3a63
--- /dev/null
+++ b/sound/soc/nuc900/nuc900-pcm.c
@@ -0,0 +1,354 @@
+/*
+ * Copyright (c) 2010 Nuvoton technology corporation.
+ *
+ * Wan ZongShun <mcuos.com@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 of the License.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/dma-mapping.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc.h>
+
+#include <mach/hardware.h>
+
+#include "nuc900-audio.h"
+
+static const struct snd_pcm_hardware nuc900_pcm_hardware = {
+        .info                   = SNDRV_PCM_INFO_INTERLEAVED |
+                                        SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                                        SNDRV_PCM_INFO_MMAP |
+                                        SNDRV_PCM_INFO_MMAP_VALID |
+                                        SNDRV_PCM_INFO_PAUSE |
+                                        SNDRV_PCM_INFO_RESUME,
+        .formats                = SNDRV_PCM_FMTBIT_S16_LE,
+        .channels_min           = 1,
+        .channels_max           = 2,
+        .buffer_bytes_max       = 4*1024,
+        .period_bytes_min       = 1*1024,
+        .period_bytes_max       = 4*1024,
+        .periods_min            = 1,
+        .periods_max            = 1024,
+};
+
+static int nuc900_dma_hw_params(struct snd_pcm_substream *substream,
+        struct snd_pcm_hw_params *params)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct nuc900_audio *nuc900_audio = runtime->private_data;
+        unsigned long flags;
+        int ret = 0;
+
+        spin_lock_irqsave(&nuc900_audio->lock, flags);
+
+        ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
+        if (ret < 0)
+                return ret;
+
+        nuc900_audio->substream = substream;
+        nuc900_audio->dma_addr[substream->stream] = runtime->dma_addr;
+        nuc900_audio->buffersize[substream->stream] =
+                                                params_buffer_bytes(params);
+
+        spin_unlock_irqrestore(&nuc900_audio->lock, flags);
+
+        return ret;
+}
+
+static void nuc900_update_dma_register(struct snd_pcm_substream *substream,
+                                dma_addr_t dma_addr, size_t count)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct nuc900_audio *nuc900_audio = runtime->private_data;
+        void __iomem *mmio_addr, *mmio_len;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                mmio_addr = nuc900_audio->mmio + ACTL_PDSTB;
+                mmio_len = nuc900_audio->mmio + ACTL_PDST_LENGTH;
+        } else {
+                mmio_addr = nuc900_audio->mmio + ACTL_RDSTB;
+                mmio_len = nuc900_audio->mmio + ACTL_RDST_LENGTH;
+        }
+
+        AUDIO_WRITE(mmio_addr, dma_addr);
+        AUDIO_WRITE(mmio_len, count);
+}
+
+static void nuc900_dma_start(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct nuc900_audio *nuc900_audio = runtime->private_data;
+        unsigned long val;
+
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_CON);
+        val |= (T_DMA_IRQ | R_DMA_IRQ);
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val);
+}
+
+static void nuc900_dma_stop(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct nuc900_audio *nuc900_audio = runtime->private_data;
+        unsigned long val;
+
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_CON);
+        val &= ~(T_DMA_IRQ | R_DMA_IRQ);
+        AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val);
+}
+
+static irqreturn_t nuc900_dma_interrupt(int irq, void *dev_id)
+{
+        struct snd_pcm_substream *substream = dev_id;
+        struct nuc900_audio *nuc900_audio = substream->runtime->private_data;
+        unsigned long val;
+
+        spin_lock(&nuc900_audio->lock);
+
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_CON);
+
+        if (val & R_DMA_IRQ) {
+                AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val | R_DMA_IRQ);
+
+                val = AUDIO_READ(nuc900_audio->mmio + ACTL_RSR);
+
+                if (val & R_DMA_MIDDLE_IRQ) {
+                        val |= R_DMA_MIDDLE_IRQ;
+                        AUDIO_WRITE(nuc900_audio->mmio + ACTL_RSR, val);
+                }
+
+                if (val & R_DMA_END_IRQ) {
+                        val |= R_DMA_END_IRQ;
+                        AUDIO_WRITE(nuc900_audio->mmio + ACTL_RSR, val);
+                }
+        } else if (val & T_DMA_IRQ) {
+                AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val | T_DMA_IRQ);
+
+                val = AUDIO_READ(nuc900_audio->mmio + ACTL_PSR);
+
+                if (val & P_DMA_MIDDLE_IRQ) {
+                        val |= P_DMA_MIDDLE_IRQ;
+                        AUDIO_WRITE(nuc900_audio->mmio + ACTL_PSR, val);
+                }
+
+                if (val & P_DMA_END_IRQ) {
+                        val |= P_DMA_END_IRQ;
+                        AUDIO_WRITE(nuc900_audio->mmio + ACTL_PSR, val);
+                }
+        } else {
+                dev_err(nuc900_audio->dev, "Wrong DMA interrupt status!\n");
+                spin_unlock(&nuc900_audio->lock);
+                return IRQ_HANDLED;
+        }
+
+        spin_unlock(&nuc900_audio->lock);
+
+        snd_pcm_period_elapsed(substream);
+
+        return IRQ_HANDLED;
+}
+
+static int nuc900_dma_hw_free(struct snd_pcm_substream *substream)
+{
+        snd_pcm_lib_free_pages(substream);
+        return 0;
+}
+
+static int nuc900_dma_prepare(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct nuc900_audio *nuc900_audio = runtime->private_data;
+        unsigned long flags, val;
+
+        spin_lock_irqsave(&nuc900_audio->lock, flags);
+
+        nuc900_update_dma_register(substream,
+                                nuc900_audio->dma_addr[substream->stream],
+                                nuc900_audio->buffersize[substream->stream]);
+
+        val = AUDIO_READ(nuc900_audio->mmio + ACTL_RESET);
+
+        switch (runtime->channels) {
+        case 1:
+                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                        val &= ~(PLAY_LEFT_CHNNEL | PLAY_RIGHT_CHNNEL);
+                        val |= PLAY_RIGHT_CHNNEL;
+                } else {
+                        val &= ~(RECORD_LEFT_CHNNEL | RECORD_RIGHT_CHNNEL);
+                        val |= RECORD_RIGHT_CHNNEL;
+                }
+                AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
+                break;
+        case 2:
+                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                        val |= (PLAY_LEFT_CHNNEL | PLAY_RIGHT_CHNNEL);
+                else
+                        val |= (RECORD_LEFT_CHNNEL | RECORD_RIGHT_CHNNEL);
+                AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
+                break;
+        default:
+                return -EINVAL;
+        }
+        spin_unlock_irqrestore(&nuc900_audio->lock, flags);
+        return 0;
+}
+
+static int nuc900_dma_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        int ret = 0;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+                nuc900_dma_start(substream);
+                break;
+
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                nuc900_dma_stop(substream);
+                break;
+
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+        return ret;
+}
+
+int nuc900_dma_getposition(struct snd_pcm_substream *substream,
+                                        dma_addr_t *src, dma_addr_t *dst)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct nuc900_audio *nuc900_audio = runtime->private_data;
+
+        if (src != NULL)
+                *src = AUDIO_READ(nuc900_audio->mmio + ACTL_PDSTC);
+
+        if (dst != NULL)
+                *dst = AUDIO_READ(nuc900_audio->mmio + ACTL_RDSTC);
+
+        return 0;
+}
+
+static snd_pcm_uframes_t nuc900_dma_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        dma_addr_t src, dst;
+        unsigned long res;
+
+        nuc900_dma_getposition(substream, &src, &dst);
+
+        if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                res = dst - runtime->dma_addr;
+        else
+                res = src - runtime->dma_addr;
+
+        return bytes_to_frames(substream->runtime, res);
+}
+
+static int nuc900_dma_open(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct nuc900_audio *nuc900_audio;
+
+        snd_soc_set_runtime_hwparams(substream, &nuc900_pcm_hardware);
+
+        nuc900_audio = nuc900_ac97_data;
+
+        if (request_irq(nuc900_audio->irq_num, nuc900_dma_interrupt,
+                        IRQF_DISABLED, "nuc900-dma", substream))
+                return -EBUSY;
+
+        runtime->private_data = nuc900_audio;
+
+        return 0;
+}
+
+static int nuc900_dma_close(struct snd_pcm_substream *substream)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct nuc900_audio *nuc900_audio = runtime->private_data;
+
+        free_irq(nuc900_audio->irq_num, substream);
+
+        return 0;
+}
+
+static int nuc900_dma_mmap(struct snd_pcm_substream *substream,
+        struct vm_area_struct *vma)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+
+        return dma_mmap_writecombine(substream->pcm->card->dev, vma,
+                                        runtime->dma_area,
+                                        runtime->dma_addr,
+                                        runtime->dma_bytes);
+}
+
+static struct snd_pcm_ops nuc900_dma_ops = {
+        .open           = nuc900_dma_open,
+        .close          = nuc900_dma_close,
+        .ioctl          = snd_pcm_lib_ioctl,
+        .hw_params      = nuc900_dma_hw_params,
+        .hw_free        = nuc900_dma_hw_free,
+        .prepare        = nuc900_dma_prepare,
+        .trigger        = nuc900_dma_trigger,
+        .pointer        = nuc900_dma_pointer,
+        .mmap           = nuc900_dma_mmap,
+};
+
+static void nuc900_dma_free_dma_buffers(struct snd_pcm *pcm)
+{
+        snd_pcm_lib_preallocate_free_for_all(pcm);
+}
+
+static u64 nuc900_pcm_dmamask = DMA_BIT_MASK(32);
+static int nuc900_dma_new(struct snd_card *card,
+        struct snd_soc_dai *dai, struct snd_pcm *pcm)
+{
+        if (!card->dev->dma_mask)
+                card->dev->dma_mask = &nuc900_pcm_dmamask;
+        if (!card->dev->coherent_dma_mask)
+                card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
+
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                card->dev, 4 * 1024, (4 * 1024) - 1);
+
+        return 0;
+}
+
+struct snd_soc_platform nuc900_soc_platform = {
+        .name           = "nuc900-dma",
+        .pcm_ops        = &nuc900_dma_ops,
+        .pcm_new        = nuc900_dma_new,
+        .pcm_free       = nuc900_dma_free_dma_buffers,
+}
+EXPORT_SYMBOL_GPL(nuc900_soc_platform);
+
+static int __init nuc900_soc_platform_init(void)
+{
+        return snd_soc_register_platform(&nuc900_soc_platform);
+}
+
+static void __exit nuc900_soc_platform_exit(void)
+{
+        snd_soc_unregister_platform(&nuc900_soc_platform);
+}
+
+module_init(nuc900_soc_platform_init);
+module_exit(nuc900_soc_platform_exit);
+
+MODULE_AUTHOR("Wan ZongShun, <mcuos.com@gmail.com>");
+MODULE_DESCRIPTION("nuc900 Audio DMA module");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/omap/omap-mcbsp.c b/sound/soc/omap/omap-mcbsp.c
index 6f44cb4d30b8..86f213905e2c 100644
--- a/sound/soc/omap/omap-mcbsp.c
+++ b/sound/soc/omap/omap-mcbsp.c
@@ -59,6 +59,7 @@ struct omap_mcbsp_data {
         int                             configured;
         unsigned int                    in_freq;
         int                             clk_div;
+        int                             wlen;
 };
 
 #define to_mcbsp(priv)  container_of((priv), struct omap_mcbsp_data, bus_id)
@@ -154,20 +155,51 @@ static void omap_mcbsp_set_threshold(struct snd_pcm_substream *substream)
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
         struct omap_mcbsp_data *mcbsp_data = to_mcbsp(cpu_dai->private_data);
+        struct omap_pcm_dma_data *dma_data;
         int dma_op_mode = omap_mcbsp_get_dma_op_mode(mcbsp_data->bus_id);
-        int samples;
+        int words;
+
+        dma_data = snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
 
         /* TODO: Currently, MODE_ELEMENT == MODE_FRAME */
         if (dma_op_mode == MCBSP_DMA_MODE_THRESHOLD)
-                samples = snd_pcm_lib_period_bytes(substream) >> 1;
+                /*
+                 * Configure McBSP threshold based on either:
+                 * packet_size, when the sDMA is in packet mode, or
+                 * based on the period size.
+                 */
+                if (dma_data->packet_size)
+                        words = dma_data->packet_size;
+                else
+                        words = snd_pcm_lib_period_bytes(substream) /
+                                                        (mcbsp_data->wlen / 8);
         else
-                samples = 1;
+                words = 1;
 
         /* Configure McBSP internal buffer usage */
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                omap_mcbsp_set_tx_threshold(mcbsp_data->bus_id, samples - 1);
+                omap_mcbsp_set_tx_threshold(mcbsp_data->bus_id, words);
         else
-                omap_mcbsp_set_rx_threshold(mcbsp_data->bus_id, samples - 1);
+                omap_mcbsp_set_rx_threshold(mcbsp_data->bus_id, words);
+}
+
+static int omap_mcbsp_hwrule_min_buffersize(struct snd_pcm_hw_params *params,
+                                    struct snd_pcm_hw_rule *rule)
+{
+        struct snd_interval *buffer_size = hw_param_interval(params,
+                                        SNDRV_PCM_HW_PARAM_BUFFER_SIZE);
+        struct snd_interval *channels = hw_param_interval(params,
+                                        SNDRV_PCM_HW_PARAM_CHANNELS);
+        struct omap_mcbsp_data *mcbsp_data = rule->private;
+        struct snd_interval frames;
+        int size;
+
+        snd_interval_any(&frames);
+        size = omap_mcbsp_get_fifo_size(mcbsp_data->bus_id);
+
+        frames.min = size / channels->min;
+        frames.integer = 1;
+        return snd_interval_refine(buffer_size, &frames);
 }
 
 static int omap_mcbsp_dai_startup(struct snd_pcm_substream *substream,
@@ -182,33 +214,35 @@ static int omap_mcbsp_dai_startup(struct snd_pcm_substream *substream,
         if (!cpu_dai->active)
                 err = omap_mcbsp_request(bus_id);
 
+        /*
+         * OMAP3 McBSP FIFO is word structured.
+         * McBSP2 has 1024 + 256 = 1280 word long buffer,
+         * McBSP1,3,4,5 has 128 word long buffer
+         * This means that the size of the FIFO depends on the sample format.
+         * For example on McBSP3:
+         * 16bit samples: size is 128 * 2 = 256 bytes
+         * 32bit samples: size is 128 * 4 = 512 bytes
+         * It is simpler to place constraint for buffer and period based on
+         * channels.
+         * McBSP3 as example again (16 or 32 bit samples):
+         * 1 channel (mono): size is 128 frames (128 words)
+         * 2 channels (stereo): size is 128 / 2 = 64 frames (2 * 64 words)
+         * 4 channels: size is 128 / 4 = 32 frames (4 * 32 words)
+         */
         if (cpu_is_omap343x()) {
-                int dma_op_mode = omap_mcbsp_get_dma_op_mode(bus_id);
-                int max_period;
-
                 /*
-                 * McBSP2 in OMAP3 has 1024 * 32-bit internal audio buffer.
-                 * Set constraint for minimum buffer size to the same than FIFO
-                 * size in order to avoid underruns in playback startup because
-                 * HW is keeping the DMA request active until FIFO is filled.
-                 */
-                if (bus_id == 1)
-                        snd_pcm_hw_constraint_minmax(substream->runtime,
-                                        SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
-                                        4096, UINT_MAX);
-
-                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                        max_period = omap_mcbsp_get_max_tx_threshold(bus_id);
-                else
-                        max_period = omap_mcbsp_get_max_rx_threshold(bus_id);
-
-                max_period++;
-                max_period <<= 1;
-
-                if (dma_op_mode == MCBSP_DMA_MODE_THRESHOLD)
-                        snd_pcm_hw_constraint_minmax(substream->runtime,
-                                                SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
-                                                32, max_period);
+                * Rule for the buffer size. We should not allow
+                * smaller buffer than the FIFO size to avoid underruns
+                */
+                snd_pcm_hw_rule_add(substream->runtime, 0,
+                                    SNDRV_PCM_HW_PARAM_CHANNELS,
+                                    omap_mcbsp_hwrule_min_buffersize,
+                                    mcbsp_data,
+                                    SNDRV_PCM_HW_PARAM_BUFFER_SIZE, -1);
+
+                /* Make sure, that the period size is always even */
+                snd_pcm_hw_constraint_step(substream->runtime, 0,
+                                           SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 2);
         }
 
         return err;
@@ -289,11 +323,14 @@ static int omap_mcbsp_dai_hw_params(struct snd_pcm_substream *substream,
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
         struct omap_mcbsp_data *mcbsp_data = to_mcbsp(cpu_dai->private_data);
         struct omap_mcbsp_reg_cfg *regs = &mcbsp_data->regs;
-        int dma, bus_id = mcbsp_data->bus_id, id = cpu_dai->id;
+        struct omap_pcm_dma_data *dma_data;
+        int dma, bus_id = mcbsp_data->bus_id;
         int wlen, channels, wpf, sync_mode = OMAP_DMA_SYNC_ELEMENT;
+        int pkt_size = 0;
         unsigned long port;
         unsigned int format, div, framesize, master;
 
+        dma_data = &omap_mcbsp_dai_dma_params[cpu_dai->id][substream->stream];
         if (cpu_class_is_omap1()) {
                 dma = omap1_dma_reqs[bus_id][substream->stream];
                 port = omap1_mcbsp_port[bus_id][substream->stream];
@@ -306,35 +343,74 @@ static int omap_mcbsp_dai_hw_params(struct snd_pcm_substream *substream,
         } else if (cpu_is_omap343x()) {
                 dma = omap24xx_dma_reqs[bus_id][substream->stream];
                 port = omap34xx_mcbsp_port[bus_id][substream->stream];
-                omap_mcbsp_dai_dma_params[id][substream->stream].set_threshold =
-                                                omap_mcbsp_set_threshold;
-                /* TODO: Currently, MODE_ELEMENT == MODE_FRAME */
-                if (omap_mcbsp_get_dma_op_mode(bus_id) ==
-                                                MCBSP_DMA_MODE_THRESHOLD)
-                        sync_mode = OMAP_DMA_SYNC_FRAME;
         } else {
                 return -ENODEV;
         }
-        omap_mcbsp_dai_dma_params[id][substream->stream].name =
-                substream->stream ? "Audio Capture" : "Audio Playback";
-        omap_mcbsp_dai_dma_params[id][substream->stream].dma_req = dma;
-        omap_mcbsp_dai_dma_params[id][substream->stream].port_addr = port;
-        omap_mcbsp_dai_dma_params[id][substream->stream].sync_mode = sync_mode;
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_S16_LE:
-                omap_mcbsp_dai_dma_params[id][substream->stream].data_type =
-                         OMAP_DMA_DATA_TYPE_S16;
+                dma_data->data_type = OMAP_DMA_DATA_TYPE_S16;
+                wlen = 16;
                 break;
         case SNDRV_PCM_FORMAT_S32_LE:
-                omap_mcbsp_dai_dma_params[id][substream->stream].data_type =
-                         OMAP_DMA_DATA_TYPE_S32;
+                dma_data->data_type = OMAP_DMA_DATA_TYPE_S32;
+                wlen = 32;
                 break;
         default:
                 return -EINVAL;
         }
+        if (cpu_is_omap343x()) {
+                dma_data->set_threshold = omap_mcbsp_set_threshold;
+                /* TODO: Currently, MODE_ELEMENT == MODE_FRAME */
+                if (omap_mcbsp_get_dma_op_mode(bus_id) ==
+                                                MCBSP_DMA_MODE_THRESHOLD) {
+                        int period_words, max_thrsh;
+
+                        period_words = params_period_bytes(params) / (wlen / 8);
+                        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                                max_thrsh = omap_mcbsp_get_max_tx_threshold(
+                                                            mcbsp_data->bus_id);
+                        else
+                                max_thrsh = omap_mcbsp_get_max_rx_threshold(
+                                                            mcbsp_data->bus_id);
+                        /*
+                         * If the period contains less or equal number of words,
+                         * we are using the original threshold mode setup:
+                         * McBSP threshold = sDMA frame size = period_size
+                         * Otherwise we switch to sDMA packet mode:
+                         * McBSP threshold = sDMA packet size
+                         * sDMA frame size = period size
+                         */
+                        if (period_words > max_thrsh) {
+                                int divider = 0;
+
+                                /*
+                                 * Look for the biggest threshold value, which
+                                 * divides the period size evenly.
+                                 */
+                                divider = period_words / max_thrsh;
+                                if (period_words % max_thrsh)
+                                        divider++;
+                                while (period_words % divider &&
+                                        divider < period_words)
+                                        divider++;
+                                if (divider == period_words)
+                                        return -EINVAL;
+
+                                pkt_size = period_words / divider;
+                                sync_mode = OMAP_DMA_SYNC_PACKET;
+                        } else {
+                                sync_mode = OMAP_DMA_SYNC_FRAME;
+                        }
+                }
+        }
 
-        snd_soc_dai_set_dma_data(cpu_dai, substream,
-                &omap_mcbsp_dai_dma_params[id][substream->stream]);
+        dma_data->name = substream->stream ? "Audio Capture" : "Audio Playback";
+        dma_data->dma_req = dma;
+        dma_data->port_addr = port;
+        dma_data->sync_mode = sync_mode;
+        dma_data->packet_size = pkt_size;
+
+        snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
 
         if (mcbsp_data->configured) {
                 /* McBSP already configured by another stream */
@@ -360,7 +436,6 @@ static int omap_mcbsp_dai_hw_params(struct snd_pcm_substream *substream,
         switch (params_format(params)) {
         case SNDRV_PCM_FORMAT_S16_LE:
                 /* Set word lengths */
-                wlen = 16;
                 regs->rcr2      |= RWDLEN2(OMAP_MCBSP_WORD_16);
                 regs->rcr1      |= RWDLEN1(OMAP_MCBSP_WORD_16);
                 regs->xcr2      |= XWDLEN2(OMAP_MCBSP_WORD_16);
@@ -368,7 +443,6 @@ static int omap_mcbsp_dai_hw_params(struct snd_pcm_substream *substream,
                 break;
         case SNDRV_PCM_FORMAT_S32_LE:
                 /* Set word lengths */
-                wlen = 32;
                 regs->rcr2      |= RWDLEN2(OMAP_MCBSP_WORD_32);
                 regs->rcr1      |= RWDLEN1(OMAP_MCBSP_WORD_32);
                 regs->xcr2      |= XWDLEN2(OMAP_MCBSP_WORD_32);
@@ -409,6 +483,7 @@ static int omap_mcbsp_dai_hw_params(struct snd_pcm_substream *substream,
         }
 
         omap_mcbsp_config(bus_id, &mcbsp_data->regs);
+        mcbsp_data->wlen = wlen;
         mcbsp_data->configured = 1;
 
         return 0;
diff --git a/sound/soc/omap/omap3pandora.c b/sound/soc/omap/omap3pandora.c
index 87ce842fa2e8..9eecac135bbb 100644
--- a/sound/soc/omap/omap3pandora.c
+++ b/sound/soc/omap/omap3pandora.c
@@ -43,12 +43,14 @@
 
 static struct regulator *omap3pandora_dac_reg;
 
-static int omap3pandora_cmn_hw_params(struct snd_pcm_substream *substream,
-        struct snd_pcm_hw_params *params, unsigned int fmt)
+static int omap3pandora_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->dai->codec_dai;
         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        int fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+                  SND_SOC_DAIFMT_CBS_CFS;
         int ret;
 
         /* Set codec DAI configuration */
@@ -91,24 +93,6 @@ static int omap3pandora_cmn_hw_params(struct snd_pcm_substream *substream,
         return 0;
 }
 
-static int omap3pandora_out_hw_params(struct snd_pcm_substream *substream,
-        struct snd_pcm_hw_params *params)
-{
-        return omap3pandora_cmn_hw_params(substream, params,
-                                          SND_SOC_DAIFMT_I2S |
-                                          SND_SOC_DAIFMT_IB_NF |
-                                          SND_SOC_DAIFMT_CBS_CFS);
-}
-
-static int omap3pandora_in_hw_params(struct snd_pcm_substream *substream,
-        struct snd_pcm_hw_params *params)
-{
-        return omap3pandora_cmn_hw_params(substream, params,
-                                          SND_SOC_DAIFMT_I2S |
-                                          SND_SOC_DAIFMT_NB_NF |
-                                          SND_SOC_DAIFMT_CBS_CFS);
-}
-
 static int omap3pandora_dac_event(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *k, int event)
 {
@@ -231,12 +215,8 @@ static int omap3pandora_in_init(struct snd_soc_codec *codec)
         return snd_soc_dapm_sync(codec);
 }
 
-static struct snd_soc_ops omap3pandora_out_ops = {
-        .hw_params = omap3pandora_out_hw_params,
-};
-
-static struct snd_soc_ops omap3pandora_in_ops = {
-        .hw_params = omap3pandora_in_hw_params,
+static struct snd_soc_ops omap3pandora_ops = {
+        .hw_params = omap3pandora_hw_params,
 };
 
 /* Digital audio interface glue - connects codec <--> CPU */
@@ -246,14 +226,14 @@ static struct snd_soc_dai_link omap3pandora_dai[] = {
                 .stream_name = "HiFi Out",
                 .cpu_dai = &omap_mcbsp_dai[0],
                 .codec_dai = &twl4030_dai[TWL4030_DAI_HIFI],
-                .ops = &omap3pandora_out_ops,
+                .ops = &omap3pandora_ops,
                 .init = omap3pandora_out_init,
         }, {
                 .name = "TWL4030",
                 .stream_name = "Line/Mic In",
                 .cpu_dai = &omap_mcbsp_dai[1],
                 .codec_dai = &twl4030_dai[TWL4030_DAI_HIFI],
-                .ops = &omap3pandora_in_ops,
+                .ops = &omap3pandora_ops,
                 .init = omap3pandora_in_init,
         }
 };
diff --git a/sound/soc/omap/rx51.c b/sound/soc/omap/rx51.c
index 47d831ef2dbb..88052d29617f 100644
--- a/sound/soc/omap/rx51.c
+++ b/sound/soc/omap/rx51.c
@@ -27,6 +27,7 @@
 #include <linux/gpio.h>
 #include <linux/platform_device.h>
 #include <sound/core.h>
+#include <sound/jack.h>
 #include <sound/pcm.h>
 #include <sound/soc.h>
 #include <sound/soc-dapm.h>
@@ -37,14 +38,22 @@
 #include "omap-pcm.h"
 #include "../codecs/tlv320aic3x.h"
 
+#define RX51_TVOUT_SEL_GPIO             40
+#define RX51_JACK_DETECT_GPIO           177
 /*
  * REVISIT: TWL4030 GPIO base in RX-51. Now statically defined to 192. This
  * gpio is reserved in arch/arm/mach-omap2/board-rx51-peripherals.c
  */
 #define RX51_SPEAKER_AMP_TWL_GPIO       (192 + 7)
 
+enum {
+        RX51_JACK_DISABLED,
+        RX51_JACK_TVOUT,                /* tv-out */
+};
+
 static int rx51_spk_func;
 static int rx51_dmic_func;
+static int rx51_jack_func;
 
 static void rx51_ext_control(struct snd_soc_codec *codec)
 {
@@ -57,6 +66,9 @@ static void rx51_ext_control(struct snd_soc_codec *codec)
         else
                 snd_soc_dapm_disable_pin(codec, "DMic");
 
+        gpio_set_value(RX51_TVOUT_SEL_GPIO,
+                       rx51_jack_func == RX51_JACK_TVOUT);
+
         snd_soc_dapm_sync(codec);
 }
 
@@ -162,6 +174,40 @@ static int rx51_set_input(struct snd_kcontrol *kcontrol,
         return 1;
 }
 
+static int rx51_get_jack(struct snd_kcontrol *kcontrol,
+                         struct snd_ctl_elem_value *ucontrol)
+{
+        ucontrol->value.integer.value[0] = rx51_jack_func;
+
+        return 0;
+}
+
+static int rx51_set_jack(struct snd_kcontrol *kcontrol,
+                         struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+
+        if (rx51_jack_func == ucontrol->value.integer.value[0])
+                return 0;
+
+        rx51_jack_func = ucontrol->value.integer.value[0];
+        rx51_ext_control(codec);
+
+        return 1;
+}
+
+static struct snd_soc_jack rx51_av_jack;
+
+static struct snd_soc_jack_gpio rx51_av_jack_gpios[] = {
+        {
+                .gpio = RX51_JACK_DETECT_GPIO,
+                .name = "avdet-gpio",
+                .report = SND_JACK_VIDEOOUT,
+                .invert = 1,
+                .debounce_time = 200,
+        },
+};
+
 static const struct snd_soc_dapm_widget aic34_dapm_widgets[] = {
         SND_SOC_DAPM_SPK("Ext Spk", rx51_spk_event),
         SND_SOC_DAPM_MIC("DMic", NULL),
@@ -177,10 +223,12 @@ static const struct snd_soc_dapm_route audio_map[] = {
 
 static const char *spk_function[] = {"Off", "On"};
 static const char *input_function[] = {"ADC", "Digital Mic"};
+static const char *jack_function[] = {"Off", "TV-OUT"};
 
 static const struct soc_enum rx51_enum[] = {
         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(spk_function), spk_function),
         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(input_function), input_function),
+        SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(jack_function), jack_function),
 };
 
 static const struct snd_kcontrol_new aic34_rx51_controls[] = {
@@ -188,10 +236,13 @@ static const struct snd_kcontrol_new aic34_rx51_controls[] = {
                      rx51_get_spk, rx51_set_spk),
         SOC_ENUM_EXT("Input Select",  rx51_enum[1],
                      rx51_get_input, rx51_set_input),
+        SOC_ENUM_EXT("Jack Function", rx51_enum[2],
+                     rx51_get_jack, rx51_set_jack),
 };
 
 static int rx51_aic34_init(struct snd_soc_codec *codec)
 {
+        struct snd_soc_card *card = codec->socdev->card;
         int err;
 
         /* Set up NC codec pins */
@@ -214,7 +265,16 @@ static int rx51_aic34_init(struct snd_soc_codec *codec)
 
         snd_soc_dapm_sync(codec);
 
-        return 0;
+        /* AV jack detection */
+        err = snd_soc_jack_new(card, "AV Jack",
+                               SND_JACK_VIDEOOUT, &rx51_av_jack);
+        if (err)
+                return err;
+        err = snd_soc_jack_add_gpios(&rx51_av_jack,
+                                     ARRAY_SIZE(rx51_av_jack_gpios),
+                                     rx51_av_jack_gpios);
+
+        return err;
 }
 
 /* Digital audio interface glue - connects codec <--> CPU */
@@ -259,6 +319,11 @@ static int __init rx51_soc_init(void)
         if (!machine_is_nokia_rx51())
                 return -ENODEV;
 
+        err = gpio_request(RX51_TVOUT_SEL_GPIO, "tvout_sel");
+        if (err)
+                goto err_gpio_tvout_sel;
+        gpio_direction_output(RX51_TVOUT_SEL_GPIO, 0);
+
         rx51_snd_device = platform_device_alloc("soc-audio", -1);
         if (!rx51_snd_device) {
                 err = -ENOMEM;
@@ -277,13 +342,19 @@ static int __init rx51_soc_init(void)
 err2:
         platform_device_put(rx51_snd_device);
 err1:
+        gpio_free(RX51_TVOUT_SEL_GPIO);
+err_gpio_tvout_sel:
 
         return err;
 }
 
 static void __exit rx51_soc_exit(void)
 {
+        snd_soc_jack_free_gpios(&rx51_av_jack, ARRAY_SIZE(rx51_av_jack_gpios),
+                                rx51_av_jack_gpios);
+
         platform_device_unregister(rx51_snd_device);
+        gpio_free(RX51_TVOUT_SEL_GPIO);
 }
 
 module_init(rx51_soc_init);
diff --git a/sound/soc/s3c24xx/Kconfig b/sound/soc/s3c24xx/Kconfig
index 2a7cc222d098..213963ac3c28 100644
--- a/sound/soc/s3c24xx/Kconfig
+++ b/sound/soc/s3c24xx/Kconfig
@@ -1,6 +1,6 @@
 config SND_S3C24XX_SOC
         tristate "SoC Audio for the Samsung S3CXXXX chips"
-        depends on ARCH_S3C2410 || ARCH_S3C64XX
+        depends on ARCH_S3C2410 || ARCH_S3C64XX || ARCH_S5PC100 || ARCH_S5PV210
         select S3C64XX_DMA if ARCH_S3C64XX
         help
           Say Y or M if you want to add support for codecs attached to
@@ -120,8 +120,14 @@ config SND_S3C24XX_SOC_SIMTEC_HERMES
 
 config SND_SOC_SMDK_WM9713
         tristate "SoC AC97 Audio support for SMDK with WM9713"
-        depends on SND_S3C24XX_SOC && MACH_SMDK6410
+        depends on SND_S3C24XX_SOC && (MACH_SMDK6410 || MACH_SMDKC100 || MACH_SMDKV210 || MACH_SMDKC110)
         select SND_SOC_WM9713
         select SND_S3C_SOC_AC97
         help
           Sat Y if you want to add support for SoC audio on the SMDK.
+
+config SND_S3C64XX_SOC_SMARTQ
+        tristate "SoC I2S Audio support for SmartQ board"
+        depends on SND_S3C24XX_SOC && MACH_SMARTQ
+        select SND_S3C64XX_SOC_I2S
+        select SND_SOC_WM8750
diff --git a/sound/soc/s3c24xx/Makefile b/sound/soc/s3c24xx/Makefile
index 81d8dc503f87..50172c385d90 100644
--- a/sound/soc/s3c24xx/Makefile
+++ b/sound/soc/s3c24xx/Makefile
@@ -29,6 +29,7 @@ snd-soc-s3c24xx-simtec-hermes-objs := s3c24xx_simtec_hermes.o
 snd-soc-s3c24xx-simtec-tlv320aic23-objs := s3c24xx_simtec_tlv320aic23.o
 snd-soc-smdk64xx-wm8580-objs := smdk64xx_wm8580.o
 snd-soc-smdk-wm9713-objs := smdk_wm9713.o
+snd-soc-s3c64xx-smartq-wm8987-objs := smartq_wm8987.o
 
 obj-$(CONFIG_SND_S3C24XX_SOC_JIVE_WM8750) += snd-soc-jive-wm8750.o
 obj-$(CONFIG_SND_S3C24XX_SOC_NEO1973_WM8753) += snd-soc-neo1973-wm8753.o
@@ -41,3 +42,4 @@ obj-$(CONFIG_SND_S3C24XX_SOC_SIMTEC_HERMES) += snd-soc-s3c24xx-simtec-hermes.o
 obj-$(CONFIG_SND_S3C24XX_SOC_SIMTEC_TLV320AIC23) += snd-soc-s3c24xx-simtec-tlv320aic23.o
 obj-$(CONFIG_SND_S3C64XX_SOC_WM8580) += snd-soc-smdk64xx-wm8580.o
 obj-$(CONFIG_SND_SOC_SMDK_WM9713) += snd-soc-smdk-wm9713.o
+obj-$(CONFIG_SND_S3C64XX_SOC_SMARTQ) += snd-soc-s3c64xx-smartq-wm8987.o
diff --git a/sound/soc/s3c24xx/s3c-ac97.c b/sound/soc/s3c24xx/s3c-ac97.c
index ecf4fd04ae96..31f6d45b6384 100644
--- a/sound/soc/s3c24xx/s3c-ac97.c
+++ b/sound/soc/s3c24xx/s3c-ac97.c
@@ -31,7 +31,6 @@
 #define AC_CMD_DATA(x) (x & 0xffff)
 
 struct s3c_ac97_info {
-        unsigned           state;
         struct clk         *ac97_clk;
         void __iomem       *regs;
         struct mutex       lock;
diff --git a/sound/soc/s3c24xx/s3c-dma.c b/sound/soc/s3c24xx/s3c-dma.c
index 1b61c23ff300..f1b1bc4bacfb 100644
--- a/sound/soc/s3c24xx/s3c-dma.c
+++ b/sound/soc/s3c24xx/s3c-dma.c
@@ -94,8 +94,7 @@ static void s3c_dma_enqueue(struct snd_pcm_substream *substream)
 
                 if ((pos + len) > prtd->dma_end) {
                         len  = prtd->dma_end - pos;
-                        pr_debug(KERN_DEBUG "%s: corrected dma len %ld\n",
-                               __func__, len);
+                        pr_debug("%s: corrected dma len %ld\n", __func__, len);
                 }
 
                 ret = s3c2410_dma_enqueue(prtd->params->channel,
diff --git a/sound/soc/s3c24xx/s3c-i2s-v2.c b/sound/soc/s3c24xx/s3c-i2s-v2.c
index 13311c8cf965..64376b2aac73 100644
--- a/sound/soc/s3c24xx/s3c-i2s-v2.c
+++ b/sound/soc/s3c24xx/s3c-i2s-v2.c
@@ -32,7 +32,8 @@
 
 #undef S3C_IIS_V2_SUPPORTED
 
-#if defined(CONFIG_CPU_S3C2412) || defined(CONFIG_CPU_S3C2413)
+#if defined(CONFIG_CPU_S3C2412) || defined(CONFIG_CPU_S3C2413) \
+        || defined(CONFIG_CPU_S5PV210)
 #define S3C_IIS_V2_SUPPORTED
 #endif
 
diff --git a/sound/soc/s3c24xx/smartq_wm8987.c b/sound/soc/s3c24xx/smartq_wm8987.c
new file mode 100644
index 000000000000..b480348140b0
--- /dev/null
+++ b/sound/soc/s3c24xx/smartq_wm8987.c
@@ -0,0 +1,295 @@
+/* sound/soc/s3c24xx/smartq_wm8987.c
+ *
+ * Copyright 2010 Maurus Cuelenaere <mcuelenaere@gmail.com>
+ *
+ * Based on smdk6410_wm8987.c
+ *     Copyright 2007 Wolfson Microelectronics PLC. - linux@wolfsonmicro.com
+ *     Graeme Gregory - graeme.gregory@wolfsonmicro.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 <linux/platform_device.h>
+#include <linux/gpio.h>
+
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/soc-dapm.h>
+#include <sound/jack.h>
+
+#include <asm/mach-types.h>
+
+#include "s3c-dma.h"
+#include "s3c64xx-i2s.h"
+
+#include "../codecs/wm8750.h"
+
+/*
+ * WM8987 is register compatible with WM8750, so using that as base driver.
+ */
+
+static struct snd_soc_card snd_soc_smartq;
+
+static int smartq_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->dai->codec_dai;
+        struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
+        struct s3c_i2sv2_rate_calc div;
+        unsigned int clk = 0;
+        int ret;
+
+        s3c_i2sv2_iis_calc_rate(&div, NULL, params_rate(params),
+                                s3c_i2sv2_get_clock(cpu_dai));
+
+        switch (params_rate(params)) {
+        case 8000:
+        case 16000:
+        case 32000:
+        case 48000:
+        case 96000:
+                clk = 12288000;
+                break;
+        case 11025:
+        case 22050:
+        case 44100:
+        case 88200:
+                clk = 11289600;
+                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;
+
+        /* set the codec system clock for DAC and ADC */
+        ret = snd_soc_dai_set_sysclk(codec_dai, WM8750_SYSCLK, clk,
+                                     SND_SOC_CLOCK_IN);
+        if (ret < 0)
+                return ret;
+
+        /* set MCLK division for sample rate */
+        ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_RCLK, div.fs_div);
+        if (ret < 0)
+                return ret;
+
+        /* set prescaler division for sample rate */
+        ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_PRESCALER,
+                                     div.clk_div - 1);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+/*
+ * SmartQ WM8987 HiFi DAI operations.
+ */
+static struct snd_soc_ops smartq_hifi_ops = {
+        .hw_params = smartq_hifi_hw_params,
+};
+
+static struct snd_soc_jack smartq_jack;
+
+static struct snd_soc_jack_pin smartq_jack_pins[] = {
+        /* Disable speaker when headphone is plugged in */
+        {
+                .pin    = "Internal Speaker",
+                .mask   = SND_JACK_HEADPHONE,
+        },
+};
+
+static struct snd_soc_jack_gpio smartq_jack_gpios[] = {
+        {
+                .gpio           = S3C64XX_GPL(12),
+                .name           = "headphone detect",
+                .report         = SND_JACK_HEADPHONE,
+                .debounce_time  = 200,
+        },
+};
+
+static const struct snd_kcontrol_new wm8987_smartq_controls[] = {
+        SOC_DAPM_PIN_SWITCH("Internal Speaker"),
+        SOC_DAPM_PIN_SWITCH("Headphone Jack"),
+        SOC_DAPM_PIN_SWITCH("Internal Mic"),
+};
+
+static int smartq_speaker_event(struct snd_soc_dapm_widget *w,
+                                struct snd_kcontrol *k,
+                                int event)
+{
+        gpio_set_value(S3C64XX_GPK(12), SND_SOC_DAPM_EVENT_OFF(event));
+
+        return 0;
+}
+
+static const struct snd_soc_dapm_widget wm8987_dapm_widgets[] = {
+        SND_SOC_DAPM_SPK("Internal Speaker", smartq_speaker_event),
+        SND_SOC_DAPM_HP("Headphone Jack", NULL),
+        SND_SOC_DAPM_MIC("Internal Mic", NULL),
+};
+
+static const struct snd_soc_dapm_route audio_map[] = {
+        {"Headphone Jack", NULL, "LOUT2"},
+        {"Headphone Jack", NULL, "ROUT2"},
+
+        {"Internal Speaker", NULL, "LOUT2"},
+        {"Internal Speaker", NULL, "ROUT2"},
+
+        {"Mic Bias", NULL, "Internal Mic"},
+        {"LINPUT2", NULL, "Mic Bias"},
+};
+
+static int smartq_wm8987_init(struct snd_soc_codec *codec)
+{
+        int err = 0;
+
+        /* Add SmartQ specific widgets */
+        snd_soc_dapm_new_controls(codec, wm8987_dapm_widgets,
+                                  ARRAY_SIZE(wm8987_dapm_widgets));
+
+        /* add SmartQ specific controls */
+        err = snd_soc_add_controls(codec, wm8987_smartq_controls,
+                                   ARRAY_SIZE(wm8987_smartq_controls));
+
+        if (err < 0)
+                return err;
+
+        /* setup SmartQ specific audio path */
+        snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
+
+        /* set endpoints to not connected */
+        snd_soc_dapm_nc_pin(codec, "LINPUT1");
+        snd_soc_dapm_nc_pin(codec, "RINPUT1");
+        snd_soc_dapm_nc_pin(codec, "OUT3");
+        snd_soc_dapm_nc_pin(codec, "ROUT1");
+
+        /* set endpoints to default off mode */
+        snd_soc_dapm_enable_pin(codec, "Internal Speaker");
+        snd_soc_dapm_enable_pin(codec, "Internal Mic");
+        snd_soc_dapm_disable_pin(codec, "Headphone Jack");
+
+        err = snd_soc_dapm_sync(codec);
+        if (err)
+                return err;
+
+        /* Headphone jack detection */
+        err = snd_soc_jack_new(&snd_soc_smartq, "Headphone Jack",
+                               SND_JACK_HEADPHONE, &smartq_jack);
+        if (err)
+                return err;
+
+        err = snd_soc_jack_add_pins(&smartq_jack, ARRAY_SIZE(smartq_jack_pins),
+                                    smartq_jack_pins);
+        if (err)
+                return err;
+
+        err = snd_soc_jack_add_gpios(&smartq_jack,
+                                     ARRAY_SIZE(smartq_jack_gpios),
+                                     smartq_jack_gpios);
+
+        return err;
+}
+
+static struct snd_soc_dai_link smartq_dai[] = {
+        {
+                .name           = "wm8987",
+                .stream_name    = "SmartQ Hi-Fi",
+                .cpu_dai        = &s3c64xx_i2s_dai[0],
+                .codec_dai      = &wm8750_dai,
+                .init           = smartq_wm8987_init,
+                .ops            = &smartq_hifi_ops,
+        },
+};
+
+static struct snd_soc_card snd_soc_smartq = {
+        .name = "SmartQ",
+        .platform = &s3c24xx_soc_platform,
+        .dai_link = smartq_dai,
+        .num_links = ARRAY_SIZE(smartq_dai),
+};
+
+static struct snd_soc_device smartq_snd_devdata = {
+        .card = &snd_soc_smartq,
+        .codec_dev = &soc_codec_dev_wm8750,
+};
+
+static struct platform_device *smartq_snd_device;
+
+static int __init smartq_init(void)
+{
+        int ret;
+
+        if (!machine_is_smartq7() && !machine_is_smartq5()) {
+                pr_info("Only SmartQ is supported by this ASoC driver\n");
+                return -ENODEV;
+        }
+
+        smartq_snd_device = platform_device_alloc("soc-audio", -1);
+        if (!smartq_snd_device)
+                return -ENOMEM;
+
+        platform_set_drvdata(smartq_snd_device, &smartq_snd_devdata);
+        smartq_snd_devdata.dev = &smartq_snd_device->dev;
+
+        ret = platform_device_add(smartq_snd_device);
+        if (ret) {
+                platform_device_put(smartq_snd_device);
+                return ret;
+        }
+
+        /* Initialise GPIOs used by amplifiers */
+        ret = gpio_request(S3C64XX_GPK(12), "amplifiers shutdown");
+        if (ret) {
+                dev_err(&smartq_snd_device->dev, "Failed to register GPK12\n");
+                goto err_unregister_device;
+        }
+
+        /* Disable amplifiers */
+        ret = gpio_direction_output(S3C64XX_GPK(12), 1);
+        if (ret) {
+                dev_err(&smartq_snd_device->dev, "Failed to configure GPK12\n");
+                goto err_free_gpio_amp_shut;
+        }
+
+        return 0;
+
+err_free_gpio_amp_shut:
+        gpio_free(S3C64XX_GPK(12));
+err_unregister_device:
+        platform_device_unregister(smartq_snd_device);
+
+        return ret;
+}
+
+static void __exit smartq_exit(void)
+{
+        snd_soc_jack_free_gpios(&smartq_jack, ARRAY_SIZE(smartq_jack_gpios),
+                                smartq_jack_gpios);
+
+        platform_device_unregister(smartq_snd_device);
+}
+
+module_init(smartq_init);
+module_exit(smartq_exit);
+
+/* Module information */
+MODULE_AUTHOR("Maurus Cuelenaere <mcuelenaere@gmail.com>");
+MODULE_DESCRIPTION("ALSA SoC SmartQ WM8987");
+MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/smdk_wm9713.c b/sound/soc/s3c24xx/smdk_wm9713.c
index 24fd39f38ccb..5527b9e88c98 100644
--- a/sound/soc/s3c24xx/smdk_wm9713.c
+++ b/sound/soc/s3c24xx/smdk_wm9713.c
@@ -25,6 +25,9 @@ static struct snd_soc_card smdk;
  * Default CFG switch settings to use this driver:
  *
  *   SMDK6410: Set CFG1 1-3 On, CFG2 1-4 Off
+ *   SMDKC100: Set CFG6 1-3 On, CFG7 1   On
+ *   SMDKC110: Set CFGB10 1-2 Off, CFGB12 1-3 On
+ *   SMDKV210: Set CFGB10 1-2 Off, CFGB12 1-3 On
  */
 
 /*
diff --git a/sound/soc/s6000/s6000-i2s.c b/sound/soc/s6000/s6000-i2s.c
index 5b9ac1759bd2..59e3fa7bcb05 100644
--- a/sound/soc/s6000/s6000-i2s.c
+++ b/sound/soc/s6000/s6000-i2s.c
@@ -451,16 +451,15 @@ static int __devinit s6000_i2s_probe(struct platform_device *pdev)
                 goto err_release_none;
         }
 
-        region = request_mem_region(scbmem->start,
-                                    scbmem->end - scbmem->start + 1,
-                                    pdev->name);
+        region = request_mem_region(scbmem->start, resource_size(scbmem),
+                                                                pdev->name);
         if (!region) {
                 dev_err(&pdev->dev, "I2S SCB region already claimed\n");
                 ret = -EBUSY;
                 goto err_release_none;
         }
 
-        mmio = ioremap(scbmem->start, scbmem->end - scbmem->start + 1);
+        mmio = ioremap(scbmem->start, resource_size(scbmem));
         if (!mmio) {
                 dev_err(&pdev->dev, "can't ioremap SCB region\n");
                 ret = -ENOMEM;
@@ -474,9 +473,8 @@ static int __devinit s6000_i2s_probe(struct platform_device *pdev)
                 goto err_release_map;
         }
 
-        region = request_mem_region(sifmem->start,
-                                    sifmem->end - sifmem->start + 1,
-                                    pdev->name);
+        region = request_mem_region(sifmem->start, resource_size(sifmem),
+                                                                pdev->name);
         if (!region) {
                 dev_err(&pdev->dev, "I2S SIF region already claimed\n");
                 ret = -EBUSY;
@@ -490,8 +488,8 @@ static int __devinit s6000_i2s_probe(struct platform_device *pdev)
                 goto err_release_sif;
         }
 
-        region = request_mem_region(dma1->start, dma1->end - dma1->start + 1,
-                                    pdev->name);
+        region = request_mem_region(dma1->start, resource_size(dma1),
+                                                                pdev->name);
         if (!region) {
                 dev_err(&pdev->dev, "I2S DMA region already claimed\n");
                 ret = -EBUSY;
@@ -500,9 +498,8 @@ static int __devinit s6000_i2s_probe(struct platform_device *pdev)
 
         dma2 = platform_get_resource(pdev, IORESOURCE_DMA, 1);
         if (dma2) {
-                region = request_mem_region(dma2->start,
-                                            dma2->end - dma2->start + 1,
-                                            pdev->name);
+                region = request_mem_region(dma2->start, resource_size(dma2),
+                                                                pdev->name);
                 if (!region) {
                         dev_err(&pdev->dev,
                                 "I2S DMA region already claimed\n");
@@ -561,15 +558,15 @@ err_release_dev:
         kfree(dev);
 err_release_dma2:
         if (dma2)
-                release_mem_region(dma2->start, dma2->end - dma2->start + 1);
+                release_mem_region(dma2->start, resource_size(dma2));
 err_release_dma1:
-        release_mem_region(dma1->start, dma1->end - dma1->start + 1);
+        release_mem_region(dma1->start, resource_size(dma1));
 err_release_sif:
-        release_mem_region(sifmem->start, (sifmem->end - sifmem->start) + 1);
+        release_mem_region(sifmem->start, resource_size(sifmem));
 err_release_map:
         iounmap(mmio);
 err_release_scb:
-        release_mem_region(scbmem->start, (scbmem->end - scbmem->start) + 1);
+        release_mem_region(scbmem->start, resource_size(scbmem));
 err_release_none:
         return ret;
 }
@@ -590,19 +587,18 @@ static void __devexit s6000_i2s_remove(struct platform_device *pdev)
         kfree(dev);
 
         region = platform_get_resource(pdev, IORESOURCE_DMA, 0);
-        release_mem_region(region->start, region->end - region->start + 1);
+        release_mem_region(region->start, resource_size(region));
 
         region = platform_get_resource(pdev, IORESOURCE_DMA, 1);
         if (region)
-                release_mem_region(region->start,
-                                   region->end - region->start + 1);
+                release_mem_region(region->start, resource_size(region));
 
         region = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(region->start, (region->end - region->start) + 1);
+        release_mem_region(region->start, resource_size(region));
 
         iounmap(mmio);
         region = platform_get_resource(pdev, IORESOURCE_IO, 0);
-        release_mem_region(region->start, (region->end - region->start) + 1);
+        release_mem_region(region->start, resource_size(region));
 }
 
 static struct platform_driver s6000_i2s_driver = {
diff --git a/sound/soc/sh/Kconfig b/sound/soc/sh/Kconfig
index a1d14bc3c76f..52d7e8ed9c1f 100644
--- a/sound/soc/sh/Kconfig
+++ b/sound/soc/sh/Kconfig
@@ -48,7 +48,7 @@ config SND_SH7760_AC97
 
 config SND_FSI_AK4642
         bool "FSI-AK4642 sound support"
-        depends on SND_SOC_SH4_FSI
+        depends on SND_SOC_SH4_FSI && I2C_SH_MOBILE
         select SND_SOC_AK4642
         help
           This option enables generic sound support for the
@@ -56,7 +56,7 @@ config SND_FSI_AK4642
 
 config SND_FSI_DA7210
         bool "FSI-DA7210 sound support"
-        depends on SND_SOC_SH4_FSI
+        depends on SND_SOC_SH4_FSI && I2C_SH_MOBILE
         select SND_SOC_DA7210
         help
           This option enables generic sound support for the
diff --git a/sound/soc/sh/fsi-ak4642.c b/sound/soc/sh/fsi-ak4642.c
index be018542314e..dad575a22622 100644
--- a/sound/soc/sh/fsi-ak4642.c
+++ b/sound/soc/sh/fsi-ak4642.c
@@ -9,16 +9,7 @@
  * for more details.
  */
 
-#include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/platform_device.h>
-#include <linux/i2c.h>
-#include <linux/io.h>
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/soc.h>
-#include <sound/soc-dapm.h>
-
 #include <sound/sh_fsi.h>
 #include <../sound/soc/codecs/ak4642.h>
 
@@ -38,7 +29,7 @@ static int fsi_ak4642_dai_init(struct snd_soc_codec *codec)
 static struct snd_soc_dai_link fsi_dai_link = {
         .name           = "AK4642",
         .stream_name    = "AK4642",
-        .cpu_dai        = &fsi_soc_dai[0], /* fsi */
+        .cpu_dai        = &fsi_soc_dai[FSI_PORT_A],
         .codec_dai      = &ak4642_dai,
         .init           = fsi_ak4642_dai_init,
         .ops            = NULL,
@@ -62,7 +53,7 @@ static int __init fsi_ak4642_init(void)
 {
         int ret = -ENOMEM;
 
-        fsi_snd_device = platform_device_alloc("soc-audio", -1);
+        fsi_snd_device = platform_device_alloc("soc-audio", FSI_PORT_A);
         if (!fsi_snd_device)
                 goto out;
 
diff --git a/sound/soc/sh/fsi-da7210.c b/sound/soc/sh/fsi-da7210.c
index 33b4d177f466..121bbb07bb03 100644
--- a/sound/soc/sh/fsi-da7210.c
+++ b/sound/soc/sh/fsi-da7210.c
@@ -10,16 +10,7 @@
  *  option) any later version.
  */
 
-#include <linux/interrupt.h>
 #include <linux/platform_device.h>
-#include <linux/io.h>
-#include <linux/i2c.h>
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/pcm_params.h>
-#include <sound/soc.h>
-#include <sound/soc-dapm.h>
-
 #include <sound/sh_fsi.h>
 #include "../codecs/da7210.h"
 
@@ -33,7 +24,7 @@ static int fsi_da7210_init(struct snd_soc_codec *codec)
 static struct snd_soc_dai_link fsi_da7210_dai = {
         .name           = "DA7210",
         .stream_name    = "DA7210",
-        .cpu_dai        = &fsi_soc_dai[1], /* FSI B */
+        .cpu_dai        = &fsi_soc_dai[FSI_PORT_B],
         .codec_dai      = &da7210_dai,
         .init           = fsi_da7210_init,
 };
@@ -56,7 +47,7 @@ static int __init fsi_da7210_sound_init(void)
 {
         int ret;
 
-        fsi_da7210_snd_device = platform_device_alloc("soc-audio", -1);
+        fsi_da7210_snd_device = platform_device_alloc("soc-audio", FSI_PORT_B);
         if (!fsi_da7210_snd_device)
                 return -ENOMEM;
 
diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c
index ec4acac49ebd..58c6bec642de 100644
--- a/sound/soc/sh/fsi.c
+++ b/sound/soc/sh/fsi.c
@@ -12,21 +12,12 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
 #include <linux/delay.h>
-#include <linux/list.h>
 #include <linux/pm_runtime.h>
 #include <linux/io.h>
 #include <linux/slab.h>
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/initval.h>
 #include <sound/soc.h>
-#include <sound/pcm_params.h>
 #include <sound/sh_fsi.h>
-#include <asm/atomic.h>
 
 #define DO_FMT          0x0000
 #define DOFF_CTL        0x0004
@@ -39,9 +30,11 @@
 #define DIDT            0x0020
 #define DODT            0x0024
 #define MUTE_ST         0x0028
-#define REG_END         MUTE_ST
-
+#define OUT_SEL         0x0030
+#define REG_END         OUT_SEL
 
+#define A_MST_CTLR      0x0180
+#define B_MST_CTLR      0x01A0
 #define CPU_INT_ST      0x01F4
 #define CPU_IEMSK       0x01F8
 #define CPU_IMSK        0x01FC
@@ -52,18 +45,18 @@
 #define CLK_RST         0x0210
 #define SOFT_RST        0x0214
 #define FIFO_SZ         0x0218
-#define MREG_START      CPU_INT_ST
+#define MREG_START      A_MST_CTLR
 #define MREG_END        FIFO_SZ
 
 /* DO_FMT */
 /* DI_FMT */
-#define CR_FMT(param) ((param) << 4)
-# define CR_MONO        0x0
-# define CR_MONO_D      0x1
-# define CR_PCM         0x2
-# define CR_I2S         0x3
-# define CR_TDM         0x4
-# define CR_TDM_D       0x5
+#define CR_MONO         (0x0 << 4)
+#define CR_MONO_D       (0x1 << 4)
+#define CR_PCM          (0x2 << 4)
+#define CR_I2S          (0x3 << 4)
+#define CR_TDM          (0x4 << 4)
+#define CR_TDM_D        (0x5 << 4)
+#define CR_SPDIF        0x00100120
 
 /* DOFF_CTL */
 /* DIFF_CTL */
@@ -75,6 +68,14 @@
 #define ERR_UNDER       0x00000001
 #define ST_ERR          (ERR_OVER | ERR_UNDER)
 
+/* CKG1 */
+#define ACKMD_MASK      0x00007000
+#define BPFMD_MASK      0x00000700
+
+/* A/B MST_CTLR */
+#define BP      (1 << 4)        /* Fix the signal of Biphase output */
+#define SE      (1 << 0)        /* Fix the master clock */
+
 /* CLK_RST */
 #define B_CLK           0x00000010
 #define A_CLK           0x00000001
@@ -119,9 +120,13 @@ struct fsi_priv {
         int period_len;
         int buffer_len;
         int periods;
+
+        u32 mst_ctrl;
 };
 
-struct fsi_regs {
+struct fsi_core {
+        int ver;
+
         u32 int_st;
         u32 iemsk;
         u32 imsk;
@@ -132,7 +137,7 @@ struct fsi_master {
         int irq;
         struct fsi_priv fsia;
         struct fsi_priv fsib;
-        struct fsi_regs *regs;
+        struct fsi_core *core;
         struct sh_fsi_platform_info *info;
         spinlock_t lock;
 };
@@ -169,24 +174,30 @@ static void __fsi_reg_mask_set(u32 reg, u32 mask, u32 data)
 
 static void fsi_reg_write(struct fsi_priv *fsi, u32 reg, u32 data)
 {
-        if (reg > REG_END)
+        if (reg > REG_END) {
+                pr_err("fsi: register access err (%s)\n", __func__);
                 return;
+        }
 
         __fsi_reg_write((u32)(fsi->base + reg), data);
 }
 
 static u32 fsi_reg_read(struct fsi_priv *fsi, u32 reg)
 {
-        if (reg > REG_END)
+        if (reg > REG_END) {
+                pr_err("fsi: register access err (%s)\n", __func__);
                 return 0;
+        }
 
         return __fsi_reg_read((u32)(fsi->base + reg));
 }
 
 static void fsi_reg_mask_set(struct fsi_priv *fsi, u32 reg, u32 mask, u32 data)
 {
-        if (reg > REG_END)
+        if (reg > REG_END) {
+                pr_err("fsi: register access err (%s)\n", __func__);
                 return;
+        }
 
         __fsi_reg_mask_set((u32)(fsi->base + reg), mask, data);
 }
@@ -196,8 +207,10 @@ static void fsi_master_write(struct fsi_master *master, u32 reg, u32 data)
         unsigned long flags;
 
         if ((reg < MREG_START) ||
-            (reg > MREG_END))
+            (reg > MREG_END)) {
+                pr_err("fsi: register access err (%s)\n", __func__);
                 return;
+        }
 
         spin_lock_irqsave(&master->lock, flags);
         __fsi_reg_write((u32)(master->base + reg), data);
@@ -210,8 +223,10 @@ static u32 fsi_master_read(struct fsi_master *master, u32 reg)
         unsigned long flags;
 
         if ((reg < MREG_START) ||
-            (reg > MREG_END))
+            (reg > MREG_END)) {
+                pr_err("fsi: register access err (%s)\n", __func__);
                 return 0;
+        }
 
         spin_lock_irqsave(&master->lock, flags);
         ret = __fsi_reg_read((u32)(master->base + reg));
@@ -226,8 +241,10 @@ static void fsi_master_mask_set(struct fsi_master *master,
         unsigned long flags;
 
         if ((reg < MREG_START) ||
-            (reg > MREG_END))
+            (reg > MREG_END)) {
+                pr_err("fsi: register access err (%s)\n", __func__);
                 return;
+        }
 
         spin_lock_irqsave(&master->lock, flags);
         __fsi_reg_mask_set((u32)(master->base + reg), mask, data);
@@ -349,8 +366,8 @@ static void fsi_irq_enable(struct fsi_priv *fsi, int is_play)
         u32 data = fsi_port_ab_io_bit(fsi, is_play);
         struct fsi_master *master = fsi_get_master(fsi);
 
-        fsi_master_mask_set(master, master->regs->imsk,  data, data);
-        fsi_master_mask_set(master, master->regs->iemsk, data, data);
+        fsi_master_mask_set(master, master->core->imsk,  data, data);
+        fsi_master_mask_set(master, master->core->iemsk, data, data);
 }
 
 static void fsi_irq_disable(struct fsi_priv *fsi, int is_play)
@@ -358,18 +375,18 @@ static void fsi_irq_disable(struct fsi_priv *fsi, int is_play)
         u32 data = fsi_port_ab_io_bit(fsi, is_play);
         struct fsi_master *master = fsi_get_master(fsi);
 
-        fsi_master_mask_set(master, master->regs->imsk,  data, 0);
-        fsi_master_mask_set(master, master->regs->iemsk, data, 0);
+        fsi_master_mask_set(master, master->core->imsk,  data, 0);
+        fsi_master_mask_set(master, master->core->iemsk, data, 0);
 }
 
 static u32 fsi_irq_get_status(struct fsi_master *master)
 {
-        return fsi_master_read(master, master->regs->int_st);
+        return fsi_master_read(master, master->core->int_st);
 }
 
 static void fsi_irq_clear_all_status(struct fsi_master *master)
 {
-        fsi_master_write(master, master->regs->int_st, 0x0000000);
+        fsi_master_write(master, master->core->int_st, 0);
 }
 
 static void fsi_irq_clear_status(struct fsi_priv *fsi)
@@ -381,7 +398,30 @@ static void fsi_irq_clear_status(struct fsi_priv *fsi)
         data |= fsi_port_ab_io_bit(fsi, 1);
 
         /* clear interrupt factor */
-        fsi_master_mask_set(master, master->regs->int_st, data, 0);
+        fsi_master_mask_set(master, master->core->int_st, data, 0);
+}
+
+/************************************************************************
+
+
+                SPDIF master clock function
+
+These functions are used later FSI2
+************************************************************************/
+static void fsi_spdif_clk_ctrl(struct fsi_priv *fsi, int enable)
+{
+        struct fsi_master *master = fsi_get_master(fsi);
+        u32 val = BP | SE;
+
+        if (master->core->ver < 2) {
+                pr_err("fsi: register access err (%s)\n", __func__);
+                return;
+        }
+
+        if (enable)
+                fsi_master_mask_set(master, fsi->mst_ctrl, val, val);
+        else
+                fsi_master_mask_set(master, fsi->mst_ctrl, val, 0);
 }
 
 /************************************************************************
@@ -662,8 +702,8 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream,
                            struct snd_soc_dai *dai)
 {
         struct fsi_priv *fsi = fsi_get_priv(substream);
-        const char *msg;
         u32 flags = fsi_get_info_flags(fsi);
+        struct fsi_master *master = fsi_get_master(fsi);
         u32 fmt;
         u32 reg;
         u32 data;
@@ -700,36 +740,40 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream,
         fmt = is_play ? SH_FSI_GET_OFMT(flags) : SH_FSI_GET_IFMT(flags);
         switch (fmt) {
         case SH_FSI_FMT_MONO:
-                msg = "MONO";
-                data = CR_FMT(CR_MONO);
+                data = CR_MONO;
                 fsi->chan = 1;
                 break;
         case SH_FSI_FMT_MONO_DELAY:
-                msg = "MONO Delay";
-                data = CR_FMT(CR_MONO_D);
+                data = CR_MONO_D;
                 fsi->chan = 1;
                 break;
         case SH_FSI_FMT_PCM:
-                msg = "PCM";
-                data = CR_FMT(CR_PCM);
+                data = CR_PCM;
                 fsi->chan = 2;
                 break;
         case SH_FSI_FMT_I2S:
-                msg = "I2S";
-                data = CR_FMT(CR_I2S);
+                data = CR_I2S;
                 fsi->chan = 2;
                 break;
         case SH_FSI_FMT_TDM:
-                msg = "TDM";
                 fsi->chan = is_play ?
                         SH_FSI_GET_CH_O(flags) : SH_FSI_GET_CH_I(flags);
-                data = CR_FMT(CR_TDM) | (fsi->chan - 1);
+                data = CR_TDM | (fsi->chan - 1);
                 break;
         case SH_FSI_FMT_TDM_DELAY:
-                msg = "TDM Delay";
                 fsi->chan = is_play ?
                         SH_FSI_GET_CH_O(flags) : SH_FSI_GET_CH_I(flags);
-                data = CR_FMT(CR_TDM_D) | (fsi->chan - 1);
+                data = CR_TDM_D | (fsi->chan - 1);
+                break;
+        case SH_FSI_FMT_SPDIF:
+                if (master->core->ver < 2) {
+                        dev_err(dai->dev, "This FSI can not use SPDIF\n");
+                        return -EINVAL;
+                }
+                data = CR_SPDIF;
+                fsi->chan = 2;
+                fsi_spdif_clk_ctrl(fsi, 1);
+                fsi_reg_mask_set(fsi, OUT_SEL, 0x0010, 0x0010);
                 break;
         default:
                 dev_err(dai->dev, "unknown format.\n");
@@ -737,12 +781,6 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream,
         }
         fsi_reg_write(fsi, reg, data);
 
-        /*
-         * clear clk reset if master mode
-         */
-        if (is_master)
-                fsi_clk_ctrl(fsi, 1);
-
         /* irq clear */
         fsi_irq_disable(fsi, is_play);
         fsi_irq_clear_status(fsi);
@@ -789,10 +827,93 @@ static int fsi_dai_trigger(struct snd_pcm_substream *substream, int cmd,
         return ret;
 }
 
+static int fsi_dai_hw_params(struct snd_pcm_substream *substream,
+                             struct snd_pcm_hw_params *params,
+                             struct snd_soc_dai *dai)
+{
+        struct fsi_priv *fsi = fsi_get_priv(substream);
+        struct fsi_master *master = fsi_get_master(fsi);
+        int (*set_rate)(int is_porta, int rate) = master->info->set_rate;
+        int fsi_ver = master->core->ver;
+        int is_play = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
+        int ret;
+
+        /* if slave mode, set_rate is not needed */
+        if (!fsi_is_master_mode(fsi, is_play))
+                return 0;
+
+        /* it is error if no set_rate */
+        if (!set_rate)
+                return -EIO;
+
+        ret = set_rate(fsi_is_port_a(fsi), params_rate(params));
+        if (ret > 0) {
+                u32 data = 0;
+
+                switch (ret & SH_FSI_ACKMD_MASK) {
+                default:
+                        /* FALL THROUGH */
+                case SH_FSI_ACKMD_512:
+                        data |= (0x0 << 12);
+                        break;
+                case SH_FSI_ACKMD_256:
+                        data |= (0x1 << 12);
+                        break;
+                case SH_FSI_ACKMD_128:
+                        data |= (0x2 << 12);
+                        break;
+                case SH_FSI_ACKMD_64:
+                        data |= (0x3 << 12);
+                        break;
+                case SH_FSI_ACKMD_32:
+                        if (fsi_ver < 2)
+                                dev_err(dai->dev, "unsupported ACKMD\n");
+                        else
+                                data |= (0x4 << 12);
+                        break;
+                }
+
+                switch (ret & SH_FSI_BPFMD_MASK) {
+                default:
+                        /* FALL THROUGH */
+                case SH_FSI_BPFMD_32:
+                        data |= (0x0 << 8);
+                        break;
+                case SH_FSI_BPFMD_64:
+                        data |= (0x1 << 8);
+                        break;
+                case SH_FSI_BPFMD_128:
+                        data |= (0x2 << 8);
+                        break;
+                case SH_FSI_BPFMD_256:
+                        data |= (0x3 << 8);
+                        break;
+                case SH_FSI_BPFMD_512:
+                        data |= (0x4 << 8);
+                        break;
+                case SH_FSI_BPFMD_16:
+                        if (fsi_ver < 2)
+                                dev_err(dai->dev, "unsupported ACKMD\n");
+                        else
+                                data |= (0x7 << 8);
+                        break;
+                }
+
+                fsi_reg_mask_set(fsi, CKG1, (ACKMD_MASK | BPFMD_MASK) , data);
+                udelay(10);
+                fsi_clk_ctrl(fsi, 1);
+                ret = 0;
+        }
+
+        return ret;
+
+}
+
 static struct snd_soc_dai_ops fsi_dai_ops = {
         .startup        = fsi_dai_startup,
         .shutdown       = fsi_dai_shutdown,
         .trigger        = fsi_dai_trigger,
+        .hw_params      = fsi_dai_hw_params,
 };
 
 /************************************************************************
@@ -965,11 +1086,6 @@ static int fsi_probe(struct platform_device *pdev)
         unsigned int irq;
         int ret;
 
-        if (0 != pdev->id) {
-                dev_err(&pdev->dev, "current fsi support id 0 only now\n");
-                return -ENODEV;
-        }
-
         id_entry = pdev->id_entry;
         if (!id_entry) {
                 dev_err(&pdev->dev, "unknown fsi device\n");
@@ -998,14 +1114,21 @@ static int fsi_probe(struct platform_device *pdev)
                 goto exit_kfree;
         }
 
+        /* master setting */
         master->irq             = irq;
         master->info            = pdev->dev.platform_data;
+        master->core            = (struct fsi_core *)id_entry->driver_data;
+        spin_lock_init(&master->lock);
+
+        /* FSI A setting */
         master->fsia.base       = master->base;
         master->fsia.master     = master;
+        master->fsia.mst_ctrl   = A_MST_CTLR;
+
+        /* FSI B setting */
         master->fsib.base       = master->base + 0x40;
         master->fsib.master     = master;
-        master->regs            = (struct fsi_regs *)id_entry->driver_data;
-        spin_lock_init(&master->lock);
+        master->fsib.mst_ctrl   = B_MST_CTLR;
 
         pm_runtime_enable(&pdev->dev);
         pm_runtime_resume(&pdev->dev);
@@ -1085,21 +1208,27 @@ static struct dev_pm_ops fsi_pm_ops = {
         .runtime_resume         = fsi_runtime_nop,
 };
 
-static struct fsi_regs fsi_regs = {
+static struct fsi_core fsi1_core = {
+        .ver    = 1,
+
+        /* Interrupt */
         .int_st = INT_ST,
         .iemsk  = IEMSK,
         .imsk   = IMSK,
 };
 
-static struct fsi_regs fsi2_regs = {
+static struct fsi_core fsi2_core = {
+        .ver    = 2,
+
+        /* Interrupt */
         .int_st = CPU_INT_ST,
         .iemsk  = CPU_IEMSK,
         .imsk   = CPU_IMSK,
 };
 
 static struct platform_device_id fsi_id_table[] = {
-        { "sh_fsi",     (kernel_ulong_t)&fsi_regs },
-        { "sh_fsi2",    (kernel_ulong_t)&fsi2_regs },
+        { "sh_fsi",     (kernel_ulong_t)&fsi1_core },
+        { "sh_fsi2",    (kernel_ulong_t)&fsi2_core },
 };
 
 static struct platform_driver fsi_driver = {
diff --git a/sound/soc/soc-cache.c b/sound/soc/soc-cache.c
index 472af38188c1..adbc68ce9050 100644
--- a/sound/soc/soc-cache.c
+++ b/sound/soc/soc-cache.c
@@ -340,7 +340,7 @@ static unsigned int snd_soc_16_8_read_i2c(struct snd_soc_codec *codec,
 static unsigned int snd_soc_16_8_read(struct snd_soc_codec *codec,
                                      unsigned int reg)
 {
-        u16 *cache = codec->reg_cache;
+        u8 *cache = codec->reg_cache;
 
         reg &= 0xff;
         if (reg >= codec->reg_cache_size)
@@ -351,7 +351,7 @@ static unsigned int snd_soc_16_8_read(struct snd_soc_codec *codec,
 static int snd_soc_16_8_write(struct snd_soc_codec *codec, unsigned int reg,
                              unsigned int value)
 {
-        u16 *cache = codec->reg_cache;
+        u8 *cache = codec->reg_cache;
         u8 data[3];
         int ret;
 
diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index 998569d60330..acc91daa1c55 100644
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -84,7 +84,7 @@ static int run_delayed_work(struct delayed_work *dwork)
 /* codec register dump */
 static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf)
 {
-        int i, step = 1, count = 0;
+        int ret, i, step = 1, count = 0;
 
         if (!codec->reg_cache_size)
                 return 0;
@@ -101,12 +101,24 @@ static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf)
                 if (count >= PAGE_SIZE - 1)
                         break;
 
-                if (codec->display_register)
+                if (codec->display_register) {
                         count += codec->display_register(codec, buf + count,
                                                          PAGE_SIZE - count, i);
-                else
-                        count += snprintf(buf + count, PAGE_SIZE - count,
-                                          "%4x", codec->read(codec, i));
+                } else {
+                        /* If the read fails it's almost certainly due to
+                         * the register being volatile and the device being
+                         * powered off.
+                         */
+                        ret = codec->read(codec, i);
+                        if (ret >= 0)
+                                count += snprintf(buf + count,
+                                                  PAGE_SIZE - count,
+                                                  "%4x", ret);
+                        else
+                                count += snprintf(buf + count,
+                                                  PAGE_SIZE - count,
+                                                  "<no data: %d>", ret);
+                }
 
                 if (count >= PAGE_SIZE - 1)
                         break;
@@ -239,7 +251,7 @@ static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
                 printk(KERN_WARNING
                        "ASoC: Failed to create codec register debugfs file\n");
 
-        codec->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0744,
+        codec->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
                                                      codec->debugfs_codec_root,
                                                      &codec->pop_time);
         if (!codec->debugfs_pop_time)
@@ -1307,7 +1319,7 @@ cpu_dai_err:
 }
 
 /*
- * Attempt to initialise any uninitalised cards.  Must be called with
+ * Attempt to initialise any uninitialised cards.  Must be called with
  * client_mutex.
  */
 static void snd_soc_instantiate_cards(void)
@@ -2353,6 +2365,99 @@ int snd_soc_limit_volume(struct snd_soc_codec *codec,
 EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
 
 /**
+ * snd_soc_info_volsw_2r_sx - double with tlv and variable data size
+ *  mixer info callback
+ * @kcontrol: mixer control
+ * @uinfo: control element information
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_info_volsw_2r_sx(struct snd_kcontrol *kcontrol,
+                        struct snd_ctl_elem_info *uinfo)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        int max = mc->max;
+        int min = mc->min;
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 2;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = max-min;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r_sx);
+
+/**
+ * snd_soc_get_volsw_2r_sx - double with tlv and variable data size
+ *  mixer get callback
+ * @kcontrol: mixer control
+ * @uinfo: control element information
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_get_volsw_2r_sx(struct snd_kcontrol *kcontrol,
+                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        unsigned int mask = (1<<mc->shift)-1;
+        int min = mc->min;
+        int val = snd_soc_read(codec, mc->reg) & mask;
+        int valr = snd_soc_read(codec, mc->rreg) & mask;
+
+        ucontrol->value.integer.value[0] = ((val & 0xff)-min) & mask;
+        ucontrol->value.integer.value[1] = ((valr & 0xff)-min) & mask;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r_sx);
+
+/**
+ * snd_soc_put_volsw_2r_sx - double with tlv and variable data size
+ *  mixer put callback
+ * @kcontrol: mixer control
+ * @uinfo: control element information
+ *
+ * Returns 0 for success.
+ */
+int snd_soc_put_volsw_2r_sx(struct snd_kcontrol *kcontrol,
+                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct soc_mixer_control *mc =
+                (struct soc_mixer_control *)kcontrol->private_value;
+        struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
+        unsigned int mask = (1<<mc->shift)-1;
+        int min = mc->min;
+        int ret;
+        unsigned int val, valr, oval, ovalr;
+
+        val = ((ucontrol->value.integer.value[0]+min) & 0xff);
+        val &= mask;
+        valr = ((ucontrol->value.integer.value[1]+min) & 0xff);
+        valr &= mask;
+
+        oval = snd_soc_read(codec, mc->reg) & mask;
+        ovalr = snd_soc_read(codec, mc->rreg) & mask;
+
+        ret = 0;
+        if (oval != val) {
+                ret = snd_soc_write(codec, mc->reg, val);
+                if (ret < 0)
+                        return ret;
+        }
+        if (ovalr != valr) {
+                ret = snd_soc_write(codec, mc->rreg, valr);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r_sx);
+
+/**
  * snd_soc_dai_set_sysclk - configure DAI system or master clock.
  * @dai: DAI
  * @clk_id: DAI specific clock ID
diff --git a/sound/sound_core.c b/sound/sound_core.c
index 7c2d677a2df5..cb61317df509 100644
--- a/sound/sound_core.c
+++ b/sound/sound_core.c
@@ -576,8 +576,6 @@ static int soundcore_open(struct inode *inode, struct file *file)
         struct sound_unit *s;
         const struct file_operations *new_fops = NULL;
 
-        lock_kernel ();
-
         chain=unit&0x0F;
         if(chain==4 || chain==5)        /* dsp/audio/dsp16 */
         {
@@ -630,18 +628,19 @@ static int soundcore_open(struct inode *inode, struct file *file)
                 const struct file_operations *old_fops = file->f_op;
                 file->f_op = new_fops;
                 spin_unlock(&sound_loader_lock);
-                if(file->f_op->open)
+
+                if (file->f_op->open)
                         err = file->f_op->open(inode,file);
+
                 if (err) {
                         fops_put(file->f_op);
                         file->f_op = fops_get(old_fops);
                 }
+
                 fops_put(old_fops);
-                unlock_kernel();
                 return err;
         }
         spin_unlock(&sound_loader_lock);
-        unlock_kernel();
         return -ENODEV;
 }
 
diff --git a/sound/sparc/amd7930.c b/sound/sparc/amd7930.c
index 71221fd20944..f8bcfc30f800 100644
--- a/sound/sparc/amd7930.c
+++ b/sound/sparc/amd7930.c
@@ -336,7 +336,7 @@ struct snd_amd7930 {
         int                     pgain;
         int                     mgain;
 
-        struct of_device        *op;
+        struct platform_device  *op;
         unsigned int            irq;
         struct snd_amd7930      *next;
 };
@@ -906,7 +906,7 @@ static int __devinit snd_amd7930_mixer(struct snd_amd7930 *amd)
 
 static int snd_amd7930_free(struct snd_amd7930 *amd)
 {
-        struct of_device *op = amd->op;
+        struct platform_device *op = amd->op;
 
         amd7930_idle(amd);
 
@@ -934,7 +934,7 @@ static struct snd_device_ops snd_amd7930_dev_ops = {
 };
 
 static int __devinit snd_amd7930_create(struct snd_card *card,
-                                        struct of_device *op,
+                                        struct platform_device *op,
                                         int irq, int dev,
                                         struct snd_amd7930 **ramd)
 {
@@ -1002,7 +1002,7 @@ static int __devinit snd_amd7930_create(struct snd_card *card,
         return 0;
 }
 
-static int __devinit amd7930_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit amd7930_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct resource *rp = &op->resource[0];
         static int dev_num;
@@ -1010,7 +1010,7 @@ static int __devinit amd7930_sbus_probe(struct of_device *op, const struct of_de
         struct snd_amd7930 *amd;
         int err, irq;
 
-        irq = op->irqs[0];
+        irq = op->archdata.irqs[0];
 
         if (dev_num >= SNDRV_CARDS)
                 return -ENODEV;
@@ -1075,7 +1075,7 @@ static struct of_platform_driver amd7930_sbus_driver = {
 
 static int __init amd7930_init(void)
 {
-        return of_register_driver(&amd7930_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&amd7930_sbus_driver);
 }
 
 static void __exit amd7930_exit(void)
@@ -1092,7 +1092,7 @@ static void __exit amd7930_exit(void)
 
         amd7930_list = NULL;
 
-        of_unregister_driver(&amd7930_sbus_driver);
+        of_unregister_platform_driver(&amd7930_sbus_driver);
 }
 
 module_init(amd7930_init);
diff --git a/sound/sparc/cs4231.c b/sound/sparc/cs4231.c
index fb4c6f2f29e5..c276086c3b57 100644
--- a/sound/sparc/cs4231.c
+++ b/sound/sparc/cs4231.c
@@ -111,7 +111,7 @@ struct snd_cs4231 {
         struct mutex            mce_mutex;      /* mutex for mce register */
         struct mutex            open_mutex;     /* mutex for ALSA open/close */
 
-        struct of_device        *op;
+        struct platform_device  *op;
         unsigned int            irq[2];
         unsigned int            regs_size;
         struct snd_cs4231       *next;
@@ -1771,7 +1771,7 @@ static unsigned int sbus_dma_addr(struct cs4231_dma_control *dma_cont)
 
 static int snd_cs4231_sbus_free(struct snd_cs4231 *chip)
 {
-        struct of_device *op = chip->op;
+        struct platform_device *op = chip->op;
 
         if (chip->irq[0])
                 free_irq(chip->irq[0], chip);
@@ -1794,7 +1794,7 @@ static struct snd_device_ops snd_cs4231_sbus_dev_ops = {
 };
 
 static int __devinit snd_cs4231_sbus_create(struct snd_card *card,
-                                            struct of_device *op,
+                                            struct platform_device *op,
                                             int dev)
 {
         struct snd_cs4231 *chip = card->private_data;
@@ -1832,14 +1832,14 @@ static int __devinit snd_cs4231_sbus_create(struct snd_card *card,
         chip->c_dma.request = sbus_dma_request;
         chip->c_dma.address = sbus_dma_addr;
 
-        if (request_irq(op->irqs[0], snd_cs4231_sbus_interrupt,
+        if (request_irq(op->archdata.irqs[0], snd_cs4231_sbus_interrupt,
                         IRQF_SHARED, "cs4231", chip)) {
                 snd_printdd("cs4231-%d: Unable to grab SBUS IRQ %d\n",
-                            dev, op->irqs[0]);
+                            dev, op->archdata.irqs[0]);
                 snd_cs4231_sbus_free(chip);
                 return -EBUSY;
         }
-        chip->irq[0] = op->irqs[0];
+        chip->irq[0] = op->archdata.irqs[0];
 
         if (snd_cs4231_probe(chip) < 0) {
                 snd_cs4231_sbus_free(chip);
@@ -1856,7 +1856,7 @@ static int __devinit snd_cs4231_sbus_create(struct snd_card *card,
         return 0;
 }
 
-static int __devinit cs4231_sbus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_sbus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct resource *rp = &op->resource[0];
         struct snd_card *card;
@@ -1870,7 +1870,7 @@ static int __devinit cs4231_sbus_probe(struct of_device *op, const struct of_dev
                 card->shortname,
                 rp->flags & 0xffL,
                 (unsigned long long)rp->start,
-                op->irqs[0]);
+                op->archdata.irqs[0]);
 
         err = snd_cs4231_sbus_create(card, op, dev);
         if (err < 0) {
@@ -1931,7 +1931,7 @@ static unsigned int _ebus_dma_addr(struct cs4231_dma_control *dma_cont)
 
 static int snd_cs4231_ebus_free(struct snd_cs4231 *chip)
 {
-        struct of_device *op = chip->op;
+        struct platform_device *op = chip->op;
 
         if (chip->c_dma.ebus_info.regs) {
                 ebus_dma_unregister(&chip->c_dma.ebus_info);
@@ -1960,7 +1960,7 @@ static struct snd_device_ops snd_cs4231_ebus_dev_ops = {
 };
 
 static int __devinit snd_cs4231_ebus_create(struct snd_card *card,
-                                            struct of_device *op,
+                                            struct platform_device *op,
                                             int dev)
 {
         struct snd_cs4231 *chip = card->private_data;
@@ -1979,12 +1979,12 @@ static int __devinit snd_cs4231_ebus_create(struct snd_card *card,
         chip->c_dma.ebus_info.flags = EBUS_DMA_FLAG_USE_EBDMA_HANDLER;
         chip->c_dma.ebus_info.callback = snd_cs4231_ebus_capture_callback;
         chip->c_dma.ebus_info.client_cookie = chip;
-        chip->c_dma.ebus_info.irq = op->irqs[0];
+        chip->c_dma.ebus_info.irq = op->archdata.irqs[0];
         strcpy(chip->p_dma.ebus_info.name, "cs4231(play)");
         chip->p_dma.ebus_info.flags = EBUS_DMA_FLAG_USE_EBDMA_HANDLER;
         chip->p_dma.ebus_info.callback = snd_cs4231_ebus_play_callback;
         chip->p_dma.ebus_info.client_cookie = chip;
-        chip->p_dma.ebus_info.irq = op->irqs[1];
+        chip->p_dma.ebus_info.irq = op->archdata.irqs[1];
 
         chip->p_dma.prepare = _ebus_dma_prepare;
         chip->p_dma.enable = _ebus_dma_enable;
@@ -2048,7 +2048,7 @@ static int __devinit snd_cs4231_ebus_create(struct snd_card *card,
         return 0;
 }
 
-static int __devinit cs4231_ebus_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_ebus_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct snd_card *card;
         int err;
@@ -2060,7 +2060,7 @@ static int __devinit cs4231_ebus_probe(struct of_device *op, const struct of_dev
         sprintf(card->longname, "%s at 0x%llx, irq %d",
                 card->shortname,
                 op->resource[0].start,
-                op->irqs[0]);
+                op->archdata.irqs[0]);
 
         err = snd_cs4231_ebus_create(card, op, dev);
         if (err < 0) {
@@ -2072,7 +2072,7 @@ static int __devinit cs4231_ebus_probe(struct of_device *op, const struct of_dev
 }
 #endif
 
-static int __devinit cs4231_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit cs4231_probe(struct platform_device *op, const struct of_device_id *match)
 {
 #ifdef EBUS_SUPPORT
         if (!strcmp(op->dev.of_node->parent->name, "ebus"))
@@ -2086,7 +2086,7 @@ static int __devinit cs4231_probe(struct of_device *op, const struct of_device_i
         return -ENODEV;
 }
 
-static int __devexit cs4231_remove(struct of_device *op)
+static int __devexit cs4231_remove(struct platform_device *op)
 {
         struct snd_cs4231 *chip = dev_get_drvdata(&op->dev);
 
@@ -2120,12 +2120,12 @@ static struct of_platform_driver cs4231_driver = {
 
 static int __init cs4231_init(void)
 {
-        return of_register_driver(&cs4231_driver, &of_bus_type);
+        return of_register_platform_driver(&cs4231_driver);
 }
 
 static void __exit cs4231_exit(void)
 {
-        of_unregister_driver(&cs4231_driver);
+        of_unregister_platform_driver(&cs4231_driver);
 }
 
 module_init(cs4231_init);
diff --git a/sound/sparc/dbri.c b/sound/sparc/dbri.c
index 1557bf132e73..39cd5d69d051 100644
--- a/sound/sparc/dbri.c
+++ b/sound/sparc/dbri.c
@@ -299,7 +299,7 @@ struct dbri_streaminfo {
 /* This structure holds the information for both chips (DBRI & CS4215) */
 struct snd_dbri {
         int regs_size, irq;     /* Needed for unload */
-        struct of_device *op;   /* OF device info */
+        struct platform_device *op;     /* OF device info */
         spinlock_t lock;
 
         struct dbri_dma *dma;   /* Pointer to our DMA block */
@@ -2523,7 +2523,7 @@ static void __devinit snd_dbri_proc(struct snd_card *card)
 static void snd_dbri_free(struct snd_dbri *dbri);
 
 static int __devinit snd_dbri_create(struct snd_card *card,
-                                     struct of_device *op,
+                                     struct platform_device *op,
                                      int irq, int dev)
 {
         struct snd_dbri *dbri = card->private_data;
@@ -2592,7 +2592,7 @@ static void snd_dbri_free(struct snd_dbri *dbri)
                                   (void *)dbri->dma, dbri->dma_dvma);
 }
 
-static int __devinit dbri_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit dbri_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct snd_dbri *dbri;
         struct resource *rp;
@@ -2608,7 +2608,7 @@ static int __devinit dbri_probe(struct of_device *op, const struct of_device_id
                 return -ENOENT;
         }
 
-        irq = op->irqs[0];
+        irq = op->archdata.irqs[0];
         if (irq <= 0) {
                 printk(KERN_ERR "DBRI-%d: No IRQ.\n", dev);
                 return -ENODEV;
@@ -2662,7 +2662,7 @@ _err:
         return err;
 }
 
-static int __devexit dbri_remove(struct of_device *op)
+static int __devexit dbri_remove(struct platform_device *op)
 {
         struct snd_card *card = dev_get_drvdata(&op->dev);
 
@@ -2699,12 +2699,12 @@ static struct of_platform_driver dbri_sbus_driver = {
 /* Probe for the dbri chip and then attach the driver. */
 static int __init dbri_init(void)
 {
-        return of_register_driver(&dbri_sbus_driver, &of_bus_type);
+        return of_register_platform_driver(&dbri_sbus_driver);
 }
 
 static void __exit dbri_exit(void)
 {
-        of_unregister_driver(&dbri_sbus_driver);
+        of_unregister_platform_driver(&dbri_sbus_driver);
 }
 
 module_init(dbri_init);
diff --git a/sound/synth/emux/emux_hwdep.c b/sound/synth/emux/emux_hwdep.c
index ff0b2a8fd25b..5ae1eae9f6db 100644
--- a/sound/synth/emux/emux_hwdep.c
+++ b/sound/synth/emux/emux_hwdep.c
@@ -128,6 +128,9 @@ snd_emux_init_hwdep(struct snd_emux *emu)
         strcpy(hw->name, SNDRV_EMUX_HWDEP_NAME);
         hw->iface = SNDRV_HWDEP_IFACE_EMUX_WAVETABLE;
         hw->ops.ioctl = snd_emux_hwdep_ioctl;
+        /* The ioctl parameter types are compatible between 32- and
+         * 64-bit architectures, so use the same function. */
+        hw->ops.ioctl_compat = snd_emux_hwdep_ioctl;
         hw->exclusive = 1;
         hw->private_data = emu;
         if ((err = snd_card_register(emu->card)) < 0)
diff --git a/sound/usb/Kconfig b/sound/usb/Kconfig
index 44d6d2ec964f..112984f4080f 100644
--- a/sound/usb/Kconfig
+++ b/sound/usb/Kconfig
@@ -65,6 +65,7 @@ config SND_USB_CAIAQ
             * Native Instruments Guitar Rig Session I/O
             * Native Instruments Guitar Rig mobile
             * Native Instruments Traktor Kontrol X1
+            * Native Instruments Traktor Kontrol S4
 
            To compile this driver as a module, choose M here: the module
            will be called snd-usb-caiaq.
@@ -82,6 +83,7 @@ config SND_USB_CAIAQ_INPUT
            * Native Instruments Kore Controller
            * Native Instruments Kore Controller 2
            * Native Instruments Audio Kontrol 1
+           * Native Instruments Traktor Kontrol S4
 
 config SND_USB_US122L
         tristate "Tascam US-122L USB driver"
diff --git a/sound/usb/caiaq/audio.c b/sound/usb/caiaq/audio.c
index 4328cad6c3a2..68b97477577b 100644
--- a/sound/usb/caiaq/audio.c
+++ b/sound/usb/caiaq/audio.c
@@ -111,7 +111,7 @@ static int stream_start(struct snd_usb_caiaqdev *dev)
         memset(dev->sub_capture, 0, sizeof(dev->sub_capture));
         dev->input_panic = 0;
         dev->output_panic = 0;
-        dev->first_packet = 1;
+        dev->first_packet = 4;
         dev->streaming = 1;
         dev->warned = 0;
 
@@ -169,7 +169,7 @@ static int snd_usb_caiaq_substream_close(struct snd_pcm_substream *substream)
 }
 
 static int snd_usb_caiaq_pcm_hw_params(struct snd_pcm_substream *sub,
-                                        struct snd_pcm_hw_params *hw_params)
+                                       struct snd_pcm_hw_params *hw_params)
 {
         debug("%s(%p)\n", __func__, sub);
         return snd_pcm_lib_malloc_pages(sub, params_buffer_bytes(hw_params));
@@ -189,7 +189,7 @@ static int snd_usb_caiaq_pcm_hw_free(struct snd_pcm_substream *sub)
 #endif
 
 static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100,
-                                 48000, 64000, 88200, 96000, 176400, 192000 };
+                                48000, 64000, 88200, 96000, 176400, 192000 };
 
 static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream)
 {
@@ -201,12 +201,39 @@ static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream)
         debug("%s(%p)\n", __func__, substream);
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                dev->period_out_count[index] = BYTES_PER_SAMPLE + 1;
-                dev->audio_out_buf_pos[index] = BYTES_PER_SAMPLE + 1;
+                int out_pos;
+
+                switch (dev->spec.data_alignment) {
+                case 0:
+                case 2:
+                        out_pos = BYTES_PER_SAMPLE + 1;
+                        break;
+                case 3:
+                default:
+                        out_pos = 0;
+                        break;
+                }
+
+                dev->period_out_count[index] = out_pos;
+                dev->audio_out_buf_pos[index] = out_pos;
         } else {
-                int in_pos = (dev->spec.data_alignment == 2) ? 0 : 2;
-                dev->period_in_count[index] = BYTES_PER_SAMPLE + in_pos;
-                dev->audio_in_buf_pos[index] = BYTES_PER_SAMPLE + in_pos;
+                int in_pos;
+
+                switch (dev->spec.data_alignment) {
+                case 0:
+                        in_pos = BYTES_PER_SAMPLE + 2;
+                        break;
+                case 2:
+                        in_pos = BYTES_PER_SAMPLE;
+                        break;
+                case 3:
+                default:
+                        in_pos = 0;
+                        break;
+                }
+
+                dev->period_in_count[index] = in_pos;
+                dev->audio_in_buf_pos[index] = in_pos;
         }
 
         if (dev->streaming)
@@ -221,7 +248,7 @@ static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream)
         snd_pcm_limit_hw_rates(runtime);
 
         bytes_per_sample = BYTES_PER_SAMPLE;
-        if (dev->spec.data_alignment == 2)
+        if (dev->spec.data_alignment >= 2)
                 bytes_per_sample++;
 
         bpp = ((runtime->rate / 8000) + CLOCK_DRIFT_TOLERANCE)
@@ -253,6 +280,8 @@ static int snd_usb_caiaq_pcm_trigger(struct snd_pcm_substream *sub, int cmd)
 {
         struct snd_usb_caiaqdev *dev = snd_pcm_substream_chip(sub);
 
+        debug("%s(%p) cmd %d\n", __func__, sub, cmd);
+
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
@@ -402,6 +431,61 @@ static void read_in_urb_mode2(struct snd_usb_caiaqdev *dev,
         }
 }
 
+static void read_in_urb_mode3(struct snd_usb_caiaqdev *dev,
+                              const struct urb *urb,
+                              const struct usb_iso_packet_descriptor *iso)
+{
+        unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
+        int stream, i;
+
+        /* paranoia check */
+        if (iso->actual_length % (BYTES_PER_SAMPLE_USB * CHANNELS_PER_STREAM))
+                return;
+
+        for (i = 0; i < iso->actual_length;) {
+                for (stream = 0; stream < dev->n_streams; stream++) {
+                        struct snd_pcm_substream *sub = dev->sub_capture[stream];
+                        char *audio_buf = NULL;
+                        int c, n, sz = 0;
+
+                        if (sub && !dev->input_panic) {
+                                struct snd_pcm_runtime *rt = sub->runtime;
+                                audio_buf = rt->dma_area;
+                                sz = frames_to_bytes(rt, rt->buffer_size);
+                        }
+
+                        for (c = 0; c < CHANNELS_PER_STREAM; c++) {
+                                /* 3 audio data bytes, followed by 1 check byte */
+                                if (audio_buf) {
+                                        for (n = 0; n < BYTES_PER_SAMPLE; n++) {
+                                                audio_buf[dev->audio_in_buf_pos[stream]++] = usb_buf[i+n];
+
+                                                if (dev->audio_in_buf_pos[stream] == sz)
+                                                        dev->audio_in_buf_pos[stream] = 0;
+                                        }
+
+                                        dev->period_in_count[stream] += BYTES_PER_SAMPLE;
+                                }
+
+                                i += BYTES_PER_SAMPLE;
+
+                                if (usb_buf[i] != ((stream << 1) | c) &&
+                                    !dev->first_packet) {
+                                        if (!dev->input_panic)
+                                                printk(" EXPECTED: %02x got %02x, c %d, stream %d, i %d\n",
+                                                        ((stream << 1) | c), usb_buf[i], c, stream, i);
+                                        dev->input_panic = 1;
+                                }
+
+                                i++;
+                        }
+                }
+        }
+
+        if (dev->first_packet > 0)
+                dev->first_packet--;
+}
+
 static void read_in_urb(struct snd_usb_caiaqdev *dev,
                         const struct urb *urb,
                         const struct usb_iso_packet_descriptor *iso)
@@ -419,6 +503,9 @@ static void read_in_urb(struct snd_usb_caiaqdev *dev,
         case 2:
                 read_in_urb_mode2(dev, urb, iso);
                 break;
+        case 3:
+                read_in_urb_mode3(dev, urb, iso);
+                break;
         }
 
         if ((dev->input_panic || dev->output_panic) && !dev->warned) {
@@ -429,9 +516,9 @@ static void read_in_urb(struct snd_usb_caiaqdev *dev,
         }
 }
 
-static void fill_out_urb(struct snd_usb_caiaqdev *dev,
-                         struct urb *urb,
-                         const struct usb_iso_packet_descriptor *iso)
+static void fill_out_urb_mode_0(struct snd_usb_caiaqdev *dev,
+                                struct urb *urb,
+                                const struct usb_iso_packet_descriptor *iso)
 {
         unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
         struct snd_pcm_substream *sub;
@@ -457,9 +544,67 @@ static void fill_out_urb(struct snd_usb_caiaqdev *dev,
                 /* fill in the check bytes */
                 if (dev->spec.data_alignment == 2 &&
                     i % (dev->n_streams * BYTES_PER_SAMPLE_USB) ==
-                        (dev->n_streams * CHANNELS_PER_STREAM))
-                    for (stream = 0; stream < dev->n_streams; stream++, i++)
-                        usb_buf[i] = MAKE_CHECKBYTE(dev, stream, i);
+                        (dev->n_streams * CHANNELS_PER_STREAM))
+                        for (stream = 0; stream < dev->n_streams; stream++, i++)
+                                usb_buf[i] = MAKE_CHECKBYTE(dev, stream, i);
+        }
+}
+
+static void fill_out_urb_mode_3(struct snd_usb_caiaqdev *dev,
+                                struct urb *urb,
+                                const struct usb_iso_packet_descriptor *iso)
+{
+        unsigned char *usb_buf = urb->transfer_buffer + iso->offset;
+        int stream, i;
+
+        for (i = 0; i < iso->length;) {
+                for (stream = 0; stream < dev->n_streams; stream++) {
+                        struct snd_pcm_substream *sub = dev->sub_playback[stream];
+                        char *audio_buf = NULL;
+                        int c, n, sz = 0;
+
+                        if (sub) {
+                                struct snd_pcm_runtime *rt = sub->runtime;
+                                audio_buf = rt->dma_area;
+                                sz = frames_to_bytes(rt, rt->buffer_size);
+                        }
+
+                        for (c = 0; c < CHANNELS_PER_STREAM; c++) {
+                                for (n = 0; n < BYTES_PER_SAMPLE; n++) {
+                                        if (audio_buf) {
+                                                usb_buf[i+n] = audio_buf[dev->audio_out_buf_pos[stream]++];
+
+                                                if (dev->audio_out_buf_pos[stream] == sz)
+                                                        dev->audio_out_buf_pos[stream] = 0;
+                                        } else {
+                                                usb_buf[i+n] = 0;
+                                        }
+                                }
+
+                                if (audio_buf)
+                                        dev->period_out_count[stream] += BYTES_PER_SAMPLE;
+
+                                i += BYTES_PER_SAMPLE;
+
+                                /* fill in the check byte pattern */
+                                usb_buf[i++] = (stream << 1) | c;
+                        }
+                }
+        }
+}
+
+static inline void fill_out_urb(struct snd_usb_caiaqdev *dev,
+                                struct urb *urb,
+                                const struct usb_iso_packet_descriptor *iso)
+{
+        switch (dev->spec.data_alignment) {
+        case 0:
+        case 2:
+                fill_out_urb_mode_0(dev, urb, iso);
+                break;
+        case 3:
+                fill_out_urb_mode_3(dev, urb, iso);
+                break;
         }
 }
 
diff --git a/sound/usb/caiaq/control.c b/sound/usb/caiaq/control.c
index 91c804cd2782..00e5d0a469e1 100644
--- a/sound/usb/caiaq/control.c
+++ b/sound/usb/caiaq/control.c
@@ -55,6 +55,10 @@ static int control_info(struct snd_kcontrol *kcontrol,
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
                 maxval = 127;
                 break;
+
+        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
+                maxval = 31;
+                break;
         }
 
         if (is_intval) {
@@ -93,6 +97,7 @@ static int control_put(struct snd_kcontrol *kcontrol,
         struct snd_usb_audio *chip = snd_kcontrol_chip(kcontrol);
         struct snd_usb_caiaqdev *dev = caiaqdev(chip->card);
         int pos = kcontrol->private_value;
+        int v = ucontrol->value.integer.value[0];
         unsigned char cmd = EP1_CMD_WRITE_IO;
 
         if (dev->chip.usb_id ==
@@ -100,12 +105,27 @@ static int control_put(struct snd_kcontrol *kcontrol,
                 cmd = EP1_CMD_DIMM_LEDS;
 
         if (pos & CNT_INTVAL) {
-                dev->control_state[pos & ~CNT_INTVAL]
-                        = ucontrol->value.integer.value[0];
-                snd_usb_caiaq_send_command(dev, cmd,
-                                dev->control_state, sizeof(dev->control_state));
+                int i = pos & ~CNT_INTVAL;
+
+                dev->control_state[i] = v;
+
+                if (dev->chip.usb_id ==
+                        USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4)) {
+                        int actual_len;
+
+                        dev->ep8_out_buf[0] = i;
+                        dev->ep8_out_buf[1] = v;
+
+                        usb_bulk_msg(dev->chip.dev,
+                                     usb_sndbulkpipe(dev->chip.dev, 8),
+                                     dev->ep8_out_buf, sizeof(dev->ep8_out_buf),
+                                     &actual_len, 200);
+                } else {
+                        snd_usb_caiaq_send_command(dev, cmd,
+                                        dev->control_state, sizeof(dev->control_state));
+                }
         } else {
-                if (ucontrol->value.integer.value[0])
+                if (v)
                         dev->control_state[pos / 8] |= 1 << (pos % 8);
                 else
                         dev->control_state[pos / 8] &= ~(1 << (pos % 8));
@@ -296,6 +316,179 @@ static struct caiaq_controller kontrolx1_controller[] = {
         { "LED Deck B: SYNC",           8  | CNT_INTVAL },
 };
 
+static struct caiaq_controller kontrols4_controller[] = {
+        { "LED: Master: Quant",                 10  | CNT_INTVAL },
+        { "LED: Master: Headphone",             11  | CNT_INTVAL },
+        { "LED: Master: Master",                12  | CNT_INTVAL },
+        { "LED: Master: Snap",                  14  | CNT_INTVAL },
+        { "LED: Master: Warning",               15  | CNT_INTVAL },
+        { "LED: Master: Master button",         112 | CNT_INTVAL },
+        { "LED: Master: Snap button",           113 | CNT_INTVAL },
+        { "LED: Master: Rec",                   118 | CNT_INTVAL },
+        { "LED: Master: Size",                  119 | CNT_INTVAL },
+        { "LED: Master: Quant button",          120 | CNT_INTVAL },
+        { "LED: Master: Browser button",        121 | CNT_INTVAL },
+        { "LED: Master: Play button",           126 | CNT_INTVAL },
+        { "LED: Master: Undo button",           127 | CNT_INTVAL },
+
+        { "LED: Channel A: >",                  4   | CNT_INTVAL },
+        { "LED: Channel A: <",                  5   | CNT_INTVAL },
+        { "LED: Channel A: Meter 1",            97  | CNT_INTVAL },
+        { "LED: Channel A: Meter 2",            98  | CNT_INTVAL },
+        { "LED: Channel A: Meter 3",            99  | CNT_INTVAL },
+        { "LED: Channel A: Meter 4",            100 | CNT_INTVAL },
+        { "LED: Channel A: Meter 5",            101 | CNT_INTVAL },
+        { "LED: Channel A: Meter 6",            102 | CNT_INTVAL },
+        { "LED: Channel A: Meter clip",         103 | CNT_INTVAL },
+        { "LED: Channel A: Active",             114 | CNT_INTVAL },
+        { "LED: Channel A: Cue",                116 | CNT_INTVAL },
+        { "LED: Channel A: FX1",                149 | CNT_INTVAL },
+        { "LED: Channel A: FX2",                148 | CNT_INTVAL },
+
+        { "LED: Channel B: >",                  2   | CNT_INTVAL },
+        { "LED: Channel B: <",                  3   | CNT_INTVAL },
+        { "LED: Channel B: Meter 1",            89  | CNT_INTVAL },
+        { "LED: Channel B: Meter 2",            90  | CNT_INTVAL },
+        { "LED: Channel B: Meter 3",            91  | CNT_INTVAL },
+        { "LED: Channel B: Meter 4",            92  | CNT_INTVAL },
+        { "LED: Channel B: Meter 5",            93  | CNT_INTVAL },
+        { "LED: Channel B: Meter 6",            94  | CNT_INTVAL },
+        { "LED: Channel B: Meter clip",         95  | CNT_INTVAL },
+        { "LED: Channel B: Active",             122 | CNT_INTVAL },
+        { "LED: Channel B: Cue",                125 | CNT_INTVAL },
+        { "LED: Channel B: FX1",                147 | CNT_INTVAL },
+        { "LED: Channel B: FX2",                146 | CNT_INTVAL },
+
+        { "LED: Channel C: >",                  6   | CNT_INTVAL },
+        { "LED: Channel C: <",                  7   | CNT_INTVAL },
+        { "LED: Channel C: Meter 1",            105 | CNT_INTVAL },
+        { "LED: Channel C: Meter 2",            106 | CNT_INTVAL },
+        { "LED: Channel C: Meter 3",            107 | CNT_INTVAL },
+        { "LED: Channel C: Meter 4",            108 | CNT_INTVAL },
+        { "LED: Channel C: Meter 5",            109 | CNT_INTVAL },
+        { "LED: Channel C: Meter 6",            110 | CNT_INTVAL },
+        { "LED: Channel C: Meter clip",         111 | CNT_INTVAL },
+        { "LED: Channel C: Active",             115 | CNT_INTVAL },
+        { "LED: Channel C: Cue",                117 | CNT_INTVAL },
+        { "LED: Channel C: FX1",                151 | CNT_INTVAL },
+        { "LED: Channel C: FX2",                150 | CNT_INTVAL },
+
+        { "LED: Channel D: >",                  0   | CNT_INTVAL },
+        { "LED: Channel D: <",                  1   | CNT_INTVAL },
+        { "LED: Channel D: Meter 1",            81  | CNT_INTVAL },
+        { "LED: Channel D: Meter 2",            82  | CNT_INTVAL },
+        { "LED: Channel D: Meter 3",            83  | CNT_INTVAL },
+        { "LED: Channel D: Meter 4",            84  | CNT_INTVAL },
+        { "LED: Channel D: Meter 5",            85  | CNT_INTVAL },
+        { "LED: Channel D: Meter 6",            86  | CNT_INTVAL },
+        { "LED: Channel D: Meter clip",         87  | CNT_INTVAL },
+        { "LED: Channel D: Active",             123 | CNT_INTVAL },
+        { "LED: Channel D: Cue",                124 | CNT_INTVAL },
+        { "LED: Channel D: FX1",                145 | CNT_INTVAL },
+        { "LED: Channel D: FX2",                144 | CNT_INTVAL },
+
+        { "LED: Deck A: 1 (blue)",              22  | CNT_INTVAL },
+        { "LED: Deck A: 1 (green)",             23  | CNT_INTVAL },
+        { "LED: Deck A: 2 (blue)",              20  | CNT_INTVAL },
+        { "LED: Deck A: 2 (green)",             21  | CNT_INTVAL },
+        { "LED: Deck A: 3 (blue)",              18  | CNT_INTVAL },
+        { "LED: Deck A: 3 (green)",             19  | CNT_INTVAL },
+        { "LED: Deck A: 4 (blue)",              16  | CNT_INTVAL },
+        { "LED: Deck A: 4 (green)",             17  | CNT_INTVAL },
+        { "LED: Deck A: Load",                  44  | CNT_INTVAL },
+        { "LED: Deck A: Deck C button",         45  | CNT_INTVAL },
+        { "LED: Deck A: In",                    47  | CNT_INTVAL },
+        { "LED: Deck A: Out",                   46  | CNT_INTVAL },
+        { "LED: Deck A: Shift",                 24  | CNT_INTVAL },
+        { "LED: Deck A: Sync",                  27  | CNT_INTVAL },
+        { "LED: Deck A: Cue",                   26  | CNT_INTVAL },
+        { "LED: Deck A: Play",                  25  | CNT_INTVAL },
+        { "LED: Deck A: Tempo up",              33  | CNT_INTVAL },
+        { "LED: Deck A: Tempo down",            32  | CNT_INTVAL },
+        { "LED: Deck A: Master",                34  | CNT_INTVAL },
+        { "LED: Deck A: Keylock",               35  | CNT_INTVAL },
+        { "LED: Deck A: Deck A",                37  | CNT_INTVAL },
+        { "LED: Deck A: Deck C",                36  | CNT_INTVAL },
+        { "LED: Deck A: Samples",               38  | CNT_INTVAL },
+        { "LED: Deck A: On Air",                39  | CNT_INTVAL },
+        { "LED: Deck A: Sample 1",              31  | CNT_INTVAL },
+        { "LED: Deck A: Sample 2",              30  | CNT_INTVAL },
+        { "LED: Deck A: Sample 3",              29  | CNT_INTVAL },
+        { "LED: Deck A: Sample 4",              28  | CNT_INTVAL },
+        { "LED: Deck A: Digit 1 - A",           55  | CNT_INTVAL },
+        { "LED: Deck A: Digit 1 - B",           54  | CNT_INTVAL },
+        { "LED: Deck A: Digit 1 - C",           53  | CNT_INTVAL },
+        { "LED: Deck A: Digit 1 - D",           52  | CNT_INTVAL },
+        { "LED: Deck A: Digit 1 - E",           51  | CNT_INTVAL },
+        { "LED: Deck A: Digit 1 - F",           50  | CNT_INTVAL },
+        { "LED: Deck A: Digit 1 - G",           49  | CNT_INTVAL },
+        { "LED: Deck A: Digit 1 - dot",         48  | CNT_INTVAL },
+        { "LED: Deck A: Digit 2 - A",           63  | CNT_INTVAL },
+        { "LED: Deck A: Digit 2 - B",           62  | CNT_INTVAL },
+        { "LED: Deck A: Digit 2 - C",           61  | CNT_INTVAL },
+        { "LED: Deck A: Digit 2 - D",           60  | CNT_INTVAL },
+        { "LED: Deck A: Digit 2 - E",           59  | CNT_INTVAL },
+        { "LED: Deck A: Digit 2 - F",           58  | CNT_INTVAL },
+        { "LED: Deck A: Digit 2 - G",           57  | CNT_INTVAL },
+        { "LED: Deck A: Digit 2 - dot",         56  | CNT_INTVAL },
+
+        { "LED: Deck B: 1 (blue)",              78  | CNT_INTVAL },
+        { "LED: Deck B: 1 (green)",             79  | CNT_INTVAL },
+        { "LED: Deck B: 2 (blue)",              76  | CNT_INTVAL },
+        { "LED: Deck B: 2 (green)",             77  | CNT_INTVAL },
+        { "LED: Deck B: 3 (blue)",              74  | CNT_INTVAL },
+        { "LED: Deck B: 3 (green)",             75  | CNT_INTVAL },
+        { "LED: Deck B: 4 (blue)",              72  | CNT_INTVAL },
+        { "LED: Deck B: 4 (green)",             73  | CNT_INTVAL },
+        { "LED: Deck B: Load",                  180 | CNT_INTVAL },
+        { "LED: Deck B: Deck D button",         181 | CNT_INTVAL },
+        { "LED: Deck B: In",                    183 | CNT_INTVAL },
+        { "LED: Deck B: Out",                   182 | CNT_INTVAL },
+        { "LED: Deck B: Shift",                 64  | CNT_INTVAL },
+        { "LED: Deck B: Sync",                  67  | CNT_INTVAL },
+        { "LED: Deck B: Cue",                   66  | CNT_INTVAL },
+        { "LED: Deck B: Play",                  65  | CNT_INTVAL },
+        { "LED: Deck B: Tempo up",              185 | CNT_INTVAL },
+        { "LED: Deck B: Tempo down",            184 | CNT_INTVAL },
+        { "LED: Deck B: Master",                186 | CNT_INTVAL },
+        { "LED: Deck B: Keylock",               187 | CNT_INTVAL },
+        { "LED: Deck B: Deck B",                189 | CNT_INTVAL },
+        { "LED: Deck B: Deck D",                188 | CNT_INTVAL },
+        { "LED: Deck B: Samples",               190 | CNT_INTVAL },
+        { "LED: Deck B: On Air",                191 | CNT_INTVAL },
+        { "LED: Deck B: Sample 1",              71  | CNT_INTVAL },
+        { "LED: Deck B: Sample 2",              70  | CNT_INTVAL },
+        { "LED: Deck B: Sample 3",              69  | CNT_INTVAL },
+        { "LED: Deck B: Sample 4",              68  | CNT_INTVAL },
+        { "LED: Deck B: Digit 1 - A",           175 | CNT_INTVAL },
+        { "LED: Deck B: Digit 1 - B",           174 | CNT_INTVAL },
+        { "LED: Deck B: Digit 1 - C",           173 | CNT_INTVAL },
+        { "LED: Deck B: Digit 1 - D",           172 | CNT_INTVAL },
+        { "LED: Deck B: Digit 1 - E",           171 | CNT_INTVAL },
+        { "LED: Deck B: Digit 1 - F",           170 | CNT_INTVAL },
+        { "LED: Deck B: Digit 1 - G",           169 | CNT_INTVAL },
+        { "LED: Deck B: Digit 1 - dot",         168 | CNT_INTVAL },
+        { "LED: Deck B: Digit 2 - A",           167 | CNT_INTVAL },
+        { "LED: Deck B: Digit 2 - B",           166 | CNT_INTVAL },
+        { "LED: Deck B: Digit 2 - C",           165 | CNT_INTVAL },
+        { "LED: Deck B: Digit 2 - D",           164 | CNT_INTVAL },
+        { "LED: Deck B: Digit 2 - E",           163 | CNT_INTVAL },
+        { "LED: Deck B: Digit 2 - F",           162 | CNT_INTVAL },
+        { "LED: Deck B: Digit 2 - G",           161 | CNT_INTVAL },
+        { "LED: Deck B: Digit 2 - dot",         160 | CNT_INTVAL },
+
+        { "LED: FX1: dry/wet",                  153 | CNT_INTVAL },
+        { "LED: FX1: 1",                        154 | CNT_INTVAL },
+        { "LED: FX1: 2",                        155 | CNT_INTVAL },
+        { "LED: FX1: 3",                        156 | CNT_INTVAL },
+        { "LED: FX1: Mode",                     157 | CNT_INTVAL },
+        { "LED: FX2: dry/wet",                  129 | CNT_INTVAL },
+        { "LED: FX2: 1",                        130 | CNT_INTVAL },
+        { "LED: FX2: 2",                        131 | CNT_INTVAL },
+        { "LED: FX2: 3",                        132 | CNT_INTVAL },
+        { "LED: FX2: Mode",                     133 | CNT_INTVAL },
+};
+
 static int __devinit add_controls(struct caiaq_controller *c, int num,
                                   struct snd_usb_caiaqdev *dev)
 {
@@ -354,6 +547,11 @@ int __devinit snd_usb_caiaq_control_init(struct snd_usb_caiaqdev *dev)
                 ret = add_controls(kontrolx1_controller,
                         ARRAY_SIZE(kontrolx1_controller), dev);
                 break;
+
+        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
+                ret = add_controls(kontrols4_controller,
+                        ARRAY_SIZE(kontrols4_controller), dev);
+                break;
         }
 
         return ret;
diff --git a/sound/usb/caiaq/device.c b/sound/usb/caiaq/device.c
index cdfb856bddd2..6480c3283c05 100644
--- a/sound/usb/caiaq/device.c
+++ b/sound/usb/caiaq/device.c
@@ -36,7 +36,7 @@
 #include "input.h"
 
 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
-MODULE_DESCRIPTION("caiaq USB audio, version 1.3.21");
+MODULE_DESCRIPTION("caiaq USB audio");
 MODULE_LICENSE("GPL");
 MODULE_SUPPORTED_DEVICE("{{Native Instruments, RigKontrol2},"
                          "{Native Instruments, RigKontrol3},"
@@ -48,7 +48,8 @@ MODULE_SUPPORTED_DEVICE("{{Native Instruments, RigKontrol2},"
                          "{Native Instruments, Audio 8 DJ},"
                          "{Native Instruments, Session I/O},"
                          "{Native Instruments, GuitarRig mobile}"
-                         "{Native Instruments, Traktor Kontrol X1}");
+                         "{Native Instruments, Traktor Kontrol X1}"
+                         "{Native Instruments, Traktor Kontrol S4}");
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */
 static char* id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */
@@ -134,6 +135,11 @@ static struct usb_device_id snd_usb_id_table[] = {
                 .idVendor =     USB_VID_NATIVEINSTRUMENTS,
                 .idProduct =    USB_PID_TRAKTORKONTROLX1
         },
+        {
+                .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
+                .idVendor =     USB_VID_NATIVEINSTRUMENTS,
+                .idProduct =    USB_PID_TRAKTORKONTROLS4
+        },
         { /* terminator */ }
 };
 
diff --git a/sound/usb/caiaq/device.h b/sound/usb/caiaq/device.h
index f1117ecc84fd..e3d8a3efb35b 100644
--- a/sound/usb/caiaq/device.h
+++ b/sound/usb/caiaq/device.h
@@ -16,6 +16,7 @@
 #define USB_PID_SESSIONIO               0x1915
 #define USB_PID_GUITARRIGMOBILE         0x0d8d
 #define USB_PID_TRAKTORKONTROLX1        0x2305
+#define USB_PID_TRAKTORKONTROLS4        0xbaff
 
 #define EP1_BUFSIZE 64
 #define EP4_BUFSIZE 512
@@ -99,13 +100,14 @@ struct snd_usb_caiaqdev {
         struct snd_pcm_substream *sub_capture[MAX_STREAMS];
 
         /* Controls */
-        unsigned char control_state[64];
+        unsigned char control_state[256];
+        unsigned char ep8_out_buf[2];
 
         /* Linux input */
 #ifdef CONFIG_SND_USB_CAIAQ_INPUT
         struct input_dev *input_dev;
         char phys[64];                  /* physical device path */
-        unsigned short keycode[64];
+        unsigned short keycode[128];
         struct urb *ep4_in_urb;
         unsigned char ep4_in_buf[EP4_BUFSIZE];
 #endif
diff --git a/sound/usb/caiaq/input.c b/sound/usb/caiaq/input.c
index dcb620796d9e..4432ef7a70a9 100644
--- a/sound/usb/caiaq/input.c
+++ b/sound/usb/caiaq/input.c
@@ -67,7 +67,12 @@ static unsigned short keycode_kore[] = {
         KEY_BRL_DOT5
 };
 
-#define KONTROLX1_INPUTS 40
+#define KONTROLX1_INPUTS        (40)
+#define KONTROLS4_BUTTONS       (12 * 8)
+#define KONTROLS4_AXIS          (46)
+
+#define KONTROLS4_BUTTON(X)     ((X) + BTN_MISC)
+#define KONTROLS4_ABS(X)        ((X) + ABS_HAT0X)
 
 #define DEG90           (range / 2)
 #define DEG180          (range)
@@ -139,6 +144,13 @@ static unsigned int decode_erp(unsigned char a, unsigned char b)
 #undef HIGH_PEAK
 #undef LOW_PEAK
 
+static inline void snd_caiaq_input_report_abs(struct snd_usb_caiaqdev *dev,
+                                              int axis, const unsigned char *buf,
+                                              int offset)
+{
+        input_report_abs(dev->input_dev, axis,
+                         (buf[offset * 2] << 8) | buf[offset * 2 + 1]);
+}
 
 static void snd_caiaq_input_read_analog(struct snd_usb_caiaqdev *dev,
                                         const unsigned char *buf,
@@ -148,36 +160,30 @@ static void snd_caiaq_input_read_analog(struct snd_usb_caiaqdev *dev,
 
         switch (dev->chip.usb_id) {
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2):
-                input_report_abs(input_dev, ABS_X, (buf[4] << 8) | buf[5]);
-                input_report_abs(input_dev, ABS_Y, (buf[0] << 8) | buf[1]);
-                input_report_abs(input_dev, ABS_Z, (buf[2] << 8) | buf[3]);
-                input_sync(input_dev);
+                snd_caiaq_input_report_abs(dev, ABS_X, buf, 2);
+                snd_caiaq_input_report_abs(dev, ABS_Y, buf, 0);
+                snd_caiaq_input_report_abs(dev, ABS_Z, buf, 1);
                 break;
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
-                input_report_abs(input_dev, ABS_X, (buf[0] << 8) | buf[1]);
-                input_report_abs(input_dev, ABS_Y, (buf[2] << 8) | buf[3]);
-                input_report_abs(input_dev, ABS_Z, (buf[4] << 8) | buf[5]);
-                input_sync(input_dev);
-                break;
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2):
-                input_report_abs(input_dev, ABS_X, (buf[0] << 8) | buf[1]);
-                input_report_abs(input_dev, ABS_Y, (buf[2] << 8) | buf[3]);
-                input_report_abs(input_dev, ABS_Z, (buf[4] << 8) | buf[5]);
-                input_sync(input_dev);
+                snd_caiaq_input_report_abs(dev, ABS_X, buf, 0);
+                snd_caiaq_input_report_abs(dev, ABS_Y, buf, 1);
+                snd_caiaq_input_report_abs(dev, ABS_Z, buf, 2);
                 break;
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
-                input_report_abs(input_dev, ABS_HAT0X, (buf[8] << 8)  | buf[9]);
-                input_report_abs(input_dev, ABS_HAT0Y, (buf[4] << 8)  | buf[5]);
-                input_report_abs(input_dev, ABS_HAT1X, (buf[12] << 8) | buf[13]);
-                input_report_abs(input_dev, ABS_HAT1Y, (buf[2] << 8)  | buf[3]);
-                input_report_abs(input_dev, ABS_HAT2X, (buf[14] << 8) | buf[15]);
-                input_report_abs(input_dev, ABS_HAT2Y, (buf[0] << 8)  | buf[1]);
-                input_report_abs(input_dev, ABS_HAT3X, (buf[10] << 8) | buf[11]);
-                input_report_abs(input_dev, ABS_HAT3Y, (buf[6] << 8)  | buf[7]);
-                input_sync(input_dev);
+                snd_caiaq_input_report_abs(dev, ABS_HAT0X, buf, 4);
+                snd_caiaq_input_report_abs(dev, ABS_HAT0Y, buf, 2);
+                snd_caiaq_input_report_abs(dev, ABS_HAT1X, buf, 6);
+                snd_caiaq_input_report_abs(dev, ABS_HAT1Y, buf, 1);
+                snd_caiaq_input_report_abs(dev, ABS_HAT2X, buf, 7);
+                snd_caiaq_input_report_abs(dev, ABS_HAT2Y, buf, 0);
+                snd_caiaq_input_report_abs(dev, ABS_HAT3X, buf, 5);
+                snd_caiaq_input_report_abs(dev, ABS_HAT3Y, buf, 3);
                 break;
         }
+
+        input_sync(input_dev);
 }
 
 static void snd_caiaq_input_read_erp(struct snd_usb_caiaqdev *dev,
@@ -250,6 +256,150 @@ static void snd_caiaq_input_read_io(struct snd_usb_caiaqdev *dev,
         input_sync(input_dev);
 }
 
+#define TKS4_MSGBLOCK_SIZE      16
+
+static void snd_usb_caiaq_tks4_dispatch(struct snd_usb_caiaqdev *dev,
+                                        const unsigned char *buf,
+                                        unsigned int len)
+{
+        while (len) {
+                unsigned int i, block_id = (buf[0] << 8) | buf[1];
+
+                switch (block_id) {
+                case 0:
+                        /* buttons */
+                        for (i = 0; i < KONTROLS4_BUTTONS; i++)
+                                input_report_key(dev->input_dev, KONTROLS4_BUTTON(i),
+                                                 (buf[4 + (i / 8)] >> (i % 8)) & 1);
+                        break;
+
+                case 1:
+                        /* left wheel */
+                        input_report_abs(dev->input_dev, KONTROLS4_ABS(36), buf[9] | ((buf[8] & 0x3) << 8));
+                        /* right wheel */
+                        input_report_abs(dev->input_dev, KONTROLS4_ABS(37), buf[13] | ((buf[12] & 0x3) << 8));
+
+                        /* rotary encoders */
+                        input_report_abs(dev->input_dev, KONTROLS4_ABS(38), buf[3] & 0xf);
+                        input_report_abs(dev->input_dev, KONTROLS4_ABS(39), buf[4] >> 4);
+                        input_report_abs(dev->input_dev, KONTROLS4_ABS(40), buf[4] & 0xf);
+                        input_report_abs(dev->input_dev, KONTROLS4_ABS(41), buf[5] >> 4);
+                        input_report_abs(dev->input_dev, KONTROLS4_ABS(42), buf[5] & 0xf);
+                        input_report_abs(dev->input_dev, KONTROLS4_ABS(43), buf[6] >> 4);
+                        input_report_abs(dev->input_dev, KONTROLS4_ABS(44), buf[6] & 0xf);
+                        input_report_abs(dev->input_dev, KONTROLS4_ABS(45), buf[7] >> 4);
+                        input_report_abs(dev->input_dev, KONTROLS4_ABS(46), buf[7] & 0xf);
+
+                        break;
+                case 2:
+                        /* Volume Fader Channel D */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(0), buf, 1);
+                        /* Volume Fader Channel B */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(1), buf, 2);
+                        /* Volume Fader Channel A */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(2), buf, 3);
+                        /* Volume Fader Channel C */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(3), buf, 4);
+                        /* Loop Volume */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(4), buf, 6);
+                        /* Crossfader */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(7), buf, 7);
+
+                        break;
+
+                case 3:
+                        /* Tempo Fader R */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(6), buf, 3);
+                        /* Tempo Fader L */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(5), buf, 4);
+                        /* Mic Volume */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(8), buf, 6);
+                        /* Cue Mix */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(9), buf, 7);
+
+                        break;
+
+                case 4:
+                        /* Wheel distance sensor L */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(10), buf, 1);
+                        /* Wheel distance sensor R */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(11), buf, 2);
+                        /* Channel D EQ - Filter */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(12), buf, 3);
+                        /* Channel D EQ - Low */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(13), buf, 4);
+                        /* Channel D EQ - Mid */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(14), buf, 5);
+                        /* Channel D EQ - Hi */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(15), buf, 6);
+                        /* FX2 - dry/wet */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(16), buf, 7);
+
+                        break;
+
+                case 5:
+                        /* FX2 - 1 */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(17), buf, 1);
+                        /* FX2 - 2 */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(18), buf, 2);
+                        /* FX2 - 3 */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(19), buf, 3);
+                        /* Channel B EQ - Filter */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(20), buf, 4);
+                        /* Channel B EQ - Low */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(21), buf, 5);
+                        /* Channel B EQ - Mid */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(22), buf, 6);
+                        /* Channel B EQ - Hi */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(23), buf, 7);
+
+                        break;
+
+                case 6:
+                        /* Channel A EQ - Filter */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(24), buf, 1);
+                        /* Channel A EQ - Low */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(25), buf, 2);
+                        /* Channel A EQ - Mid */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(26), buf, 3);
+                        /* Channel A EQ - Hi */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(27), buf, 4);
+                        /* Channel C EQ - Filter */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(28), buf, 5);
+                        /* Channel C EQ - Low */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(29), buf, 6);
+                        /* Channel C EQ - Mid */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(30), buf, 7);
+
+                        break;
+
+                case 7:
+                        /* Channel C EQ - Hi */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(31), buf, 1);
+                        /* FX1 - wet/dry */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(32), buf, 2);
+                        /* FX1 - 1 */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(33), buf, 3);
+                        /* FX1 - 2 */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(34), buf, 4);
+                        /* FX1 - 3 */
+                        snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(35), buf, 5);
+
+                        break;
+
+                default:
+                        debug("%s(): bogus block (id %d)\n",
+                                __func__, block_id);
+                        return;
+                }
+
+                len -= TKS4_MSGBLOCK_SIZE;
+                buf += TKS4_MSGBLOCK_SIZE;
+        }
+
+        input_sync(dev->input_dev);
+}
+
 static void snd_usb_caiaq_ep4_reply_dispatch(struct urb *urb)
 {
         struct snd_usb_caiaqdev *dev = urb->context;
@@ -259,11 +409,11 @@ static void snd_usb_caiaq_ep4_reply_dispatch(struct urb *urb)
         if (urb->status || !dev || urb != dev->ep4_in_urb)
                 return;
 
-        if (urb->actual_length < 24)
-                goto requeue;
-
         switch (dev->chip.usb_id) {
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
+                if (urb->actual_length < 24)
+                        goto requeue;
+
                 if (buf[0] & 0x3)
                         snd_caiaq_input_read_io(dev, buf + 1, 7);
 
@@ -271,6 +421,10 @@ static void snd_usb_caiaq_ep4_reply_dispatch(struct urb *urb)
                         snd_caiaq_input_read_analog(dev, buf + 8, 16);
 
                 break;
+
+        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
+                snd_usb_caiaq_tks4_dispatch(dev, buf, urb->actual_length);
+                break;
         }
 
 requeue:
@@ -289,6 +443,7 @@ static int snd_usb_caiaq_input_open(struct input_dev *idev)
 
         switch (dev->chip.usb_id) {
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
+        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
                 if (usb_submit_urb(dev->ep4_in_urb, GFP_KERNEL) != 0)
                         return -EIO;
                 break;
@@ -306,6 +461,7 @@ static void snd_usb_caiaq_input_close(struct input_dev *idev)
 
         switch (dev->chip.usb_id) {
         case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
+        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
                 usb_kill_urb(dev->ep4_in_urb);
                 break;
         }
@@ -456,6 +612,46 @@ int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev *dev)
                 snd_usb_caiaq_set_auto_msg(dev, 1, 10, 5);
 
                 break;
+
+        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
+                input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+                BUILD_BUG_ON(sizeof(dev->keycode) < KONTROLS4_BUTTONS);
+                for (i = 0; i < KONTROLS4_BUTTONS; i++)
+                        dev->keycode[i] = KONTROLS4_BUTTON(i);
+                input->keycodemax = KONTROLS4_BUTTONS;
+
+                for (i = 0; i < KONTROLS4_AXIS; i++) {
+                        int axis = KONTROLS4_ABS(i);
+                        input->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
+                }
+
+                /* 36 analog potentiometers and faders */
+                for (i = 0; i < 36; i++)
+                        input_set_abs_params(input, KONTROLS4_ABS(i), 0, 0xfff, 0, 10);
+
+                /* 2 encoder wheels */
+                input_set_abs_params(input, KONTROLS4_ABS(36), 0, 0x3ff, 0, 1);
+                input_set_abs_params(input, KONTROLS4_ABS(37), 0, 0x3ff, 0, 1);
+
+                /* 9 rotary encoders */
+                for (i = 0; i < 9; i++)
+                        input_set_abs_params(input, KONTROLS4_ABS(38+i), 0, 0xf, 0, 1);
+
+                dev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL);
+                if (!dev->ep4_in_urb) {
+                        ret = -ENOMEM;
+                        goto exit_free_idev;
+                }
+
+                usb_fill_bulk_urb(dev->ep4_in_urb, usb_dev,
+                                  usb_rcvbulkpipe(usb_dev, 0x4),
+                                  dev->ep4_in_buf, EP4_BUFSIZE,
+                                  snd_usb_caiaq_ep4_reply_dispatch, dev);
+
+                snd_usb_caiaq_set_auto_msg(dev, 1, 10, 5);
+
+                break;
+
         default:
                 /* no input methods supported on this device */
                 goto exit_free_idev;
diff --git a/sound/usb/card.c b/sound/usb/card.c
index 7a8ac1d81be7..800f7cb4f251 100644
--- a/sound/usb/card.c
+++ b/sound/usb/card.c
@@ -126,7 +126,7 @@ static void snd_usb_stream_disconnect(struct list_head *head)
         for (idx = 0; idx < 2; idx++) {
                 subs = &as->substream[idx];
                 if (!subs->num_formats)
-                        return;
+                        continue;
                 snd_usb_release_substream_urbs(subs, 1);
                 subs->interface = -1;
         }
@@ -216,8 +216,13 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
         }
 
         switch (protocol) {
+        default:
+                snd_printdd(KERN_WARNING "unknown interface protocol %#02x, assuming v1\n",
+                            protocol);
+                /* fall through */
+
         case UAC_VERSION_1: {
-                struct uac_ac_header_descriptor_v1 *h1 = control_header;
+                struct uac1_ac_header_descriptor *h1 = control_header;
 
                 if (!h1->bInCollection) {
                         snd_printk(KERN_INFO "skipping empty audio interface (v1)\n");
@@ -253,10 +258,6 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
 
                 break;
         }
-
-        default:
-                snd_printk(KERN_ERR "unknown protocol version 0x%02x\n", protocol);
-                return -EINVAL;
         }
 
         return 0;
@@ -299,9 +300,13 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx,
 
         *rchip = NULL;
 
-        if (snd_usb_get_speed(dev) != USB_SPEED_LOW &&
-            snd_usb_get_speed(dev) != USB_SPEED_FULL &&
-            snd_usb_get_speed(dev) != USB_SPEED_HIGH) {
+        switch (snd_usb_get_speed(dev)) {
+        case USB_SPEED_LOW:
+        case USB_SPEED_FULL:
+        case USB_SPEED_HIGH:
+        case USB_SPEED_SUPER:
+                break;
+        default:
                 snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
                 return -ENXIO;
         }
@@ -377,11 +382,22 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx,
         if (len < sizeof(card->longname))
                 usb_make_path(dev, card->longname + len, sizeof(card->longname) - len);
 
-        strlcat(card->longname,
-                snd_usb_get_speed(dev) == USB_SPEED_LOW ? ", low speed" :
-                snd_usb_get_speed(dev) == USB_SPEED_FULL ? ", full speed" :
-                ", high speed",
-                sizeof(card->longname));
+        switch (snd_usb_get_speed(dev)) {
+        case USB_SPEED_LOW:
+                strlcat(card->longname, ", low speed", sizeof(card->longname));
+                break;
+        case USB_SPEED_FULL:
+                strlcat(card->longname, ", full speed", sizeof(card->longname));
+                break;
+        case USB_SPEED_HIGH:
+                strlcat(card->longname, ", high speed", sizeof(card->longname));
+                break;
+        case USB_SPEED_SUPER:
+                strlcat(card->longname, ", super speed", sizeof(card->longname));
+                break;
+        default:
+                break;
+        }
 
         snd_usb_audio_create_proc(chip);
 
@@ -465,7 +481,13 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
                         goto __error;
         }
 
-        chip->ctrl_intf = alts;
+        /*
+         * For devices with more than one control interface, we assume the
+         * first contains the audio controls. We might need a more specific
+         * check here in the future.
+         */
+        if (!chip->ctrl_intf)
+                chip->ctrl_intf = alts;
 
         if (err > 0) {
                 /* create normal USB audio interfaces */
diff --git a/sound/usb/clock.c b/sound/usb/clock.c
index b5855114667e..7754a1034545 100644
--- a/sound/usb/clock.c
+++ b/sound/usb/clock.c
@@ -19,33 +19,19 @@
 
 #include <linux/bitops.h>
 #include <linux/init.h>
-#include <linux/list.h>
-#include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/usb.h>
-#include <linux/moduleparam.h>
-#include <linux/mutex.h>
 #include <linux/usb/audio.h>
 #include <linux/usb/audio-v2.h>
 
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/pcm.h>
-#include <sound/pcm_params.h>
-#include <sound/initval.h>
 
 #include "usbaudio.h"
 #include "card.h"
-#include "midi.h"
-#include "mixer.h"
-#include "proc.h"
-#include "quirks.h"
-#include "endpoint.h"
 #include "helper.h"
-#include "debug.h"
-#include "pcm.h"
-#include "urb.h"
-#include "format.h"
+#include "clock.h"
 
 static struct uac_clock_source_descriptor *
         snd_usb_find_clock_source(struct usb_host_interface *ctrl_iface,
@@ -134,10 +120,7 @@ static bool uac_clock_source_is_valid(struct snd_usb_audio *chip, int source_id)
         return !!data;
 }
 
-/* Try to find the clock source ID of a given clock entity */
-
 static int __uac_clock_find_source(struct snd_usb_audio *chip,
-                                   struct usb_host_interface *host_iface,
                                    int entity_id, unsigned long *visited)
 {
         struct uac_clock_source_descriptor *source;
@@ -154,11 +137,11 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip,
         }
 
         /* first, see if the ID we're looking for is a clock source already */
-        source = snd_usb_find_clock_source(host_iface, entity_id);
+        source = snd_usb_find_clock_source(chip->ctrl_intf, entity_id);
         if (source)
                 return source->bClockID;
 
-        selector = snd_usb_find_clock_selector(host_iface, entity_id);
+        selector = snd_usb_find_clock_selector(chip->ctrl_intf, entity_id);
         if (selector) {
                 int ret;
 
@@ -168,6 +151,8 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip,
                 if (ret < 0)
                         return ret;
 
+                /* Selector values are one-based */
+
                 if (ret > selector->bNrInPins || ret < 1) {
                         printk(KERN_ERR
                                 "%s(): selector reported illegal value, id %d, ret %d\n",
@@ -176,27 +161,35 @@ static int __uac_clock_find_source(struct snd_usb_audio *chip,
                         return -EINVAL;
                 }
 
-                return __uac_clock_find_source(chip, host_iface,
-                                               selector->baCSourceID[ret-1],
+                return __uac_clock_find_source(chip, selector->baCSourceID[ret-1],
                                                visited);
         }
 
         /* FIXME: multipliers only act as pass-thru element for now */
-        multiplier = snd_usb_find_clock_multiplier(host_iface, entity_id);
+        multiplier = snd_usb_find_clock_multiplier(chip->ctrl_intf, entity_id);
         if (multiplier)
-                return __uac_clock_find_source(chip, host_iface,
-                                               multiplier->bCSourceID, visited);
+                return __uac_clock_find_source(chip, multiplier->bCSourceID,
+                                                visited);
 
         return -EINVAL;
 }
 
-int snd_usb_clock_find_source(struct snd_usb_audio *chip,
-                              struct usb_host_interface *host_iface,
-                              int entity_id)
+/*
+ * For all kinds of sample rate settings and other device queries,
+ * the clock source (end-leaf) must be used. However, clock selectors,
+ * clock multipliers and sample rate converters may be specified as
+ * clock source input to terminal. This functions walks the clock path
+ * to its end and tries to find the source.
+ *
+ * The 'visited' bitfield is used internally to detect recursive loops.
+ *
+ * Returns the clock source UnitID (>=0) on success, or an error.
+ */
+int snd_usb_clock_find_source(struct snd_usb_audio *chip, int entity_id)
 {
         DECLARE_BITMAP(visited, 256);
         memset(visited, 0, sizeof(visited));
-        return __uac_clock_find_source(chip, host_iface, entity_id, visited);
+        return __uac_clock_find_source(chip, entity_id, visited);
 }
 
 static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface,
@@ -211,11 +204,8 @@ static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface,
         ep = get_endpoint(alts, 0)->bEndpointAddress;
 
         /* if endpoint doesn't have sampling rate control, bail out */
-        if (!(fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE)) {
-                snd_printk(KERN_WARNING "%d:%d:%d: endpoint lacks sample rate attribute bit, cannot set.\n",
-                                   dev->devnum, iface, fmt->altsetting);
+        if (!(fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE))
                 return 0;
-        }
 
         data[0] = rate;
         data[1] = rate >> 8;
@@ -254,12 +244,13 @@ static int set_sample_rate_v2(struct snd_usb_audio *chip, int iface,
         struct usb_device *dev = chip->dev;
         unsigned char data[4];
         int err, crate;
-        int clock = snd_usb_clock_find_source(chip, chip->ctrl_intf, fmt->clock);
+        int clock = snd_usb_clock_find_source(chip, fmt->clock);
 
         if (clock < 0)
                 return clock;
 
         if (!uac_clock_source_is_valid(chip, clock)) {
+                /* TODO: should we try to find valid clock setups by ourself? */
                 snd_printk(KERN_ERR "%d:%d:%d: clock source %d is not valid, cannot use\n",
                            dev->devnum, iface, fmt->altsetting, clock);
                 return -ENXIO;
@@ -304,12 +295,11 @@ int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
 
         switch (altsd->bInterfaceProtocol) {
         case UAC_VERSION_1:
+        default:
                 return set_sample_rate_v1(chip, iface, alts, fmt, rate);
 
         case UAC_VERSION_2:
                 return set_sample_rate_v2(chip, iface, alts, fmt, rate);
         }
-
-        return -EINVAL;
 }
 
diff --git a/sound/usb/clock.h b/sound/usb/clock.h
index beb253684e2d..46630936d31f 100644
--- a/sound/usb/clock.h
+++ b/sound/usb/clock.h
@@ -5,8 +5,6 @@ int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
                              struct usb_host_interface *alts,
                              struct audioformat *fmt, int rate);
 
-int snd_usb_clock_find_source(struct snd_usb_audio *chip,
-                              struct usb_host_interface *host_iface,
-                              int entity_id);
+int snd_usb_clock_find_source(struct snd_usb_audio *chip, int entity_id);
 
 #endif /* __USBAUDIO_CLOCK_H */
diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c
index 6f6596cf2b19..b0ef9f501896 100644
--- a/sound/usb/endpoint.c
+++ b/sound/usb/endpoint.c
@@ -33,6 +33,7 @@
 #include "pcm.h"
 #include "helper.h"
 #include "format.h"
+#include "clock.h"
 
 /*
  * free a substream
@@ -274,8 +275,14 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
 
                 /* get audio formats */
                 switch (protocol) {
+                default:
+                        snd_printdd(KERN_WARNING "%d:%u:%d: unknown interface protocol %#02x, assuming v1\n",
+                                    dev->devnum, iface_no, altno, protocol);
+                        protocol = UAC_VERSION_1;
+                        /* fall through */
+
                 case UAC_VERSION_1: {
-                        struct uac_as_header_descriptor_v1 *as =
+                        struct uac1_as_header_descriptor *as =
                                 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
 
                         if (!as) {
@@ -297,7 +304,7 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                 case UAC_VERSION_2: {
                         struct uac2_input_terminal_descriptor *input_term;
                         struct uac2_output_terminal_descriptor *output_term;
-                        struct uac_as_header_descriptor_v2 *as =
+                        struct uac2_as_header_descriptor *as =
                                 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
 
                         if (!as) {
@@ -335,11 +342,6 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                                    dev->devnum, iface_no, altno, as->bTerminalLink);
                         continue;
                 }
-
-                default:
-                        snd_printk(KERN_ERR "%d:%u:%d : unknown interface protocol %04x\n",
-                                   dev->devnum, iface_no, altno, protocol);
-                        continue;
                 }
 
                 /* get format type */
@@ -403,8 +405,6 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                         break;
                 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
                 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
-                case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra 8 */
-                case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
                         /* doesn't set the sample rate attribute, but supports it */
                         fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;
                         break;
diff --git a/sound/usb/format.c b/sound/usb/format.c
index 30364aba79cc..69148212aa70 100644
--- a/sound/usb/format.c
+++ b/sound/usb/format.c
@@ -49,7 +49,8 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip,
         u64 pcm_formats;
 
         switch (protocol) {
-        case UAC_VERSION_1: {
+        case UAC_VERSION_1:
+        default: {
                 struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
                 sample_width = fmt->bBitResolution;
                 sample_bytes = fmt->bSubframeSize;
@@ -64,9 +65,6 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip,
                 format <<= 1;
                 break;
         }
-
-        default:
-                return -EINVAL;
         }
 
         pcm_formats = 0;
@@ -264,13 +262,12 @@ static int parse_uac2_sample_rate_range(struct audioformat *fp, int nr_triplets,
  * on the audioformat table (audio class v2).
  */
 static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
-                                       struct audioformat *fp,
-                                       struct usb_host_interface *iface)
+                                       struct audioformat *fp)
 {
         struct usb_device *dev = chip->dev;
         unsigned char tmp[2], *data;
         int nr_triplets, data_size, ret = 0;
-        int clock = snd_usb_clock_find_source(chip, chip->ctrl_intf, fp->clock);
+        int clock = snd_usb_clock_find_source(chip, fp->clock);
 
         if (clock < 0) {
                 snd_printk(KERN_ERR "%s(): unable to find clock source (clock %d)\n",
@@ -385,13 +382,17 @@ static int parse_audio_format_i(struct snd_usb_audio *chip,
          * audio class v2 uses class specific EP0 range requests for that.
          */
         switch (protocol) {
+        default:
+                snd_printdd(KERN_WARNING "%d:%u:%d : invalid protocol version %d, assuming v1\n",
+                           chip->dev->devnum, fp->iface, fp->altsetting, protocol);
+                /* fall through */
         case UAC_VERSION_1:
                 fp->channels = fmt->bNrChannels;
                 ret = parse_audio_format_rates_v1(chip, fp, (unsigned char *) fmt, 7);
                 break;
         case UAC_VERSION_2:
                 /* fp->channels is already set in this case */
-                ret = parse_audio_format_rates_v2(chip, fp, iface);
+                ret = parse_audio_format_rates_v2(chip, fp);
                 break;
         }
 
@@ -435,6 +436,10 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip,
         fp->channels = 1;
 
         switch (protocol) {
+        default:
+                snd_printdd(KERN_WARNING "%d:%u:%d : invalid protocol version %d, assuming v1\n",
+                           chip->dev->devnum, fp->iface, fp->altsetting, protocol);
+                /* fall through */
         case UAC_VERSION_1: {
                 struct uac_format_type_ii_discrete_descriptor *fmt = _fmt;
                 brate = le16_to_cpu(fmt->wMaxBitRate);
@@ -450,7 +455,7 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip,
                 framesize = le16_to_cpu(fmt->wSamplesPerFrame);
                 snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
                 fp->frame_size = framesize;
-                ret = parse_audio_format_rates_v2(chip, fp, iface);
+                ret = parse_audio_format_rates_v2(chip, fp);
                 break;
         }
         }
diff --git a/sound/usb/helper.c b/sound/usb/helper.c
index d48d6f8f6ac9..f280c1903c25 100644
--- a/sound/usb/helper.c
+++ b/sound/usb/helper.c
@@ -103,11 +103,16 @@ int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
 unsigned char snd_usb_parse_datainterval(struct snd_usb_audio *chip,
                                          struct usb_host_interface *alts)
 {
-        if (snd_usb_get_speed(chip->dev) == USB_SPEED_HIGH &&
-            get_endpoint(alts, 0)->bInterval >= 1 &&
-            get_endpoint(alts, 0)->bInterval <= 4)
-                return get_endpoint(alts, 0)->bInterval - 1;
-        else
-                return 0;
+        switch (snd_usb_get_speed(chip->dev)) {
+        case USB_SPEED_HIGH:
+        case USB_SPEED_SUPER:
+                if (get_endpoint(alts, 0)->bInterval >= 1 &&
+                    get_endpoint(alts, 0)->bInterval <= 4)
+                        return get_endpoint(alts, 0)->bInterval - 1;
+                break;
+        default:
+                break;
+        }
+        return 0;
 }
 
diff --git a/sound/usb/midi.c b/sound/usb/midi.c
index 46785643c66d..156cd0716c42 100644
--- a/sound/usb/midi.c
+++ b/sound/usb/midi.c
@@ -434,7 +434,7 @@ static void snd_usbmidi_maudio_broken_running_status_input(
                         u8 cin = buffer[i] & 0x0f;
                         struct usbmidi_in_port *port = &ep->ports[cable];
                         int length;
-                        
+
                         length = snd_usbmidi_cin_length[cin];
                         if (cin == 0xf && buffer[i + 1] >= 0xf8)
                                 ; /* realtime msg: no running status change */
@@ -628,13 +628,13 @@ static struct usb_protocol_ops snd_usbmidi_standard_ops = {
 
 static struct usb_protocol_ops snd_usbmidi_midiman_ops = {
         .input = snd_usbmidi_midiman_input,
-        .output = snd_usbmidi_standard_output, 
+        .output = snd_usbmidi_standard_output,
         .output_packet = snd_usbmidi_output_midiman_packet,
 };
 
 static struct usb_protocol_ops snd_usbmidi_maudio_broken_running_status_ops = {
         .input = snd_usbmidi_maudio_broken_running_status_input,
-        .output = snd_usbmidi_standard_output, 
+        .output = snd_usbmidi_standard_output,
         .output_packet = snd_usbmidi_output_standard_packet,
 };
 
@@ -834,7 +834,14 @@ static void snd_usbmidi_us122l_output(struct snd_usb_midi_out_endpoint *ep,
 
         if (!ep->ports[0].active)
                 return;
-        count = snd_usb_get_speed(ep->umidi->dev) == USB_SPEED_HIGH ? 1 : 2;
+        switch (snd_usb_get_speed(ep->umidi->dev)) {
+        case USB_SPEED_HIGH:
+        case USB_SPEED_SUPER:
+                count = 1;
+                break;
+        default:
+                count = 2;
+        }
         count = snd_rawmidi_transmit(ep->ports[0].substream,
                                      urb->transfer_buffer,
                                      count);
@@ -1248,7 +1255,7 @@ static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint *ep
  */
 static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi,
                                            struct snd_usb_midi_endpoint_info* ep_info,
-                                           struct snd_usb_midi_endpoint* rep)
+                                           struct snd_usb_midi_endpoint* rep)
 {
         struct snd_usb_midi_out_endpoint* ep;
         unsigned int i;
@@ -1398,7 +1405,7 @@ static void snd_usbmidi_rawmidi_free(struct snd_rawmidi *rmidi)
 }
 
 static struct snd_rawmidi_substream *snd_usbmidi_find_substream(struct snd_usb_midi* umidi,
-                                                           int stream, int number)
+                                                                int stream, int number)
 {
         struct list_head* list;
 
@@ -1811,7 +1818,7 @@ static int snd_usbmidi_detect_endpoints(struct snd_usb_midi* umidi,
                 snd_usbmidi_switch_roland_altsetting(umidi);
 
         if (endpoint[0].out_ep || endpoint[0].in_ep)
-                return 0;       
+                return 0;
 
         intf = umidi->iface;
         if (!intf || intf->num_altsetting < 1)
@@ -1849,7 +1856,7 @@ static int snd_usbmidi_detect_per_port_endpoints(struct snd_usb_midi* umidi,
                                                  struct snd_usb_midi_endpoint_info* endpoints)
 {
         int err, i;
-        
+
         err = snd_usbmidi_detect_endpoints(umidi, endpoints, MIDI_MAX_ENDPOINTS);
         for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
                 if (endpoints[i].out_ep)
diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
index 736d134cc03c..f2d74d654b3c 100644
--- a/sound/usb/mixer.c
+++ b/sound/usb/mixer.c
@@ -26,6 +26,22 @@
  *
  */
 
+/*
+ * TODOs, for both the mixer and the streaming interfaces:
+ *
+ *  - support for UAC2 effect units
+ *  - support for graphical equalizers
+ *  - RANGE and MEM set commands (UAC2)
+ *  - RANGE and MEM interrupt dispatchers (UAC2)
+ *  - audio channel clustering (UAC2)
+ *  - audio sample rate converter units (UAC2)
+ *  - proper handling of clock multipliers (UAC2)
+ *  - dispatch clock change notifications (UAC2)
+ *      - stop PCM streams which use a clock that became invalid
+ *      - stop PCM streams which use a clock selector that has changed
+ *      - parse available sample rates again when clock sources changed
+ */
+
 #include <linux/bitops.h>
 #include <linux/init.h>
 #include <linux/list.h>
@@ -275,28 +291,28 @@ static int get_abs_value(struct usb_mixer_elem_info *cval, int val)
 
 static int get_ctl_value_v1(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
 {
+        struct snd_usb_audio *chip = cval->mixer->chip;
         unsigned char buf[2];
         int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
         int timeout = 10;
 
         while (timeout-- > 0) {
-                if (snd_usb_ctl_msg(cval->mixer->chip->dev,
-                                    usb_rcvctrlpipe(cval->mixer->chip->dev, 0),
-                                    request,
+                if (snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), request,
                                     USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
-                                    validx, cval->mixer->ctrlif | (cval->id << 8),
+                                    validx, snd_usb_ctrl_intf(chip) | (cval->id << 8),
                                     buf, val_len, 100) >= val_len) {
                         *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
                         return 0;
                 }
         }
         snd_printdd(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
-                    request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type);
+                    request, validx, snd_usb_ctrl_intf(chip) | (cval->id << 8), cval->val_type);
         return -EINVAL;
 }
 
 static int get_ctl_value_v2(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
 {
+        struct snd_usb_audio *chip = cval->mixer->chip;
         unsigned char buf[2 + 3*sizeof(__u16)]; /* enough space for one range */
         unsigned char *val;
         int ret, size;
@@ -312,16 +328,14 @@ static int get_ctl_value_v2(struct usb_mixer_elem_info *cval, int request, int v
 
         memset(buf, 0, sizeof(buf));
 
-        ret = snd_usb_ctl_msg(cval->mixer->chip->dev,
-                              usb_rcvctrlpipe(cval->mixer->chip->dev, 0),
-                              bRequest,
+        ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), bRequest,
                               USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
-                              validx, cval->mixer->ctrlif | (cval->id << 8),
+                              validx, snd_usb_ctrl_intf(chip) | (cval->id << 8),
                               buf, size, 1000);
 
         if (ret < 0) {
                 snd_printk(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
-                           request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type);
+                           request, validx, snd_usb_ctrl_intf(chip) | (cval->id << 8), cval->val_type);
                 return ret;
         }
 
@@ -397,6 +411,7 @@ static int get_cur_mix_value(struct usb_mixer_elem_info *cval,
 int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
                                 int request, int validx, int value_set)
 {
+        struct snd_usb_audio *chip = cval->mixer->chip;
         unsigned char buf[2];
         int val_len, timeout = 10;
 
@@ -419,15 +434,14 @@ int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
         buf[0] = value_set & 0xff;
         buf[1] = (value_set >> 8) & 0xff;
         while (timeout-- > 0)
-                if (snd_usb_ctl_msg(cval->mixer->chip->dev,
-                                    usb_sndctrlpipe(cval->mixer->chip->dev, 0),
-                                    request,
+                if (snd_usb_ctl_msg(chip->dev,
+                                    usb_sndctrlpipe(chip->dev, 0), request,
                                     USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
-                                    validx, cval->mixer->ctrlif | (cval->id << 8),
+                                    validx, snd_usb_ctrl_intf(chip) | (cval->id << 8),
                                     buf, val_len, 100) >= 0)
                         return 0;
         snd_printdd(KERN_ERR "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n",
-                    request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type, buf[0], buf[1]);
+                    request, validx, snd_usb_ctrl_intf(chip) | (cval->id << 8), cval->val_type, buf[0], buf[1]);
         return -EINVAL;
 }
 
@@ -582,9 +596,9 @@ static int get_term_name(struct mixer_build *state, struct usb_audio_term *iterm
                 switch (iterm->type >> 16) {
                 case UAC_SELECTOR_UNIT:
                         strcpy(name, "Selector"); return 8;
-                case UAC_PROCESSING_UNIT_V1:
+                case UAC1_PROCESSING_UNIT:
                         strcpy(name, "Process Unit"); return 12;
-                case UAC_EXTENSION_UNIT_V1:
+                case UAC1_EXTENSION_UNIT:
                         strcpy(name, "Ext Unit"); return 8;
                 case UAC_MIXER_UNIT:
                         strcpy(name, "Mixer"); return 5;
@@ -672,8 +686,8 @@ static int check_input_term(struct mixer_build *state, int id, struct usb_audio_
                         term->name = uac_selector_unit_iSelector(d);
                         return 0;
                 }
-                case UAC_PROCESSING_UNIT_V1:
-                case UAC_EXTENSION_UNIT_V1: {
+                case UAC1_PROCESSING_UNIT:
+                case UAC1_EXTENSION_UNIT: {
                         struct uac_processing_unit_descriptor *d = p1;
                         if (d->bNrInPins) {
                                 id = d->baSourceID[0];
@@ -767,7 +781,7 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
                 if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
                     get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
                         snd_printd(KERN_ERR "%d:%d: cannot get min/max values for control %d (id %d)\n",
-                                   cval->id, cval->mixer->ctrlif, cval->control, cval->id);
+                                   cval->id, snd_usb_ctrl_intf(cval->mixer->chip), cval->control, cval->id);
                         return -EINVAL;
                 }
                 if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
@@ -1199,14 +1213,6 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void
                 }
         } else { /* UAC_VERSION_2 */
                 for (i = 0; i < 30/2; i++) {
-                        /* From the USB Audio spec v2.0:
-                           bmaControls() is a (ch+1)-element array of 4-byte bitmaps,
-                           each containing a set of bit pairs. If a Control is present,
-                           it must be Host readable. If a certain Control is not
-                           present then the bit pair must be set to 0b00.
-                           If a Control is present but read-only, the bit pair must be
-                           set to 0b01. If a Control is also Host programmable, the bit
-                           pair must be set to 0b11. The value 0b10 is not allowed. */
                         unsigned int ch_bits = 0;
                         unsigned int ch_read_only = 0;
 
@@ -1634,9 +1640,10 @@ static int mixer_ctl_selector_info(struct snd_kcontrol *kcontrol, struct snd_ctl
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
         uinfo->value.enumerated.items = cval->max;
-        if ((int)uinfo->value.enumerated.item >= cval->max)
+        if (uinfo->value.enumerated.item >= cval->max)
                 uinfo->value.enumerated.item = cval->max - 1;
-        strcpy(uinfo->value.enumerated.name, itemlist[uinfo->value.enumerated.item]);
+        strlcpy(uinfo->value.enumerated.name, itemlist[uinfo->value.enumerated.item],
+                sizeof(uinfo->value.enumerated.name));
         return 0;
 }
 
@@ -1855,13 +1862,13 @@ static int parse_audio_unit(struct mixer_build *state, int unitid)
                 return parse_audio_selector_unit(state, unitid, p1);
         case UAC_FEATURE_UNIT:
                 return parse_audio_feature_unit(state, unitid, p1);
-        case UAC_PROCESSING_UNIT_V1:
+        case UAC1_PROCESSING_UNIT:
         /*   UAC2_EFFECT_UNIT has the same value */
                 if (state->mixer->protocol == UAC_VERSION_1)
                         return parse_audio_processing_unit(state, unitid, p1);
                 else
                         return 0; /* FIXME - effect units not implemented yet */
-        case UAC_EXTENSION_UNIT_V1:
+        case UAC1_EXTENSION_UNIT:
         /*   UAC2_PROCESSING_UNIT_V2 has the same value */
                 if (state->mixer->protocol == UAC_VERSION_1)
                         return parse_audio_extension_unit(state, unitid, p1);
@@ -1905,7 +1912,7 @@ static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
         struct usb_host_interface *hostif;
         void *p;
 
-        hostif = &usb_ifnum_to_if(mixer->chip->dev, mixer->ctrlif)->altsetting[0];
+        hostif = mixer->chip->ctrl_intf;
         memset(&state, 0, sizeof(state));
         state.chip = mixer->chip;
         state.mixer = mixer;
@@ -1925,7 +1932,7 @@ static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
         p = NULL;
         while ((p = snd_usb_find_csint_desc(hostif->extra, hostif->extralen, p, UAC_OUTPUT_TERMINAL)) != NULL) {
                 if (mixer->protocol == UAC_VERSION_1) {
-                        struct uac_output_terminal_descriptor_v1 *desc = p;
+                        struct uac1_output_terminal_descriptor *desc = p;
 
                         if (desc->bLength < sizeof(*desc))
                                 continue; /* invalid descriptor? */
@@ -1997,7 +2004,7 @@ static void snd_usb_mixer_proc_read(struct snd_info_entry *entry,
         list_for_each_entry(mixer, &chip->mixer_list, list) {
                 snd_iprintf(buffer,
                         "USB Mixer: usb_id=0x%08x, ctrlif=%i, ctlerr=%i\n",
-                                chip->usb_id, mixer->ctrlif,
+                                chip->usb_id, snd_usb_ctrl_intf(chip),
                                 mixer->ignore_ctl_error);
                 snd_iprintf(buffer, "Card: %s\n", chip->card->longname);
                 for (unitid = 0; unitid < MAX_ID_ELEMS; unitid++) {
@@ -2115,7 +2122,7 @@ static int snd_usb_mixer_status_create(struct usb_mixer_interface *mixer)
         int buffer_length;
         unsigned int epnum;
 
-        hostif = &usb_ifnum_to_if(mixer->chip->dev, mixer->ctrlif)->altsetting[0];
+        hostif = mixer->chip->ctrl_intf;
         /* we need one interrupt input endpoint */
         if (get_iface_desc(hostif)->bNumEndpoints < 1)
                 return 0;
@@ -2158,7 +2165,6 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
         if (!mixer)
                 return -ENOMEM;
         mixer->chip = chip;
-        mixer->ctrlif = ctrlif;
         mixer->ignore_ctl_error = ignore_error;
         mixer->id_elems = kcalloc(MAX_ID_ELEMS, sizeof(*mixer->id_elems),
                                   GFP_KERNEL);
@@ -2168,7 +2174,15 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
         }
 
         host_iface = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0];
-        mixer->protocol = get_iface_desc(host_iface)->bInterfaceProtocol;
+        switch (get_iface_desc(host_iface)->bInterfaceProtocol) {
+        case UAC_VERSION_1:
+        default:
+                mixer->protocol = UAC_VERSION_1;
+                break;
+        case UAC_VERSION_2:
+                mixer->protocol = UAC_VERSION_2;
+                break;
+        }
 
         if ((err = snd_usb_mixer_controls(mixer)) < 0 ||
             (err = snd_usb_mixer_status_create(mixer)) < 0)
diff --git a/sound/usb/mixer.h b/sound/usb/mixer.h
index a7cf1007fbb0..26c636c5c93a 100644
--- a/sound/usb/mixer.h
+++ b/sound/usb/mixer.h
@@ -3,7 +3,6 @@
 
 struct usb_mixer_interface {
         struct snd_usb_audio *chip;
-        unsigned int ctrlif;
         struct list_head list;
         unsigned int ignore_ctl_error;
         struct urb *urb;
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index 456829882f40..f49756c1b837 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -173,13 +173,12 @@ int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
 
         switch (altsd->bInterfaceProtocol) {
         case UAC_VERSION_1:
+        default:
                 return init_pitch_v1(chip, iface, alts, fmt);
 
         case UAC_VERSION_2:
                 return init_pitch_v2(chip, iface, alts, fmt);
         }
-
-        return -EINVAL;
 }
 
 /*
@@ -467,7 +466,7 @@ static int hw_check_valid_format(struct snd_usb_substream *subs,
                 return 0;
         }
         /* check whether the period time is >= the data packet interval */
-        if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH) {
+        if (snd_usb_get_speed(subs->dev) != USB_SPEED_FULL) {
                 ptime = 125 * (1 << fp->datainterval);
                 if (ptime > pt->max || (ptime == pt->max && pt->openmax)) {
                         hwc_debug("   > check: ptime %u > max %u\n", ptime, pt->max);
@@ -636,7 +635,7 @@ static int hw_rule_period_time(struct snd_pcm_hw_params *params,
                 min_datainterval = min(min_datainterval, fp->datainterval);
         }
         if (min_datainterval == 0xff) {
-                hwc_debug("  --> get emtpy\n");
+                hwc_debug("  --> get empty\n");
                 it->empty = 1;
                 return -EINVAL;
         }
@@ -735,7 +734,7 @@ static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substre
         }
 
         param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME;
-        if (snd_usb_get_speed(subs->dev) != USB_SPEED_HIGH)
+        if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
                 /* full speed devices have fixed data packet interval */
                 ptmin = 1000;
         if (ptmin == 1000)
diff --git a/sound/usb/pcm.h b/sound/usb/pcm.h
index 1c931b68f3b5..ed3e283f618d 100644
--- a/sound/usb/pcm.h
+++ b/sound/usb/pcm.h
@@ -7,8 +7,5 @@ int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
                        struct usb_host_interface *alts,
                        struct audioformat *fmt);
 
-int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface,
-                             struct usb_host_interface *alts,
-                             struct audioformat *fmt, int rate);
 
 #endif /* __USBAUDIO_PCM_H */
diff --git a/sound/usb/proc.c b/sound/usb/proc.c
index f5e3f356b95f..3c650ab3c91d 100644
--- a/sound/usb/proc.c
+++ b/sound/usb/proc.c
@@ -107,7 +107,7 @@ static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct s
                         }
                         snd_iprintf(buffer, "\n");
                 }
-                if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH)
+                if (snd_usb_get_speed(subs->dev) != USB_SPEED_FULL)
                         snd_iprintf(buffer, "    Data packet interval: %d us\n",
                                     125 * (1 << fp->datainterval));
                 // snd_iprintf(buffer, "    Max Packet Size = %d\n", fp->maxpacksize);
diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h
index f8797f61a24b..c86c613e0b96 100644
--- a/sound/usb/quirks-table.h
+++ b/sound/usb/quirks-table.h
@@ -1136,11 +1136,34 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
+        /* has ID 0x0066 when not in "Advanced Driver" mode */
+        USB_DEVICE(0x0582, 0x0064),
+        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
+                /* .vendor_name = "EDIROL", */
+                /* .product_name = "PCR-1", */
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_COMPOSITE,
+                .data = (const struct snd_usb_audio_quirk[]) {
+                        {
+                                .ifnum = 1,
+                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                        },
+                        {
+                                .ifnum = 2,
+                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                        },
+                        {
+                                .ifnum = -1
+                        }
+                }
+        }
+},
+{
         /* has ID 0x0067 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0065),
         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
-                .vendor_name = "EDIROL",
-                .product_name = "PCR-1",
+                /* .vendor_name = "EDIROL", */
+                /* .product_name = "PCR-1", */
                 .ifnum = 0,
                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
                 .data = & (const struct snd_usb_midi_endpoint_info) {
@@ -1525,6 +1548,50 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                 }
         }
 },
+{
+        /* has ID 0x0110 when not in Advanced Driver mode */
+        USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f),
+        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
+                /* .vendor_name = "Roland", */
+                /* .product_name = "A-PRO", */
+                .ifnum = 1,
+                .type = QUIRK_MIDI_FIXED_ENDPOINT,
+                .data = & (const struct snd_usb_midi_endpoint_info) {
+                        .out_cables = 0x0003,
+                        .in_cables  = 0x0007
+                }
+        }
+},
+{
+        USB_DEVICE(0x0582, 0x0113),
+        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
+                /* .vendor_name = "BOSS", */
+                /* .product_name = "ME-25", */
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_COMPOSITE,
+                .data = (const struct snd_usb_audio_quirk[]) {
+                        {
+                                .ifnum = 0,
+                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                        },
+                        {
+                                .ifnum = 1,
+                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                        },
+                        {
+                                .ifnum = 2,
+                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
+                                .data = & (const struct snd_usb_midi_endpoint_info) {
+                                        .out_cables = 0x0001,
+                                        .in_cables  = 0x0001
+                                }
+                        },
+                        {
+                                .ifnum = -1
+                        }
+                }
+        }
+},
 
 /* Guillemot devices */
 {
@@ -1830,7 +1897,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         USB_DEVICE(0x0763, 0x2080),
         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
                 /* .vendor_name = "M-Audio", */
-                /* .product_name = "Fast Track Ultra 8", */
+                /* .product_name = "Fast Track Ultra", */
                 .ifnum = QUIRK_ANY_INTERFACE,
                 .type = QUIRK_COMPOSITE,
                 .data = & (const struct snd_usb_audio_quirk[]) {
@@ -1840,11 +1907,51 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                         },
                         {
                                 .ifnum = 1,
-                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
+                                .data = & (const struct audioformat) {
+                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
+                                        .channels = 8,
+                                        .iface = 1,
+                                        .altsetting = 1,
+                                        .altset_idx = 1,
+                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
+                                        .endpoint = 0x01,
+                                        .ep_attr = 0x09,
+                                        .rates = SNDRV_PCM_RATE_44100 |
+                                                 SNDRV_PCM_RATE_48000 |
+                                                 SNDRV_PCM_RATE_88200 |
+                                                 SNDRV_PCM_RATE_96000,
+                                        .rate_min = 44100,
+                                        .rate_max = 96000,
+                                        .nr_rates = 4,
+                                        .rate_table = (unsigned int[]) {
+                                                44100, 48000, 88200, 96000
+                                        }
+                                }
                         },
                         {
                                 .ifnum = 2,
-                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
+                                .data = & (const struct audioformat) {
+                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
+                                        .channels = 8,
+                                        .iface = 2,
+                                        .altsetting = 1,
+                                        .altset_idx = 1,
+                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
+                                        .endpoint = 0x81,
+                                        .ep_attr = 0x05,
+                                        .rates = SNDRV_PCM_RATE_44100 |
+                                                 SNDRV_PCM_RATE_48000 |
+                                                 SNDRV_PCM_RATE_88200 |
+                                                 SNDRV_PCM_RATE_96000,
+                                        .rate_min = 44100,
+                                        .rate_max = 96000,
+                                        .nr_rates = 4,
+                                        .rate_table = (unsigned int[]) {
+                                                44100, 48000, 88200, 96000
+                                        }
+                                }
                         },
                         /* interface 3 (MIDI) is standard compliant */
                         {
@@ -1867,11 +1974,51 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                         },
                         {
                                 .ifnum = 1,
-                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
+                                .data = & (const struct audioformat) {
+                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
+                                        .channels = 8,
+                                        .iface = 1,
+                                        .altsetting = 1,
+                                        .altset_idx = 1,
+                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
+                                        .endpoint = 0x01,
+                                        .ep_attr = 0x09,
+                                        .rates = SNDRV_PCM_RATE_44100 |
+                                                 SNDRV_PCM_RATE_48000 |
+                                                 SNDRV_PCM_RATE_88200 |
+                                                 SNDRV_PCM_RATE_96000,
+                                        .rate_min = 44100,
+                                        .rate_max = 96000,
+                                        .nr_rates = 4,
+                                        .rate_table = (unsigned int[]) {
+                                                        44100, 48000, 88200, 96000
+                                        }
+                                }
                         },
                         {
                                 .ifnum = 2,
-                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
+                                .data = & (const struct audioformat) {
+                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
+                                        .channels = 8,
+                                        .iface = 2,
+                                        .altsetting = 1,
+                                        .altset_idx = 1,
+                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
+                                        .endpoint = 0x81,
+                                        .ep_attr = 0x05,
+                                        .rates = SNDRV_PCM_RATE_44100 |
+                                                 SNDRV_PCM_RATE_48000 |
+                                                 SNDRV_PCM_RATE_88200 |
+                                                 SNDRV_PCM_RATE_96000,
+                                        .rate_min = 44100,
+                                        .rate_max = 96000,
+                                        .nr_rates = 4,
+                                        .rate_table = (unsigned int[]) {
+                                                44100, 48000, 88200, 96000
+                                        }
+                                }
                         },
                         /* interface 3 (MIDI) is standard compliant */
                         {
@@ -2152,7 +2299,21 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7201),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-850",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                        USB_DEVICE_ID_MATCH_INT_CLASS |
                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2166,7 +2327,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7202),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                        USB_DEVICE_ID_MATCH_INT_CLASS |
                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2180,7 +2341,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7203),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                        USB_DEVICE_ID_MATCH_INT_CLASS |
                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2194,7 +2355,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7204),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                        USB_DEVICE_ID_MATCH_INT_CLASS |
                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2208,7 +2369,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7205),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                        USB_DEVICE_ID_MATCH_INT_CLASS |
                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2222,7 +2383,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7250),
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                        USB_DEVICE_ID_MATCH_INT_CLASS |
                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2236,7 +2397,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
-        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7230),
+        USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
                        USB_DEVICE_ID_MATCH_INT_CLASS |
                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
@@ -2244,7 +2405,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
                 .vendor_name = "Hauppauge",
-                .product_name = "HVR-850",
+                .product_name = "HVR-950Q",
                 .ifnum = QUIRK_ANY_INTERFACE,
                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
         }
diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
index b45e54c09ba2..9a9da09586a5 100644
--- a/sound/usb/quirks.c
+++ b/sound/usb/quirks.c
@@ -32,6 +32,7 @@
 #include "helper.h"
 #include "endpoint.h"
 #include "pcm.h"
+#include "clock.h"
 
 /*
  * handle the quirks for the contained interfaces
diff --git a/sound/usb/urb.c b/sound/usb/urb.c
index de607d4411ac..8deeaad10f10 100644
--- a/sound/usb/urb.c
+++ b/sound/usb/urb.c
@@ -244,7 +244,7 @@ int snd_usb_init_substream_urbs(struct snd_usb_substream *subs,
         else
                 subs->curpacksize = maxsize;
 
-        if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH)
+        if (snd_usb_get_speed(subs->dev) != USB_SPEED_FULL)
                 packs_per_ms = 8 >> subs->datainterval;
         else
                 packs_per_ms = 1;