203 files changed, 10519 insertions, 2938 deletions

diff --git a/sound/Kconfig b/sound/Kconfig
index b65ee4701f98..e0d791a98452 100644
--- a/sound/Kconfig
+++ b/sound/Kconfig
@@ -58,6 +58,8 @@ source "sound/pci/Kconfig"
 
 source "sound/ppc/Kconfig"
 
+source "sound/aoa/Kconfig"
+
 source "sound/arm/Kconfig"
 
 source "sound/mips/Kconfig"
diff --git a/sound/Makefile b/sound/Makefile
index f352bb235968..a682ea30f0c9 100644
--- a/sound/Makefile
+++ b/sound/Makefile
@@ -4,7 +4,7 @@
 obj-$(CONFIG_SOUND) += soundcore.o
 obj-$(CONFIG_SOUND_PRIME) += oss/
 obj-$(CONFIG_DMASOUND) += oss/
-obj-$(CONFIG_SND) += core/ i2c/ drivers/ isa/ pci/ ppc/ arm/ synth/ usb/ sparc/ parisc/ pcmcia/ mips/
+obj-$(CONFIG_SND) += core/ i2c/ drivers/ isa/ pci/ ppc/ arm/ synth/ usb/ sparc/ parisc/ pcmcia/ mips/ aoa/
 
 ifeq ($(CONFIG_SND),y)
   obj-y += last.o
diff --git a/sound/aoa/Kconfig b/sound/aoa/Kconfig
new file mode 100644
index 000000000000..a85194fe0b06
--- /dev/null
+++ b/sound/aoa/Kconfig
@@ -0,0 +1,17 @@
+menu "Apple Onboard Audio driver"
+        depends on SND!=n && PPC
+
+config SND_AOA
+        tristate "Apple Onboard Audio driver"
+        depends on SOUND && SND_PCM
+        ---help---
+        This option enables the new driver for the various
+        Apple Onboard Audio components.
+
+source "sound/aoa/fabrics/Kconfig"
+
+source "sound/aoa/codecs/Kconfig"
+
+source "sound/aoa/soundbus/Kconfig"
+
+endmenu
diff --git a/sound/aoa/Makefile b/sound/aoa/Makefile
new file mode 100644
index 000000000000..d8de3e7df48d
--- /dev/null
+++ b/sound/aoa/Makefile
@@ -0,0 +1,4 @@
+obj-$(CONFIG_SND_AOA) += core/
+obj-$(CONFIG_SND_AOA) += codecs/
+obj-$(CONFIG_SND_AOA) += fabrics/
+obj-$(CONFIG_SND_AOA_SOUNDBUS) += soundbus/
diff --git a/sound/aoa/aoa-gpio.h b/sound/aoa/aoa-gpio.h
new file mode 100644
index 000000000000..3a61f3115573
--- /dev/null
+++ b/sound/aoa/aoa-gpio.h
@@ -0,0 +1,81 @@
+/*
+ * Apple Onboard Audio GPIO definitions
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+
+#ifndef __AOA_GPIO_H
+#define __AOA_GPIO_H
+#include <linux/workqueue.h>
+#include <linux/mutex.h>
+#include <asm/prom.h>
+
+typedef void (*notify_func_t)(void *data);
+
+enum notify_type {
+        AOA_NOTIFY_HEADPHONE,
+        AOA_NOTIFY_LINE_IN,
+        AOA_NOTIFY_LINE_OUT,
+};
+
+struct gpio_runtime;
+struct gpio_methods {
+        /* for initialisation/de-initialisation of the GPIO layer */
+        void (*init)(struct gpio_runtime *rt);
+        void (*exit)(struct gpio_runtime *rt);
+
+        /* turn off headphone, speakers, lineout */
+        void (*all_amps_off)(struct gpio_runtime *rt);
+        /* turn headphone, speakers, lineout back to previous setting */
+        void (*all_amps_restore)(struct gpio_runtime *rt);
+
+        void (*set_headphone)(struct gpio_runtime *rt, int on);
+        void (*set_speakers)(struct gpio_runtime *rt, int on);
+        void (*set_lineout)(struct gpio_runtime *rt, int on);
+
+        int (*get_headphone)(struct gpio_runtime *rt);
+        int (*get_speakers)(struct gpio_runtime *rt);
+        int (*get_lineout)(struct gpio_runtime *rt);
+
+        void (*set_hw_reset)(struct gpio_runtime *rt, int on);
+
+        /* use this to be notified of any events. The notification
+         * function is passed the data, and is called in process
+         * context by the use of schedule_work.
+         * The interface for it is that setting a function to NULL
+         * removes it, and they return 0 if the operation succeeded,
+         * and -EBUSY if the notification is already assigned by
+         * someone else. */
+        int (*set_notify)(struct gpio_runtime *rt,
+                          enum notify_type type,
+                          notify_func_t notify,
+                          void *data);
+        /* returns 0 if not plugged in, 1 if plugged in
+         * or a negative error code */
+        int (*get_detect)(struct gpio_runtime *rt,
+                          enum notify_type type);
+};
+
+struct gpio_notification {
+        notify_func_t notify;
+        void *data;
+        void *gpio_private;
+        struct work_struct work;
+        struct mutex mutex;
+};
+
+struct gpio_runtime {
+        /* to be assigned by fabric */
+        struct device_node *node;
+        /* since everyone needs this pointer anyway... */
+        struct gpio_methods *methods;
+        /* to be used by the gpio implementation */
+        int implementation_private;
+        struct gpio_notification headphone_notify;
+        struct gpio_notification line_in_notify;
+        struct gpio_notification line_out_notify;
+};
+
+#endif /* __AOA_GPIO_H */
diff --git a/sound/aoa/aoa.h b/sound/aoa/aoa.h
new file mode 100644
index 000000000000..378ef1e9879b
--- /dev/null
+++ b/sound/aoa/aoa.h
@@ -0,0 +1,131 @@
+/*
+ * Apple Onboard Audio definitions
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+
+#ifndef __AOA_H
+#define __AOA_H
+#include <asm/prom.h>
+#include <linux/module.h>
+/* So apparently there's a reason for requiring driver.h to be included first! */
+#include <sound/driver.h>
+#include <sound/core.h>
+#include <sound/asound.h>
+#include <sound/control.h>
+#include "aoa-gpio.h"
+#include "soundbus/soundbus.h"
+
+#define MAX_CODEC_NAME_LEN      32
+
+struct aoa_codec {
+        char    name[MAX_CODEC_NAME_LEN];
+
+        struct module *owner;
+
+        /* called when the fabric wants to init this codec.
+         * Do alsa card manipulations from here. */
+        int (*init)(struct aoa_codec *codec);
+
+        /* called when the fabric is done with the codec.
+         * The alsa card will be cleaned up so don't bother. */
+        void (*exit)(struct aoa_codec *codec);
+
+        /* May be NULL, but can be used by the fabric.
+         * Refcounting is the codec driver's responsibility */
+        struct device_node *node;
+
+        /* assigned by fabric before init() is called, points
+         * to the soundbus device. Cannot be NULL. */
+        struct soundbus_dev *soundbus_dev;
+
+        /* assigned by the fabric before init() is called, points
+         * to the fabric's gpio runtime record for the relevant
+         * device. */
+        struct gpio_runtime *gpio;
+
+        /* assigned by the fabric before init() is called, contains
+         * a codec specific bitmask of what outputs and inputs are
+         * actually connected */
+        u32 connected;
+
+        /* data the fabric can associate with this structure */
+        void *fabric_data;
+
+        /* private! */
+        struct list_head list;
+        struct aoa_fabric *fabric;
+};
+
+/* return 0 on success */
+extern int
+aoa_codec_register(struct aoa_codec *codec);
+extern void
+aoa_codec_unregister(struct aoa_codec *codec);
+
+#define MAX_LAYOUT_NAME_LEN     32
+
+struct aoa_fabric {
+        char    name[MAX_LAYOUT_NAME_LEN];
+
+        struct module *owner;
+
+        /* once codecs register, they are passed here after.
+         * They are of course not initialised, since the
+         * fabric is responsible for initialising some fields
+         * in the codec structure! */
+        int (*found_codec)(struct aoa_codec *codec);
+        /* called for each codec when it is removed,
+         * also in the case that aoa_fabric_unregister
+         * is called and all codecs are removed
+         * from this fabric.
+         * Also called if found_codec returned 0 but
+         * the codec couldn't initialise. */
+        void (*remove_codec)(struct aoa_codec *codec);
+        /* If found_codec returned 0, and the codec
+         * could be initialised, this is called. */
+        void (*attached_codec)(struct aoa_codec *codec);
+};
+
+/* return 0 on success, -EEXIST if another fabric is
+ * registered, -EALREADY if the same fabric is registered.
+ * Passing NULL can be used to test for the presence
+ * of another fabric, if -EALREADY is returned there is
+ * no other fabric present.
+ * In the case that the function returns -EALREADY
+ * and the fabric passed is not NULL, all codecs
+ * that are not assigned yet are passed to the fabric
+ * again for reconsideration. */
+extern int
+aoa_fabric_register(struct aoa_fabric *fabric);
+
+/* it is vital to call this when the fabric exits!
+ * When calling, the remove_codec will be called
+ * for all codecs, unless it is NULL. */
+extern void
+aoa_fabric_unregister(struct aoa_fabric *fabric);
+
+/* if for some reason you want to get rid of a codec
+ * before the fabric is removed, use this.
+ * Note that remove_codec is called for it! */
+extern void
+aoa_fabric_unlink_codec(struct aoa_codec *codec);
+
+/* alsa help methods */
+struct aoa_card {
+        struct snd_card *alsa_card;
+};
+        
+extern int aoa_snd_device_new(snd_device_type_t type,
+        void * device_data, struct snd_device_ops * ops);
+extern struct snd_card *aoa_get_card(void);
+extern int aoa_snd_ctl_add(struct snd_kcontrol* control);
+
+/* GPIO stuff */
+extern struct gpio_methods *pmf_gpio_methods;
+extern struct gpio_methods *ftr_gpio_methods;
+/* extern struct gpio_methods *map_gpio_methods; */
+
+#endif /* __AOA_H */
diff --git a/sound/aoa/codecs/Kconfig b/sound/aoa/codecs/Kconfig
new file mode 100644
index 000000000000..90cf58f68630
--- /dev/null
+++ b/sound/aoa/codecs/Kconfig
@@ -0,0 +1,32 @@
+config SND_AOA_ONYX
+        tristate "support Onyx chip"
+        depends on SND_AOA
+        ---help---
+        This option enables support for the Onyx (pcm3052)
+        codec chip found in the latest Apple machines
+        (most of those with digital audio output).
+
+#config SND_AOA_TOPAZ
+#       tristate "support Topaz chips"
+#       depends on SND_AOA
+#       ---help---
+#       This option enables support for the Topaz (CS84xx)
+#       codec chips found in the latest Apple machines,
+#       these chips do the digital input and output on
+#       some PowerMacs.
+
+config SND_AOA_TAS
+        tristate "support TAS chips"
+        depends on SND_AOA
+        ---help---
+        This option enables support for the tas chips
+        found in a lot of Apple Machines, especially
+        iBooks and PowerBooks without digital.
+
+config SND_AOA_TOONIE
+        tristate "support Toonie chip"
+        depends on SND_AOA
+        ---help---
+        This option enables support for the toonie codec
+        found in the Mac Mini. If you have a Mac Mini and
+        want to hear sound, select this option.
diff --git a/sound/aoa/codecs/Makefile b/sound/aoa/codecs/Makefile
new file mode 100644
index 000000000000..31cbe68fd42f
--- /dev/null
+++ b/sound/aoa/codecs/Makefile
@@ -0,0 +1,3 @@
+obj-$(CONFIG_SND_AOA_ONYX) += snd-aoa-codec-onyx.o
+obj-$(CONFIG_SND_AOA_TAS) += snd-aoa-codec-tas.o
+obj-$(CONFIG_SND_AOA_TOONIE) += snd-aoa-codec-toonie.o
diff --git a/sound/aoa/codecs/snd-aoa-codec-onyx.c b/sound/aoa/codecs/snd-aoa-codec-onyx.c
new file mode 100644
index 000000000000..0b7650788f1f
--- /dev/null
+++ b/sound/aoa/codecs/snd-aoa-codec-onyx.c
@@ -0,0 +1,1113 @@
+/*
+ * Apple Onboard Audio driver for Onyx codec
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ *
+ *
+ * This is a driver for the pcm3052 codec chip (codenamed Onyx)
+ * that is present in newer Apple hardware (with digital output).
+ *
+ * The Onyx codec has the following connections (listed by the bit
+ * to be used in aoa_codec.connected):
+ *  0: analog output
+ *  1: digital output
+ *  2: line input
+ *  3: microphone input
+ * Note that even though I know of no machine that has for example
+ * the digital output connected but not the analog, I have handled
+ * all the different cases in the code so that this driver may serve
+ * as a good example of what to do.
+ *
+ * NOTE: This driver assumes that there's at most one chip to be
+ *       used with one alsa card, in form of creating all kinds
+ *       of mixer elements without regard for their existence.
+ *       But snd-aoa assumes that there's at most one card, so
+ *       this means you can only have one onyx on a system. This
+ *       should probably be fixed by changing the assumption of
+ *       having just a single card on a system, and making the
+ *       'card' pointer accessible to anyone who needs it instead
+ *       of hiding it in the aoa_snd_* functions...
+ *
+ */
+#include <linux/delay.h>
+#include <linux/module.h>
+MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("pcm3052 (onyx) codec driver for snd-aoa");
+
+#include "snd-aoa-codec-onyx.h"
+#include "../aoa.h"
+#include "../soundbus/soundbus.h"
+
+
+#define PFX "snd-aoa-codec-onyx: "
+
+struct onyx {
+        /* cache registers 65 to 80, they are write-only! */
+        u8                      cache[16];
+        struct i2c_client       i2c;
+        struct aoa_codec        codec;
+        u32                     initialised:1,
+                                spdif_locked:1,
+                                analog_locked:1,
+                                original_mute:2;
+        int                     open_count;
+        struct codec_info       *codec_info;
+
+        /* mutex serializes concurrent access to the device
+         * and this structure.
+         */
+        struct mutex mutex;
+};
+#define codec_to_onyx(c) container_of(c, struct onyx, codec)
+
+/* both return 0 if all ok, else on error */
+static int onyx_read_register(struct onyx *onyx, u8 reg, u8 *value)
+{
+        s32 v;
+
+        if (reg != ONYX_REG_CONTROL) {
+                *value = onyx->cache[reg-FIRSTREGISTER];
+                return 0;
+        }
+        v = i2c_smbus_read_byte_data(&onyx->i2c, reg);
+        if (v < 0)
+                return -1;
+        *value = (u8)v;
+        onyx->cache[ONYX_REG_CONTROL-FIRSTREGISTER] = *value;
+        return 0;
+}
+
+static int onyx_write_register(struct onyx *onyx, u8 reg, u8 value)
+{
+        int result;
+
+        result = i2c_smbus_write_byte_data(&onyx->i2c, reg, value);
+        if (!result)
+                onyx->cache[reg-FIRSTREGISTER] = value;
+        return result;
+}
+
+/* alsa stuff */
+
+static int onyx_dev_register(struct snd_device *dev)
+{
+        return 0;
+}
+
+static struct snd_device_ops ops = {
+        .dev_register = onyx_dev_register,
+};
+
+/* this is necessary because most alsa mixer programs
+ * can't properly handle the negative range */
+#define VOLUME_RANGE_SHIFT      128
+
+static int onyx_snd_vol_info(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 2;
+        uinfo->value.integer.min = -128 + VOLUME_RANGE_SHIFT;
+        uinfo->value.integer.max = -1 + VOLUME_RANGE_SHIFT;
+        return 0;
+}
+
+static int onyx_snd_vol_get(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct onyx *onyx = snd_kcontrol_chip(kcontrol);
+        s8 l, r;
+
+        mutex_lock(&onyx->mutex);
+        onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_LEFT, &l);
+        onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT, &r);
+        mutex_unlock(&onyx->mutex);
+
+        ucontrol->value.integer.value[0] = l + VOLUME_RANGE_SHIFT;
+        ucontrol->value.integer.value[1] = r + VOLUME_RANGE_SHIFT;
+
+        return 0;
+}
+
+static int onyx_snd_vol_put(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct onyx *onyx = snd_kcontrol_chip(kcontrol);
+        s8 l, r;
+
+        mutex_lock(&onyx->mutex);
+        onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_LEFT, &l);
+        onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT, &r);
+
+        if (l + VOLUME_RANGE_SHIFT == ucontrol->value.integer.value[0] &&
+            r + VOLUME_RANGE_SHIFT == ucontrol->value.integer.value[1]) {
+                mutex_unlock(&onyx->mutex);
+                return 0;
+        }
+
+        onyx_write_register(onyx, ONYX_REG_DAC_ATTEN_LEFT,
+                            ucontrol->value.integer.value[0]
+                             - VOLUME_RANGE_SHIFT);
+        onyx_write_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT,
+                            ucontrol->value.integer.value[1]
+                             - VOLUME_RANGE_SHIFT);
+        mutex_unlock(&onyx->mutex);
+
+        return 1;
+}
+
+static struct snd_kcontrol_new volume_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Master Playback Volume",
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = onyx_snd_vol_info,
+        .get = onyx_snd_vol_get,
+        .put = onyx_snd_vol_put,
+};
+
+/* like above, this is necessary because a lot
+ * of alsa mixer programs don't handle ranges
+ * that don't start at 0 properly.
+ * even alsamixer is one of them... */
+#define INPUTGAIN_RANGE_SHIFT   (-3)
+
+static int onyx_snd_inputgain_info(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 3 + INPUTGAIN_RANGE_SHIFT;
+        uinfo->value.integer.max = 28 + INPUTGAIN_RANGE_SHIFT;
+        return 0;
+}
+
+static int onyx_snd_inputgain_get(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct onyx *onyx = snd_kcontrol_chip(kcontrol);
+        u8 ig;
+
+        mutex_lock(&onyx->mutex);
+        onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &ig);
+        mutex_unlock(&onyx->mutex);
+
+        ucontrol->value.integer.value[0] =
+                (ig & ONYX_ADC_PGA_GAIN_MASK) + INPUTGAIN_RANGE_SHIFT;
+
+        return 0;
+}
+
+static int onyx_snd_inputgain_put(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct onyx *onyx = snd_kcontrol_chip(kcontrol);
+        u8 v, n;
+
+        mutex_lock(&onyx->mutex);
+        onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
+        n = v;
+        n &= ~ONYX_ADC_PGA_GAIN_MASK;
+        n |= (ucontrol->value.integer.value[0] - INPUTGAIN_RANGE_SHIFT)
+                & ONYX_ADC_PGA_GAIN_MASK;
+        onyx_write_register(onyx, ONYX_REG_ADC_CONTROL, n);
+        mutex_unlock(&onyx->mutex);
+
+        return n != v;
+}
+
+static struct snd_kcontrol_new inputgain_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Master Capture Volume",
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = onyx_snd_inputgain_info,
+        .get = onyx_snd_inputgain_get,
+        .put = onyx_snd_inputgain_put,
+};
+
+static int onyx_snd_capture_source_info(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        static char *texts[] = { "Line-In", "Microphone" };
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 2;
+        if (uinfo->value.enumerated.item > 1)
+                uinfo->value.enumerated.item = 1;
+        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
+static int onyx_snd_capture_source_get(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct onyx *onyx = snd_kcontrol_chip(kcontrol);
+        s8 v;
+
+        mutex_lock(&onyx->mutex);
+        onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
+        mutex_unlock(&onyx->mutex);
+
+        ucontrol->value.enumerated.item[0] = !!(v&ONYX_ADC_INPUT_MIC);
+
+        return 0;
+}
+
+static void onyx_set_capture_source(struct onyx *onyx, int mic)
+{
+        s8 v;
+
+        mutex_lock(&onyx->mutex);
+        onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
+        v &= ~ONYX_ADC_INPUT_MIC;
+        if (mic)
+                v |= ONYX_ADC_INPUT_MIC;
+        onyx_write_register(onyx, ONYX_REG_ADC_CONTROL, v);
+        mutex_unlock(&onyx->mutex);
+}
+
+static int onyx_snd_capture_source_put(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        onyx_set_capture_source(snd_kcontrol_chip(kcontrol),
+                                ucontrol->value.enumerated.item[0]);
+        return 1;
+}
+
+static struct snd_kcontrol_new capture_source_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        /* If we name this 'Input Source', it properly shows up in
+         * alsamixer as a selection, * but it's shown under the 
+         * 'Playback' category.
+         * If I name it 'Capture Source', it shows up in strange
+         * ways (two bools of which one can be selected at a
+         * time) but at least it's shown in the 'Capture'
+         * category.
+         * I was told that this was due to backward compatibility,
+         * but I don't understand then why the mangling is *not*
+         * done when I name it "Input Source".....
+         */
+        .name = "Capture Source",
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = onyx_snd_capture_source_info,
+        .get = onyx_snd_capture_source_get,
+        .put = onyx_snd_capture_source_put,
+};
+
+static int onyx_snd_mute_info(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 2;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
+        return 0;
+}
+
+static int onyx_snd_mute_get(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct onyx *onyx = snd_kcontrol_chip(kcontrol);
+        u8 c;
+
+        mutex_lock(&onyx->mutex);
+        onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &c);
+        mutex_unlock(&onyx->mutex);
+
+        ucontrol->value.integer.value[0] = !(c & ONYX_MUTE_LEFT);
+        ucontrol->value.integer.value[1] = !(c & ONYX_MUTE_RIGHT);
+
+        return 0;
+}
+
+static int onyx_snd_mute_put(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct onyx *onyx = snd_kcontrol_chip(kcontrol);
+        u8 v = 0, c = 0;
+        int err = -EBUSY;
+
+        mutex_lock(&onyx->mutex);
+        if (onyx->analog_locked)
+                goto out_unlock;
+
+        onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
+        c = v;
+        c &= ~(ONYX_MUTE_RIGHT | ONYX_MUTE_LEFT);
+        if (!ucontrol->value.integer.value[0])
+                c |= ONYX_MUTE_LEFT;
+        if (!ucontrol->value.integer.value[1])
+                c |= ONYX_MUTE_RIGHT;
+        err = onyx_write_register(onyx, ONYX_REG_DAC_CONTROL, c);
+
+ out_unlock:
+        mutex_unlock(&onyx->mutex);
+
+        return !err ? (v != c) : err;
+}
+
+static struct snd_kcontrol_new mute_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Master Playback Switch",
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = onyx_snd_mute_info,
+        .get = onyx_snd_mute_get,
+        .put = onyx_snd_mute_put,
+};
+
+
+static int onyx_snd_single_bit_info(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
+        return 0;
+}
+
+#define FLAG_POLARITY_INVERT    1
+#define FLAG_SPDIFLOCK          2
+
+static int onyx_snd_single_bit_get(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct onyx *onyx = snd_kcontrol_chip(kcontrol);
+        u8 c;
+        long int pv = kcontrol->private_value;
+        u8 polarity = (pv >> 16) & FLAG_POLARITY_INVERT;
+        u8 address = (pv >> 8) & 0xff;
+        u8 mask = pv & 0xff;
+
+        mutex_lock(&onyx->mutex);
+        onyx_read_register(onyx, address, &c);
+        mutex_unlock(&onyx->mutex);
+
+        ucontrol->value.integer.value[0] = !!(c & mask) ^ polarity;
+
+        return 0;
+}
+
+static int onyx_snd_single_bit_put(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct onyx *onyx = snd_kcontrol_chip(kcontrol);
+        u8 v = 0, c = 0;
+        int err;
+        long int pv = kcontrol->private_value;
+        u8 polarity = (pv >> 16) & FLAG_POLARITY_INVERT;
+        u8 spdiflock = (pv >> 16) & FLAG_SPDIFLOCK;
+        u8 address = (pv >> 8) & 0xff;
+        u8 mask = pv & 0xff;
+
+        mutex_lock(&onyx->mutex);
+        if (spdiflock && onyx->spdif_locked) {
+                /* even if alsamixer doesn't care.. */
+                err = -EBUSY;
+                goto out_unlock;
+        }
+        onyx_read_register(onyx, address, &v);
+        c = v;
+        c &= ~(mask);
+        if (!!ucontrol->value.integer.value[0] ^ polarity)
+                c |= mask;
+        err = onyx_write_register(onyx, address, c);
+
+ out_unlock:
+        mutex_unlock(&onyx->mutex);
+
+        return !err ? (v != c) : err;
+}
+
+#define SINGLE_BIT(n, type, description, address, mask, flags)          \
+static struct snd_kcontrol_new n##_control = {                          \
+        .iface = SNDRV_CTL_ELEM_IFACE_##type,                           \
+        .name = description,                                            \
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,                      \
+        .info = onyx_snd_single_bit_info,                               \
+        .get = onyx_snd_single_bit_get,                                 \
+        .put = onyx_snd_single_bit_put,                                 \
+        .private_value = (flags << 16) | (address << 8) | mask          \
+}
+
+SINGLE_BIT(spdif,
+           MIXER,
+           SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
+           ONYX_REG_DIG_INFO4,
+           ONYX_SPDIF_ENABLE,
+           FLAG_SPDIFLOCK);
+SINGLE_BIT(ovr1,
+           MIXER,
+           "Oversampling Rate",
+           ONYX_REG_DAC_CONTROL,
+           ONYX_OVR1,
+           0);
+SINGLE_BIT(flt0,
+           MIXER,
+           "Fast Digital Filter Rolloff",
+           ONYX_REG_DAC_FILTER,
+           ONYX_ROLLOFF_FAST,
+           FLAG_POLARITY_INVERT);
+SINGLE_BIT(hpf,
+           MIXER,
+           "Highpass Filter",
+           ONYX_REG_ADC_HPF_BYPASS,
+           ONYX_HPF_DISABLE,
+           FLAG_POLARITY_INVERT);
+SINGLE_BIT(dm12,
+           MIXER,
+           "Digital De-Emphasis",
+           ONYX_REG_DAC_DEEMPH,
+           ONYX_DIGDEEMPH_CTRL,
+           0);
+
+static int onyx_spdif_info(struct snd_kcontrol *kcontrol,
+                           struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
+        uinfo->count = 1;
+        return 0;
+}
+
+static int onyx_spdif_mask_get(struct snd_kcontrol *kcontrol,
+                               struct snd_ctl_elem_value *ucontrol)
+{
+        /* datasheet page 30, all others are 0 */
+        ucontrol->value.iec958.status[0] = 0x3e;
+        ucontrol->value.iec958.status[1] = 0xff;
+
+        ucontrol->value.iec958.status[3] = 0x3f;
+        ucontrol->value.iec958.status[4] = 0x0f;
+        
+        return 0;
+}
+
+static struct snd_kcontrol_new onyx_spdif_mask = {
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ,
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
+        .info =         onyx_spdif_info,
+        .get =          onyx_spdif_mask_get,
+};
+
+static int onyx_spdif_get(struct snd_kcontrol *kcontrol,
+                          struct snd_ctl_elem_value *ucontrol)
+{
+        struct onyx *onyx = snd_kcontrol_chip(kcontrol);
+        u8 v;
+
+        mutex_lock(&onyx->mutex);
+        onyx_read_register(onyx, ONYX_REG_DIG_INFO1, &v);
+        ucontrol->value.iec958.status[0] = v & 0x3e;
+
+        onyx_read_register(onyx, ONYX_REG_DIG_INFO2, &v);
+        ucontrol->value.iec958.status[1] = v;
+
+        onyx_read_register(onyx, ONYX_REG_DIG_INFO3, &v);
+        ucontrol->value.iec958.status[3] = v & 0x3f;
+
+        onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
+        ucontrol->value.iec958.status[4] = v & 0x0f;
+        mutex_unlock(&onyx->mutex);
+
+        return 0;
+}
+
+static int onyx_spdif_put(struct snd_kcontrol *kcontrol,
+                          struct snd_ctl_elem_value *ucontrol)
+{
+        struct onyx *onyx = snd_kcontrol_chip(kcontrol);
+        u8 v;
+
+        mutex_lock(&onyx->mutex);
+        onyx_read_register(onyx, ONYX_REG_DIG_INFO1, &v);
+        v = (v & ~0x3e) | (ucontrol->value.iec958.status[0] & 0x3e);
+        onyx_write_register(onyx, ONYX_REG_DIG_INFO1, v);
+
+        v = ucontrol->value.iec958.status[1];
+        onyx_write_register(onyx, ONYX_REG_DIG_INFO2, v);
+
+        onyx_read_register(onyx, ONYX_REG_DIG_INFO3, &v);
+        v = (v & ~0x3f) | (ucontrol->value.iec958.status[3] & 0x3f);
+        onyx_write_register(onyx, ONYX_REG_DIG_INFO3, v);
+
+        onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
+        v = (v & ~0x0f) | (ucontrol->value.iec958.status[4] & 0x0f);
+        onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v);
+        mutex_unlock(&onyx->mutex);
+
+        return 1;
+}
+
+static struct snd_kcontrol_new onyx_spdif_ctrl = {
+        .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
+        .info =         onyx_spdif_info,
+        .get =          onyx_spdif_get,
+        .put =          onyx_spdif_put,
+};
+
+/* our registers */
+
+static u8 register_map[] = {
+        ONYX_REG_DAC_ATTEN_LEFT,
+        ONYX_REG_DAC_ATTEN_RIGHT,
+        ONYX_REG_CONTROL,
+        ONYX_REG_DAC_CONTROL,
+        ONYX_REG_DAC_DEEMPH,
+        ONYX_REG_DAC_FILTER,
+        ONYX_REG_DAC_OUTPHASE,
+        ONYX_REG_ADC_CONTROL,
+        ONYX_REG_ADC_HPF_BYPASS,
+        ONYX_REG_DIG_INFO1,
+        ONYX_REG_DIG_INFO2,
+        ONYX_REG_DIG_INFO3,
+        ONYX_REG_DIG_INFO4
+};
+
+static u8 initial_values[ARRAY_SIZE(register_map)] = {
+        0x80, 0x80, /* muted */
+        ONYX_MRST | ONYX_SRST, /* but handled specially! */
+        ONYX_MUTE_LEFT | ONYX_MUTE_RIGHT,
+        0, /* no deemphasis */
+        ONYX_DAC_FILTER_ALWAYS,
+        ONYX_OUTPHASE_INVERTED,
+        (-1 /*dB*/ + 8) & 0xF, /* line in selected, -1 dB gain*/
+        ONYX_ADC_HPF_ALWAYS,
+        (1<<2), /* pcm audio */
+        2,      /* category: pcm coder */
+        0,      /* sampling frequency 44.1 kHz, clock accuracy level II */
+        1       /* 24 bit depth */
+};
+
+/* reset registers of chip, either to initial or to previous values */
+static int onyx_register_init(struct onyx *onyx)
+{
+        int i;
+        u8 val;
+        u8 regs[sizeof(initial_values)];
+
+        if (!onyx->initialised) {
+                memcpy(regs, initial_values, sizeof(initial_values));
+                if (onyx_read_register(onyx, ONYX_REG_CONTROL, &val))
+                        return -1;
+                val &= ~ONYX_SILICONVERSION;
+                val |= initial_values[3];
+                regs[3] = val;
+        } else {
+                for (i=0; i<sizeof(register_map); i++)
+                        regs[i] = onyx->cache[register_map[i]-FIRSTREGISTER];
+        }
+
+        for (i=0; i<sizeof(register_map); i++) {
+                if (onyx_write_register(onyx, register_map[i], regs[i]))
+                        return -1;
+        }
+        onyx->initialised = 1;
+        return 0;
+}
+
+static struct transfer_info onyx_transfers[] = {
+        /* this is first so we can skip it if no input is present...
+         * No hardware exists with that, but it's here as an example
+         * of what to do :) */
+        {
+                /* analog input */
+                .formats = SNDRV_PCM_FMTBIT_S8 |
+                           SNDRV_PCM_FMTBIT_S16_BE |
+                           SNDRV_PCM_FMTBIT_S24_BE,
+                .rates = SNDRV_PCM_RATE_8000_96000,
+                .transfer_in = 1,
+                .must_be_clock_source = 0,
+                .tag = 0,
+        },
+        {
+                /* if analog and digital are currently off, anything should go,
+                 * so this entry describes everything we can do... */
+                .formats = SNDRV_PCM_FMTBIT_S8 |
+                           SNDRV_PCM_FMTBIT_S16_BE |
+                           SNDRV_PCM_FMTBIT_S24_BE
+#ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
+                           | SNDRV_PCM_FMTBIT_COMPRESSED_16BE
+#endif
+                ,
+                .rates = SNDRV_PCM_RATE_8000_96000,
+                .tag = 0,
+        },
+        {
+                /* analog output */
+                .formats = SNDRV_PCM_FMTBIT_S8 |
+                           SNDRV_PCM_FMTBIT_S16_BE |
+                           SNDRV_PCM_FMTBIT_S24_BE,
+                .rates = SNDRV_PCM_RATE_8000_96000,
+                .transfer_in = 0,
+                .must_be_clock_source = 0,
+                .tag = 1,
+        },
+        {
+                /* digital pcm output, also possible for analog out */
+                .formats = SNDRV_PCM_FMTBIT_S8 |
+                           SNDRV_PCM_FMTBIT_S16_BE |
+                           SNDRV_PCM_FMTBIT_S24_BE,
+                .rates = SNDRV_PCM_RATE_32000 |
+                         SNDRV_PCM_RATE_44100 |
+                         SNDRV_PCM_RATE_48000,
+                .transfer_in = 0,
+                .must_be_clock_source = 0,
+                .tag = 2,
+        },
+#ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
+Once alsa gets supports for this kind of thing we can add it...
+        {
+                /* digital compressed output */
+                .formats =  SNDRV_PCM_FMTBIT_COMPRESSED_16BE,
+                .rates = SNDRV_PCM_RATE_32000 |
+                         SNDRV_PCM_RATE_44100 |
+                         SNDRV_PCM_RATE_48000,
+                .tag = 2,
+        },
+#endif
+        {}
+};
+
+static int onyx_usable(struct codec_info_item *cii,
+                       struct transfer_info *ti,
+                       struct transfer_info *out)
+{
+        u8 v;
+        struct onyx *onyx = cii->codec_data;
+        int spdif_enabled, analog_enabled;
+
+        mutex_lock(&onyx->mutex);
+        onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
+        spdif_enabled = !!(v & ONYX_SPDIF_ENABLE);
+        onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
+        analog_enabled = 
+                (v & (ONYX_MUTE_RIGHT|ONYX_MUTE_LEFT))
+                 != (ONYX_MUTE_RIGHT|ONYX_MUTE_LEFT);
+        mutex_unlock(&onyx->mutex);
+
+        switch (ti->tag) {
+        case 0: return 1;
+        case 1: return analog_enabled;
+        case 2: return spdif_enabled;
+        }
+        return 1;
+}
+
+static int onyx_prepare(struct codec_info_item *cii,
+                        struct bus_info *bi,
+                        struct snd_pcm_substream *substream)
+{
+        u8 v;
+        struct onyx *onyx = cii->codec_data;
+        int err = -EBUSY;
+
+        mutex_lock(&onyx->mutex);
+
+#ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
+        if (substream->runtime->format == SNDRV_PCM_FMTBIT_COMPRESSED_16BE) {
+                /* mute and lock analog output */
+                onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
+                if (onyx_write_register(onyx
+                                        ONYX_REG_DAC_CONTROL,
+                                        v | ONYX_MUTE_RIGHT | ONYX_MUTE_LEFT))
+                        goto out_unlock;
+                onyx->analog_locked = 1;
+                err = 0;
+                goto out_unlock;
+        }
+#endif
+        switch (substream->runtime->rate) {
+        case 32000:
+        case 44100:
+        case 48000:
+                /* these rates are ok for all outputs */
+                /* FIXME: program spdif channel control bits here so that
+                 *        userspace doesn't have to if it only plays pcm! */
+                err = 0;
+                goto out_unlock;
+        default:
+                /* got some rate that the digital output can't do,
+                 * so disable and lock it */
+                onyx_read_register(cii->codec_data, ONYX_REG_DIG_INFO4, &v);
+                if (onyx_write_register(onyx,
+                                        ONYX_REG_DIG_INFO4,
+                                        v & ~ONYX_SPDIF_ENABLE))
+                        goto out_unlock;
+                onyx->spdif_locked = 1;
+                err = 0;
+                goto out_unlock;
+        }
+
+ out_unlock:
+        mutex_unlock(&onyx->mutex);
+
+        return err;
+}
+
+static int onyx_open(struct codec_info_item *cii,
+                     struct snd_pcm_substream *substream)
+{
+        struct onyx *onyx = cii->codec_data;
+
+        mutex_lock(&onyx->mutex);
+        onyx->open_count++;
+        mutex_unlock(&onyx->mutex);
+
+        return 0;
+}
+
+static int onyx_close(struct codec_info_item *cii,
+                      struct snd_pcm_substream *substream)
+{
+        struct onyx *onyx = cii->codec_data;
+
+        mutex_lock(&onyx->mutex);
+        onyx->open_count--;
+        if (!onyx->open_count)
+                onyx->spdif_locked = onyx->analog_locked = 0;
+        mutex_unlock(&onyx->mutex);
+
+        return 0;
+}
+
+static int onyx_switch_clock(struct codec_info_item *cii,
+                             enum clock_switch what)
+{
+        struct onyx *onyx = cii->codec_data;
+
+        mutex_lock(&onyx->mutex);
+        /* this *MUST* be more elaborate later... */
+        switch (what) {
+        case CLOCK_SWITCH_PREPARE_SLAVE:
+                onyx->codec.gpio->methods->all_amps_off(onyx->codec.gpio);
+                break;
+        case CLOCK_SWITCH_SLAVE:
+                onyx->codec.gpio->methods->all_amps_restore(onyx->codec.gpio);
+                break;
+        default: /* silence warning */
+                break;
+        }
+        mutex_unlock(&onyx->mutex);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+
+static int onyx_suspend(struct codec_info_item *cii, pm_message_t state)
+{
+        struct onyx *onyx = cii->codec_data;
+        u8 v;
+        int err = -ENXIO;
+
+        mutex_lock(&onyx->mutex);
+        if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v))
+                goto out_unlock;
+        onyx_write_register(onyx, ONYX_REG_CONTROL, v | ONYX_ADPSV | ONYX_DAPSV);
+        /* Apple does a sleep here but the datasheet says to do it on resume */
+        err = 0;
+ out_unlock:
+        mutex_unlock(&onyx->mutex);
+
+        return err;
+}
+
+static int onyx_resume(struct codec_info_item *cii)
+{
+        struct onyx *onyx = cii->codec_data;
+        u8 v;
+        int err = -ENXIO;
+
+        mutex_lock(&onyx->mutex);
+        /* take codec out of suspend */
+        if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v))
+                goto out_unlock;
+        onyx_write_register(onyx, ONYX_REG_CONTROL, v & ~(ONYX_ADPSV | ONYX_DAPSV));
+        /* FIXME: should divide by sample rate, but 8k is the lowest we go */
+        msleep(2205000/8000);
+        /* reset all values */
+        onyx_register_init(onyx);
+        err = 0;
+ out_unlock:
+        mutex_unlock(&onyx->mutex);
+
+        return err;
+}
+
+#endif /* CONFIG_PM */
+
+static struct codec_info onyx_codec_info = {
+        .transfers = onyx_transfers,
+        .sysclock_factor = 256,
+        .bus_factor = 64,
+        .owner = THIS_MODULE,
+        .usable = onyx_usable,
+        .prepare = onyx_prepare,
+        .open = onyx_open,
+        .close = onyx_close,
+        .switch_clock = onyx_switch_clock,
+#ifdef CONFIG_PM
+        .suspend = onyx_suspend,
+        .resume = onyx_resume,
+#endif
+};
+
+static int onyx_init_codec(struct aoa_codec *codec)
+{
+        struct onyx *onyx = codec_to_onyx(codec);
+        struct snd_kcontrol *ctl;
+        struct codec_info *ci = &onyx_codec_info;
+        u8 v;
+        int err;
+
+        if (!onyx->codec.gpio || !onyx->codec.gpio->methods) {
+                printk(KERN_ERR PFX "gpios not assigned!!\n");
+                return -EINVAL;
+        }
+
+        onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
+        msleep(1);
+        onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 1);
+        msleep(1);
+        onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
+        msleep(1);
+        
+        if (onyx_register_init(onyx)) {
+                printk(KERN_ERR PFX "failed to initialise onyx registers\n");
+                return -ENODEV;
+        }
+
+        if (aoa_snd_device_new(SNDRV_DEV_LOWLEVEL, onyx, &ops)) {
+                printk(KERN_ERR PFX "failed to create onyx snd device!\n");
+                return -ENODEV;
+        }
+
+        /* nothing connected? what a joke! */
+        if ((onyx->codec.connected & 0xF) == 0)
+                return -ENOTCONN;
+
+        /* if no inputs are present... */
+        if ((onyx->codec.connected & 0xC) == 0) {
+                if (!onyx->codec_info)
+                        onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
+                if (!onyx->codec_info)
+                        return -ENOMEM;
+                ci = onyx->codec_info;
+                *ci = onyx_codec_info;
+                ci->transfers++;
+        }
+
+        /* if no outputs are present... */
+        if ((onyx->codec.connected & 3) == 0) {
+                if (!onyx->codec_info)
+                        onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
+                if (!onyx->codec_info)
+                        return -ENOMEM;
+                ci = onyx->codec_info;
+                /* this is fine as there have to be inputs
+                 * if we end up in this part of the code */
+                *ci = onyx_codec_info;
+                ci->transfers[1].formats = 0;
+        }
+
+        if (onyx->codec.soundbus_dev->attach_codec(onyx->codec.soundbus_dev,
+                                                   aoa_get_card(),
+                                                   ci, onyx)) {
+                printk(KERN_ERR PFX "error creating onyx pcm\n");
+                return -ENODEV;
+        }
+#define ADDCTL(n)                                                       \
+        do {                                                            \
+                ctl = snd_ctl_new1(&n, onyx);                           \
+                if (ctl) {                                              \
+                        ctl->id.device =                                \
+                                onyx->codec.soundbus_dev->pcm->device;  \
+                        err = aoa_snd_ctl_add(ctl);                     \
+                        if (err)                                        \
+                                goto error;                             \
+                }                                                       \
+        } while (0)
+
+        if (onyx->codec.soundbus_dev->pcm) {
+                /* give the user appropriate controls
+                 * depending on what inputs are connected */
+                if ((onyx->codec.connected & 0xC) == 0xC)
+                        ADDCTL(capture_source_control);
+                else if (onyx->codec.connected & 4)
+                        onyx_set_capture_source(onyx, 0);
+                else
+                        onyx_set_capture_source(onyx, 1);
+                if (onyx->codec.connected & 0xC)
+                        ADDCTL(inputgain_control);
+
+                /* depending on what output is connected,
+                 * give the user appropriate controls */
+                if (onyx->codec.connected & 1) {
+                        ADDCTL(volume_control);
+                        ADDCTL(mute_control);
+                        ADDCTL(ovr1_control);
+                        ADDCTL(flt0_control);
+                        ADDCTL(hpf_control);
+                        ADDCTL(dm12_control);
+                        /* spdif control defaults to off */
+                }
+                if (onyx->codec.connected & 2) {
+                        ADDCTL(onyx_spdif_mask);
+                        ADDCTL(onyx_spdif_ctrl);
+                }
+                if ((onyx->codec.connected & 3) == 3)
+                        ADDCTL(spdif_control);
+                /* if only S/PDIF is connected, enable it unconditionally */
+                if ((onyx->codec.connected & 3) == 2) {
+                        onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
+                        v |= ONYX_SPDIF_ENABLE;
+                        onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v);
+                }
+        }
+#undef ADDCTL
+        printk(KERN_INFO PFX "attached to onyx codec via i2c\n");
+
+        return 0;
+ error:
+        onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx);
+        snd_device_free(aoa_get_card(), onyx);
+        return err;
+}
+
+static void onyx_exit_codec(struct aoa_codec *codec)
+{
+        struct onyx *onyx = codec_to_onyx(codec);
+
+        if (!onyx->codec.soundbus_dev) {
+                printk(KERN_ERR PFX "onyx_exit_codec called without soundbus_dev!\n");
+                return;
+        }
+        onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx);
+}
+
+static struct i2c_driver onyx_driver;
+
+static int onyx_create(struct i2c_adapter *adapter,
+                       struct device_node *node,
+                       int addr)
+{
+        struct onyx *onyx;
+        u8 dummy;
+
+        onyx = kzalloc(sizeof(struct onyx), GFP_KERNEL);
+
+        if (!onyx)
+                return -ENOMEM;
+
+        mutex_init(&onyx->mutex);
+        onyx->i2c.driver = &onyx_driver;
+        onyx->i2c.adapter = adapter;
+        onyx->i2c.addr = addr & 0x7f;
+        strlcpy(onyx->i2c.name, "onyx audio codec", I2C_NAME_SIZE-1);
+
+        if (i2c_attach_client(&onyx->i2c)) {
+                printk(KERN_ERR PFX "failed to attach to i2c\n");
+                goto fail;
+        }
+
+        /* we try to read from register ONYX_REG_CONTROL
+         * to check if the codec is present */
+        if (onyx_read_register(onyx, ONYX_REG_CONTROL, &dummy) != 0) {
+                i2c_detach_client(&onyx->i2c);
+                printk(KERN_ERR PFX "failed to read control register\n");
+                goto fail;
+        }
+
+        strlcpy(onyx->codec.name, "onyx", MAX_CODEC_NAME_LEN-1);
+        onyx->codec.owner = THIS_MODULE;
+        onyx->codec.init = onyx_init_codec;
+        onyx->codec.exit = onyx_exit_codec;
+        onyx->codec.node = of_node_get(node);
+
+        if (aoa_codec_register(&onyx->codec)) {
+                i2c_detach_client(&onyx->i2c);
+                goto fail;
+        }
+        printk(KERN_DEBUG PFX "created and attached onyx instance\n");
+        return 0;
+ fail:
+        kfree(onyx);
+        return -EINVAL;
+}
+
+static int onyx_i2c_attach(struct i2c_adapter *adapter)
+{
+        struct device_node *busnode, *dev = NULL;
+        struct pmac_i2c_bus *bus;
+
+        bus = pmac_i2c_adapter_to_bus(adapter);
+        if (bus == NULL)
+                return -ENODEV;
+        busnode = pmac_i2c_get_bus_node(bus);
+
+        while ((dev = of_get_next_child(busnode, dev)) != NULL) {
+                if (device_is_compatible(dev, "pcm3052")) {
+                        u32 *addr;
+                        printk(KERN_DEBUG PFX "found pcm3052\n");
+                        addr = (u32 *) get_property(dev, "reg", NULL);
+                        if (!addr)
+                                return -ENODEV;
+                        return onyx_create(adapter, dev, (*addr)>>1);
+                }
+        }
+
+        /* if that didn't work, try desperate mode for older
+         * machines that have stuff missing from the device tree */
+        
+        if (!device_is_compatible(busnode, "k2-i2c"))
+                return -ENODEV;
+
+        printk(KERN_DEBUG PFX "found k2-i2c, checking if onyx chip is on it\n");
+        /* probe both possible addresses for the onyx chip */
+        if (onyx_create(adapter, NULL, 0x46) == 0)
+                return 0;
+        return onyx_create(adapter, NULL, 0x47);
+}
+
+static int onyx_i2c_detach(struct i2c_client *client)
+{
+        struct onyx *onyx = container_of(client, struct onyx, i2c);
+        int err;
+
+        if ((err = i2c_detach_client(client)))
+                return err;
+        aoa_codec_unregister(&onyx->codec);
+        of_node_put(onyx->codec.node);
+        if (onyx->codec_info)
+                kfree(onyx->codec_info);
+        kfree(onyx);
+        return 0;
+}
+
+static struct i2c_driver onyx_driver = {
+        .driver = {
+                .name = "aoa_codec_onyx",
+                .owner = THIS_MODULE,
+        },
+        .attach_adapter = onyx_i2c_attach,
+        .detach_client = onyx_i2c_detach,
+};
+
+static int __init onyx_init(void)
+{
+        return i2c_add_driver(&onyx_driver);
+}
+
+static void __exit onyx_exit(void)
+{
+        i2c_del_driver(&onyx_driver);
+}
+
+module_init(onyx_init);
+module_exit(onyx_exit);
diff --git a/sound/aoa/codecs/snd-aoa-codec-onyx.h b/sound/aoa/codecs/snd-aoa-codec-onyx.h
new file mode 100644
index 000000000000..aeedda773699
--- /dev/null
+++ b/sound/aoa/codecs/snd-aoa-codec-onyx.h
@@ -0,0 +1,76 @@
+/*
+ * Apple Onboard Audio driver for Onyx codec (header)
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+#ifndef __SND_AOA_CODEC_ONYX_H
+#define __SND_AOA_CODEC_ONYX_H
+#include <stddef.h>
+#include <linux/i2c.h>
+#include <linux/i2c-dev.h>
+#include <asm/pmac_low_i2c.h>
+#include <asm/prom.h>
+
+/* PCM3052 register definitions */
+
+/* the attenuation registers take values from
+ * -1 (0dB) to -127 (-63.0 dB) or others (muted) */
+#define ONYX_REG_DAC_ATTEN_LEFT         65
+#define FIRSTREGISTER                   ONYX_REG_DAC_ATTEN_LEFT
+#define ONYX_REG_DAC_ATTEN_RIGHT        66
+
+#define ONYX_REG_CONTROL                67
+#       define ONYX_MRST                (1<<7)
+#       define ONYX_SRST                (1<<6)
+#       define ONYX_ADPSV               (1<<5)
+#       define ONYX_DAPSV               (1<<4)
+#       define ONYX_SILICONVERSION      (1<<0)
+/* all others reserved */
+
+#define ONYX_REG_DAC_CONTROL            68
+#       define ONYX_OVR1                (1<<6)
+#       define ONYX_MUTE_RIGHT          (1<<1)
+#       define ONYX_MUTE_LEFT           (1<<0)
+
+#define ONYX_REG_DAC_DEEMPH             69
+#       define ONYX_DIGDEEMPH_SHIFT     5
+#       define ONYX_DIGDEEMPH_MASK      (3<<ONYX_DIGDEEMPH_SHIFT)
+#       define ONYX_DIGDEEMPH_CTRL      (1<<4)
+
+#define ONYX_REG_DAC_FILTER             70
+#       define ONYX_ROLLOFF_FAST        (1<<5)
+#       define ONYX_DAC_FILTER_ALWAYS   (1<<2)
+
+#define ONYX_REG_DAC_OUTPHASE           71
+#       define ONYX_OUTPHASE_INVERTED   (1<<0)
+
+#define ONYX_REG_ADC_CONTROL            72
+#       define ONYX_ADC_INPUT_MIC       (1<<5)
+/* 8 + input gain in dB, valid range for input gain is -4 .. 20 dB */
+#       define ONYX_ADC_PGA_GAIN_MASK   0x1f
+
+#define ONYX_REG_ADC_HPF_BYPASS         75
+#       define ONYX_HPF_DISABLE         (1<<3)
+#       define ONYX_ADC_HPF_ALWAYS      (1<<2)
+
+#define ONYX_REG_DIG_INFO1              77
+#       define ONYX_MASK_DIN_TO_BPZ     (1<<7)
+/* bits 1-5 control channel bits 1-5 */
+#       define ONYX_DIGOUT_DISABLE      (1<<0)
+
+#define ONYX_REG_DIG_INFO2              78
+/* controls channel bits 8-15 */
+
+#define ONYX_REG_DIG_INFO3              79
+/* control channel bits 24-29, high 2 bits reserved */
+
+#define ONYX_REG_DIG_INFO4              80
+#       define ONYX_VALIDL              (1<<7)
+#       define ONYX_VALIDR              (1<<6)
+#       define ONYX_SPDIF_ENABLE        (1<<5)
+/* lower 4 bits control bits 32-35 of channel control and word length */
+#       define ONYX_WORDLEN_MASK        (0xF)
+
+#endif /* __SND_AOA_CODEC_ONYX_H */
diff --git a/sound/aoa/codecs/snd-aoa-codec-tas-gain-table.h b/sound/aoa/codecs/snd-aoa-codec-tas-gain-table.h
new file mode 100644
index 000000000000..4cfa6757715e
--- /dev/null
+++ b/sound/aoa/codecs/snd-aoa-codec-tas-gain-table.h
@@ -0,0 +1,209 @@
+/*
+ This is the program used to generate below table.
+
+#include <stdio.h>
+#include <math.h>
+int main() {
+  int dB2;
+  printf("/" "* This file is only included exactly once!\n");
+  printf(" *\n");
+  printf(" * If they'd only tell us that generating this table was\n");
+  printf(" * as easy as calculating\n");
+  printf(" *      hwvalue = 1048576.0*exp(0.057564628*dB*2)\n");
+  printf(" * :) *" "/\n");
+  printf("static int tas_gaintable[] = {\n");
+  printf("      0x000000, /" "* -infinity dB *" "/\n");
+  for (dB2=-140;dB2<=36;dB2++)
+    printf("    0x%.6x, /" "* %-02.1f dB *" "/\n", (int)(1048576.0*exp(0.057564628*dB2)), dB2/2.0);
+  printf("};\n\n");
+}
+
+*/
+
+/* This file is only included exactly once!
+ *
+ * If they'd only tell us that generating this table was
+ * as easy as calculating
+ *      hwvalue = 1048576.0*exp(0.057564628*dB*2)
+ * :) */
+static int tas_gaintable[] = {
+        0x000000, /* -infinity dB */
+        0x00014b, /* -70.0 dB */
+        0x00015f, /* -69.5 dB */
+        0x000174, /* -69.0 dB */
+        0x00018a, /* -68.5 dB */
+        0x0001a1, /* -68.0 dB */
+        0x0001ba, /* -67.5 dB */
+        0x0001d4, /* -67.0 dB */
+        0x0001f0, /* -66.5 dB */
+        0x00020d, /* -66.0 dB */
+        0x00022c, /* -65.5 dB */
+        0x00024d, /* -65.0 dB */
+        0x000270, /* -64.5 dB */
+        0x000295, /* -64.0 dB */
+        0x0002bc, /* -63.5 dB */
+        0x0002e6, /* -63.0 dB */
+        0x000312, /* -62.5 dB */
+        0x000340, /* -62.0 dB */
+        0x000372, /* -61.5 dB */
+        0x0003a6, /* -61.0 dB */
+        0x0003dd, /* -60.5 dB */
+        0x000418, /* -60.0 dB */
+        0x000456, /* -59.5 dB */
+        0x000498, /* -59.0 dB */
+        0x0004de, /* -58.5 dB */
+        0x000528, /* -58.0 dB */
+        0x000576, /* -57.5 dB */
+        0x0005c9, /* -57.0 dB */
+        0x000620, /* -56.5 dB */
+        0x00067d, /* -56.0 dB */
+        0x0006e0, /* -55.5 dB */
+        0x000748, /* -55.0 dB */
+        0x0007b7, /* -54.5 dB */
+        0x00082c, /* -54.0 dB */
+        0x0008a8, /* -53.5 dB */
+        0x00092b, /* -53.0 dB */
+        0x0009b6, /* -52.5 dB */
+        0x000a49, /* -52.0 dB */
+        0x000ae5, /* -51.5 dB */
+        0x000b8b, /* -51.0 dB */
+        0x000c3a, /* -50.5 dB */
+        0x000cf3, /* -50.0 dB */
+        0x000db8, /* -49.5 dB */
+        0x000e88, /* -49.0 dB */
+        0x000f64, /* -48.5 dB */
+        0x00104e, /* -48.0 dB */
+        0x001145, /* -47.5 dB */
+        0x00124b, /* -47.0 dB */
+        0x001361, /* -46.5 dB */
+        0x001487, /* -46.0 dB */
+        0x0015be, /* -45.5 dB */
+        0x001708, /* -45.0 dB */
+        0x001865, /* -44.5 dB */
+        0x0019d8, /* -44.0 dB */
+        0x001b60, /* -43.5 dB */
+        0x001cff, /* -43.0 dB */
+        0x001eb7, /* -42.5 dB */
+        0x002089, /* -42.0 dB */
+        0x002276, /* -41.5 dB */
+        0x002481, /* -41.0 dB */
+        0x0026ab, /* -40.5 dB */
+        0x0028f5, /* -40.0 dB */
+        0x002b63, /* -39.5 dB */
+        0x002df5, /* -39.0 dB */
+        0x0030ae, /* -38.5 dB */
+        0x003390, /* -38.0 dB */
+        0x00369e, /* -37.5 dB */
+        0x0039db, /* -37.0 dB */
+        0x003d49, /* -36.5 dB */
+        0x0040ea, /* -36.0 dB */
+        0x0044c3, /* -35.5 dB */
+        0x0048d6, /* -35.0 dB */
+        0x004d27, /* -34.5 dB */
+        0x0051b9, /* -34.0 dB */
+        0x005691, /* -33.5 dB */
+        0x005bb2, /* -33.0 dB */
+        0x006121, /* -32.5 dB */
+        0x0066e3, /* -32.0 dB */
+        0x006cfb, /* -31.5 dB */
+        0x007370, /* -31.0 dB */
+        0x007a48, /* -30.5 dB */
+        0x008186, /* -30.0 dB */
+        0x008933, /* -29.5 dB */
+        0x009154, /* -29.0 dB */
+        0x0099f1, /* -28.5 dB */
+        0x00a310, /* -28.0 dB */
+        0x00acba, /* -27.5 dB */
+        0x00b6f6, /* -27.0 dB */
+        0x00c1cd, /* -26.5 dB */
+        0x00cd49, /* -26.0 dB */
+        0x00d973, /* -25.5 dB */
+        0x00e655, /* -25.0 dB */
+        0x00f3fb, /* -24.5 dB */
+        0x010270, /* -24.0 dB */
+        0x0111c0, /* -23.5 dB */
+        0x0121f9, /* -23.0 dB */
+        0x013328, /* -22.5 dB */
+        0x01455b, /* -22.0 dB */
+        0x0158a2, /* -21.5 dB */
+        0x016d0e, /* -21.0 dB */
+        0x0182af, /* -20.5 dB */
+        0x019999, /* -20.0 dB */
+        0x01b1de, /* -19.5 dB */
+        0x01cb94, /* -19.0 dB */
+        0x01e6cf, /* -18.5 dB */
+        0x0203a7, /* -18.0 dB */
+        0x022235, /* -17.5 dB */
+        0x024293, /* -17.0 dB */
+        0x0264db, /* -16.5 dB */
+        0x02892c, /* -16.0 dB */
+        0x02afa3, /* -15.5 dB */
+        0x02d862, /* -15.0 dB */
+        0x03038a, /* -14.5 dB */
+        0x033142, /* -14.0 dB */
+        0x0361af, /* -13.5 dB */
+        0x0394fa, /* -13.0 dB */
+        0x03cb50, /* -12.5 dB */
+        0x0404de, /* -12.0 dB */
+        0x0441d5, /* -11.5 dB */
+        0x048268, /* -11.0 dB */
+        0x04c6d0, /* -10.5 dB */
+        0x050f44, /* -10.0 dB */
+        0x055c04, /* -9.5 dB */
+        0x05ad50, /* -9.0 dB */
+        0x06036e, /* -8.5 dB */
+        0x065ea5, /* -8.0 dB */
+        0x06bf44, /* -7.5 dB */
+        0x07259d, /* -7.0 dB */
+        0x079207, /* -6.5 dB */
+        0x0804dc, /* -6.0 dB */
+        0x087e80, /* -5.5 dB */
+        0x08ff59, /* -5.0 dB */
+        0x0987d5, /* -4.5 dB */
+        0x0a1866, /* -4.0 dB */
+        0x0ab189, /* -3.5 dB */
+        0x0b53be, /* -3.0 dB */
+        0x0bff91, /* -2.5 dB */
+        0x0cb591, /* -2.0 dB */
+        0x0d765a, /* -1.5 dB */
+        0x0e4290, /* -1.0 dB */
+        0x0f1adf, /* -0.5 dB */
+        0x100000, /* 0.0 dB */
+        0x10f2b4, /* 0.5 dB */
+        0x11f3c9, /* 1.0 dB */
+        0x13041a, /* 1.5 dB */
+        0x14248e, /* 2.0 dB */
+        0x15561a, /* 2.5 dB */
+        0x1699c0, /* 3.0 dB */
+        0x17f094, /* 3.5 dB */
+        0x195bb8, /* 4.0 dB */
+        0x1adc61, /* 4.5 dB */
+        0x1c73d5, /* 5.0 dB */
+        0x1e236d, /* 5.5 dB */
+        0x1fec98, /* 6.0 dB */
+        0x21d0d9, /* 6.5 dB */
+        0x23d1cd, /* 7.0 dB */
+        0x25f125, /* 7.5 dB */
+        0x2830af, /* 8.0 dB */
+        0x2a9254, /* 8.5 dB */
+        0x2d1818, /* 9.0 dB */
+        0x2fc420, /* 9.5 dB */
+        0x3298b0, /* 10.0 dB */
+        0x35982f, /* 10.5 dB */
+        0x38c528, /* 11.0 dB */
+        0x3c224c, /* 11.5 dB */
+        0x3fb278, /* 12.0 dB */
+        0x4378b0, /* 12.5 dB */
+        0x477829, /* 13.0 dB */
+        0x4bb446, /* 13.5 dB */
+        0x5030a1, /* 14.0 dB */
+        0x54f106, /* 14.5 dB */
+        0x59f980, /* 15.0 dB */
+        0x5f4e52, /* 15.5 dB */
+        0x64f403, /* 16.0 dB */
+        0x6aef5e, /* 16.5 dB */
+        0x714575, /* 17.0 dB */
+        0x77fbaa, /* 17.5 dB */
+        0x7f17af, /* 18.0 dB */
+};
+
diff --git a/sound/aoa/codecs/snd-aoa-codec-tas.c b/sound/aoa/codecs/snd-aoa-codec-tas.c
new file mode 100644
index 000000000000..2e39ff6ee349
--- /dev/null
+++ b/sound/aoa/codecs/snd-aoa-codec-tas.c
@@ -0,0 +1,654 @@
+/*
+ * Apple Onboard Audio driver for tas codec
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ *
+ * Open questions:
+ *  - How to distinguish between 3004 and versions?
+ *
+ * FIXMEs:
+ *  - This codec driver doesn't honour the 'connected'
+ *    property of the aoa_codec struct, hence if
+ *    it is used in machines where not everything is
+ *    connected it will display wrong mixer elements.
+ *  - Driver assumes that the microphone is always
+ *    monaureal and connected to the right channel of
+ *    the input. This should also be a codec-dependent
+ *    flag, maybe the codec should have 3 different
+ *    bits for the three different possibilities how
+ *    it can be hooked up...
+ *    But as long as I don't see any hardware hooked
+ *    up that way...
+ *  - As Apple notes in their code, the tas3004 seems
+ *    to delay the right channel by one sample. You can
+ *    see this when for example recording stereo in
+ *    audacity, or recording the tas output via cable
+ *    on another machine (use a sinus generator or so).
+ *    I tried programming the BiQuads but couldn't
+ *    make the delay work, maybe someone can read the
+ *    datasheet and fix it. The relevant Apple comment
+ *    is in AppleTAS3004Audio.cpp lines 1637 ff. Note
+ *    that their comment describing how they program
+ *    the filters sucks...
+ *
+ * Other things:
+ *  - this should actually register *two* aoa_codec
+ *    structs since it has two inputs. Then it must
+ *    use the prepare callback to forbid running the
+ *    secondary output on a different clock.
+ *    Also, whatever bus knows how to do this must
+ *    provide two soundbus_dev devices and the fabric
+ *    must be able to link them correctly.
+ *
+ *    I don't even know if Apple ever uses the second
+ *    port on the tas3004 though, I don't think their
+ *    i2s controllers can even do it. OTOH, they all
+ *    derive the clocks from common clocks, so it
+ *    might just be possible. The framework allows the
+ *    codec to refine the transfer_info items in the
+ *    usable callback, so we can simply remove the
+ *    rates the second instance is not using when it
+ *    actually is in use.
+ *    Maybe we'll need to make the sound busses have
+ *    a 'clock group id' value so the codec can
+ *    determine if the two outputs can be driven at
+ *    the same time. But that is likely overkill, up
+ *    to the fabric to not link them up incorrectly,
+ *    and up to the hardware designer to not wire
+ *    them up in some weird unusable way.
+ */
+#include <stddef.h>
+#include <linux/i2c.h>
+#include <linux/i2c-dev.h>
+#include <asm/pmac_low_i2c.h>
+#include <asm/prom.h>
+#include <linux/delay.h>
+#include <linux/module.h>
+MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("tas codec driver for snd-aoa");
+
+#include "snd-aoa-codec-tas.h"
+#include "snd-aoa-codec-tas-gain-table.h"
+#include "../aoa.h"
+#include "../soundbus/soundbus.h"
+
+
+#define PFX "snd-aoa-codec-tas: "
+
+struct tas {
+        struct aoa_codec        codec;
+        struct i2c_client       i2c;
+        u32                     muted_l:1, muted_r:1,
+                                controls_created:1;
+        u8                      cached_volume_l, cached_volume_r;
+        u8                      mixer_l[3], mixer_r[3];
+        u8                      acr;
+};
+
+static struct tas *codec_to_tas(struct aoa_codec *codec)
+{
+        return container_of(codec, struct tas, codec);
+}
+
+static inline int tas_write_reg(struct tas *tas, u8 reg, u8 len, u8 *data)
+{
+        if (len == 1)
+                return i2c_smbus_write_byte_data(&tas->i2c, reg, *data);
+        else
+                return i2c_smbus_write_i2c_block_data(&tas->i2c, reg, len, data);
+}
+
+static void tas_set_volume(struct tas *tas)
+{
+        u8 block[6];
+        int tmp;
+        u8 left, right;
+
+        left = tas->cached_volume_l;
+        right = tas->cached_volume_r;
+
+        if (left > 177) left = 177;
+        if (right > 177) right = 177;
+
+        if (tas->muted_l) left = 0;
+        if (tas->muted_r) right = 0;
+
+        /* analysing the volume and mixer tables shows
+         * that they are similar enough when we shift
+         * the mixer table down by 4 bits. The error
+         * is miniscule, in just one item the error
+         * is 1, at a value of 0x07f17b (mixer table
+         * value is 0x07f17a) */
+        tmp = tas_gaintable[left];
+        block[0] = tmp>>20;
+        block[1] = tmp>>12;
+        block[2] = tmp>>4;
+        tmp = tas_gaintable[right];
+        block[3] = tmp>>20;
+        block[4] = tmp>>12;
+        block[5] = tmp>>4;
+        tas_write_reg(tas, TAS_REG_VOL, 6, block);
+}
+
+static void tas_set_mixer(struct tas *tas)
+{
+        u8 block[9];
+        int tmp, i;
+        u8 val;
+
+        for (i=0;i<3;i++) {
+                val = tas->mixer_l[i];
+                if (val > 177) val = 177;
+                tmp = tas_gaintable[val];
+                block[3*i+0] = tmp>>16;
+                block[3*i+1] = tmp>>8;
+                block[3*i+2] = tmp;
+        }
+        tas_write_reg(tas, TAS_REG_LMIX, 9, block);
+
+        for (i=0;i<3;i++) {
+                val = tas->mixer_r[i];
+                if (val > 177) val = 177;
+                tmp = tas_gaintable[val];
+                block[3*i+0] = tmp>>16;
+                block[3*i+1] = tmp>>8;
+                block[3*i+2] = tmp;
+        }
+        tas_write_reg(tas, TAS_REG_RMIX, 9, block);
+}
+
+/* alsa stuff */
+
+static int tas_dev_register(struct snd_device *dev)
+{
+        return 0;
+}
+
+static struct snd_device_ops ops = {
+        .dev_register = tas_dev_register,
+};
+
+static int tas_snd_vol_info(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 2;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 177;
+        return 0;
+}
+
+static int tas_snd_vol_get(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct tas *tas = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.integer.value[0] = tas->cached_volume_l;
+        ucontrol->value.integer.value[1] = tas->cached_volume_r;
+        return 0;
+}
+
+static int tas_snd_vol_put(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct tas *tas = snd_kcontrol_chip(kcontrol);
+
+        if (tas->cached_volume_l == ucontrol->value.integer.value[0]
+         && tas->cached_volume_r == ucontrol->value.integer.value[1])
+                return 0;
+
+        tas->cached_volume_l = ucontrol->value.integer.value[0];
+        tas->cached_volume_r = ucontrol->value.integer.value[1];
+        tas_set_volume(tas);
+        return 1;
+}
+
+static struct snd_kcontrol_new volume_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Master Playback Volume",
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = tas_snd_vol_info,
+        .get = tas_snd_vol_get,
+        .put = tas_snd_vol_put,
+};
+
+static int tas_snd_mute_info(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 2;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
+        return 0;
+}
+
+static int tas_snd_mute_get(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct tas *tas = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.integer.value[0] = !tas->muted_l;
+        ucontrol->value.integer.value[1] = !tas->muted_r;
+        return 0;
+}
+
+static int tas_snd_mute_put(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct tas *tas = snd_kcontrol_chip(kcontrol);
+
+        if (tas->muted_l == !ucontrol->value.integer.value[0]
+         && tas->muted_r == !ucontrol->value.integer.value[1])
+                return 0;
+
+        tas->muted_l = !ucontrol->value.integer.value[0];
+        tas->muted_r = !ucontrol->value.integer.value[1];
+        tas_set_volume(tas);
+        return 1;
+}
+
+static struct snd_kcontrol_new mute_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Master Playback Switch",
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = tas_snd_mute_info,
+        .get = tas_snd_mute_get,
+        .put = tas_snd_mute_put,
+};
+
+static int tas_snd_mixer_info(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 2;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 177;
+        return 0;
+}
+
+static int tas_snd_mixer_get(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct tas *tas = snd_kcontrol_chip(kcontrol);
+        int idx = kcontrol->private_value;
+
+        ucontrol->value.integer.value[0] = tas->mixer_l[idx];
+        ucontrol->value.integer.value[1] = tas->mixer_r[idx];
+
+        return 0;
+}
+
+static int tas_snd_mixer_put(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct tas *tas = snd_kcontrol_chip(kcontrol);
+        int idx = kcontrol->private_value;
+
+        if (tas->mixer_l[idx] == ucontrol->value.integer.value[0]
+         && tas->mixer_r[idx] == ucontrol->value.integer.value[1])
+                return 0;
+
+        tas->mixer_l[idx] = ucontrol->value.integer.value[0];
+        tas->mixer_r[idx] = ucontrol->value.integer.value[1];
+
+        tas_set_mixer(tas);
+        return 1;
+}
+
+#define MIXER_CONTROL(n,descr,idx)                      \
+static struct snd_kcontrol_new n##_control = {          \
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
+        .name = descr " Playback Volume",               \
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,      \
+        .info = tas_snd_mixer_info,                     \
+        .get = tas_snd_mixer_get,                       \
+        .put = tas_snd_mixer_put,                       \
+        .private_value = idx,                           \
+}
+
+MIXER_CONTROL(pcm1, "PCM1", 0);
+MIXER_CONTROL(monitor, "Monitor", 2);
+
+static int tas_snd_capture_source_info(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_info *uinfo)
+{
+        static char *texts[] = { "Line-In", "Microphone" };
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 2;
+        if (uinfo->value.enumerated.item > 1)
+                uinfo->value.enumerated.item = 1;
+        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
+static int tas_snd_capture_source_get(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct tas *tas = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.enumerated.item[0] = !!(tas->acr & TAS_ACR_INPUT_B);
+        return 0;
+}
+
+static int tas_snd_capture_source_put(struct snd_kcontrol *kcontrol,
+        struct snd_ctl_elem_value *ucontrol)
+{
+        struct tas *tas = snd_kcontrol_chip(kcontrol);
+        int oldacr = tas->acr;
+
+        tas->acr &= ~TAS_ACR_INPUT_B;
+        if (ucontrol->value.enumerated.item[0])
+                tas->acr |= TAS_ACR_INPUT_B;
+        if (oldacr == tas->acr)
+                return 0;
+        tas_write_reg(tas, TAS_REG_ACR, 1, &tas->acr);
+        return 1;
+}
+
+static struct snd_kcontrol_new capture_source_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        /* If we name this 'Input Source', it properly shows up in
+         * alsamixer as a selection, * but it's shown under the
+         * 'Playback' category.
+         * If I name it 'Capture Source', it shows up in strange
+         * ways (two bools of which one can be selected at a
+         * time) but at least it's shown in the 'Capture'
+         * category.
+         * I was told that this was due to backward compatibility,
+         * but I don't understand then why the mangling is *not*
+         * done when I name it "Input Source".....
+         */
+        .name = "Capture Source",
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = tas_snd_capture_source_info,
+        .get = tas_snd_capture_source_get,
+        .put = tas_snd_capture_source_put,
+};
+
+
+static struct transfer_info tas_transfers[] = {
+        {
+                /* input */
+                .formats = SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_S16_BE |
+                           SNDRV_PCM_FMTBIT_S24_BE | SNDRV_PCM_FMTBIT_S24_BE,
+                .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
+                .transfer_in = 1,
+        },
+        {
+                /* output */
+                .formats = SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_S16_BE |
+                           SNDRV_PCM_FMTBIT_S24_BE | SNDRV_PCM_FMTBIT_S24_BE,
+                .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
+                .transfer_in = 0,
+        },
+        {}
+};
+
+static int tas_usable(struct codec_info_item *cii,
+                      struct transfer_info *ti,
+                      struct transfer_info *out)
+{
+        return 1;
+}
+
+static int tas_reset_init(struct tas *tas)
+{
+        u8 tmp;
+        tas->codec.gpio->methods->set_hw_reset(tas->codec.gpio, 0);
+        msleep(1);
+        tas->codec.gpio->methods->set_hw_reset(tas->codec.gpio, 1);
+        msleep(1);
+        tas->codec.gpio->methods->set_hw_reset(tas->codec.gpio, 0);
+        msleep(1);
+
+        tas->acr &= ~TAS_ACR_ANALOG_PDOWN;
+        tas->acr |= TAS_ACR_B_MONAUREAL | TAS_ACR_B_MON_SEL_RIGHT;
+        if (tas_write_reg(tas, TAS_REG_ACR, 1, &tas->acr))
+                return -ENODEV;
+
+        tmp = TAS_MCS_SCLK64 | TAS_MCS_SPORT_MODE_I2S | TAS_MCS_SPORT_WL_24BIT;
+        if (tas_write_reg(tas, TAS_REG_MCS, 1, &tmp))
+                return -ENODEV;
+
+        tmp = 0;
+        if (tas_write_reg(tas, TAS_REG_MCS2, 1, &tmp))
+                return -ENODEV;
+
+        return 0;
+}
+
+/* we are controlled via i2c and assume that is always up
+ * If that wasn't the case, we'd have to suspend once
+ * our i2c device is suspended, and then take note of that! */
+static int tas_suspend(struct tas *tas)
+{
+        tas->acr |= TAS_ACR_ANALOG_PDOWN;
+        tas_write_reg(tas, TAS_REG_ACR, 1, &tas->acr);
+        return 0;
+}
+
+static int tas_resume(struct tas *tas)
+{
+        /* reset codec */
+        tas_reset_init(tas);
+        tas_set_volume(tas);
+        tas_set_mixer(tas);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int _tas_suspend(struct codec_info_item *cii, pm_message_t state)
+{
+        return tas_suspend(cii->codec_data);
+}
+
+static int _tas_resume(struct codec_info_item *cii)
+{
+        return tas_resume(cii->codec_data);
+}
+#endif
+
+static struct codec_info tas_codec_info = {
+        .transfers = tas_transfers,
+        /* in theory, we can drive it at 512 too...
+         * but so far the framework doesn't allow
+         * for that and I don't see much point in it. */
+        .sysclock_factor = 256,
+        /* same here, could be 32 for just one 16 bit format */
+        .bus_factor = 64,
+        .owner = THIS_MODULE,
+        .usable = tas_usable,
+#ifdef CONFIG_PM
+        .suspend = _tas_suspend,
+        .resume = _tas_resume,
+#endif
+};
+
+static int tas_init_codec(struct aoa_codec *codec)
+{
+        struct tas *tas = codec_to_tas(codec);
+        int err;
+
+        if (!tas->codec.gpio || !tas->codec.gpio->methods) {
+                printk(KERN_ERR PFX "gpios not assigned!!\n");
+                return -EINVAL;
+        }
+
+        if (tas_reset_init(tas)) {
+                printk(KERN_ERR PFX "tas failed to initialise\n");
+                return -ENXIO;
+        }
+
+        if (tas->codec.soundbus_dev->attach_codec(tas->codec.soundbus_dev,
+                                                   aoa_get_card(),
+                                                   &tas_codec_info, tas)) {
+                printk(KERN_ERR PFX "error attaching tas to soundbus\n");
+                return -ENODEV;
+        }
+
+        if (aoa_snd_device_new(SNDRV_DEV_LOWLEVEL, tas, &ops)) {
+                printk(KERN_ERR PFX "failed to create tas snd device!\n");
+                return -ENODEV;
+        }
+        err = aoa_snd_ctl_add(snd_ctl_new1(&volume_control, tas));
+        if (err)
+                goto error;
+
+        err = aoa_snd_ctl_add(snd_ctl_new1(&mute_control, tas));
+        if (err)
+                goto error;
+
+        err = aoa_snd_ctl_add(snd_ctl_new1(&pcm1_control, tas));
+        if (err)
+                goto error;
+
+        err = aoa_snd_ctl_add(snd_ctl_new1(&monitor_control, tas));
+        if (err)
+                goto error;
+
+        err = aoa_snd_ctl_add(snd_ctl_new1(&capture_source_control, tas));
+        if (err)
+                goto error;
+
+        return 0;
+ error:
+        tas->codec.soundbus_dev->detach_codec(tas->codec.soundbus_dev, tas);
+        snd_device_free(aoa_get_card(), tas);
+        return err;
+}
+
+static void tas_exit_codec(struct aoa_codec *codec)
+{
+        struct tas *tas = codec_to_tas(codec);
+
+        if (!tas->codec.soundbus_dev)
+                return;
+        tas->codec.soundbus_dev->detach_codec(tas->codec.soundbus_dev, tas);
+}
+        
+
+static struct i2c_driver tas_driver;
+
+static int tas_create(struct i2c_adapter *adapter,
+                       struct device_node *node,
+                       int addr)
+{
+        struct tas *tas;
+
+        tas = kzalloc(sizeof(struct tas), GFP_KERNEL);
+
+        if (!tas)
+                return -ENOMEM;
+
+        tas->i2c.driver = &tas_driver;
+        tas->i2c.adapter = adapter;
+        tas->i2c.addr = addr;
+        strlcpy(tas->i2c.name, "tas audio codec", I2C_NAME_SIZE-1);
+
+        if (i2c_attach_client(&tas->i2c)) {
+                printk(KERN_ERR PFX "failed to attach to i2c\n");
+                goto fail;
+        }
+
+        strlcpy(tas->codec.name, "tas", MAX_CODEC_NAME_LEN-1);
+        tas->codec.owner = THIS_MODULE;
+        tas->codec.init = tas_init_codec;
+        tas->codec.exit = tas_exit_codec;
+        tas->codec.node = of_node_get(node);
+
+        if (aoa_codec_register(&tas->codec)) {
+                goto detach;
+        }
+        printk(KERN_DEBUG "snd-aoa-codec-tas: created and attached tas instance\n");
+        return 0;
+ detach:
+        i2c_detach_client(&tas->i2c);
+ fail:
+        kfree(tas);
+        return -EINVAL;
+}
+
+static int tas_i2c_attach(struct i2c_adapter *adapter)
+{
+        struct device_node *busnode, *dev = NULL;
+        struct pmac_i2c_bus *bus;
+
+        bus = pmac_i2c_adapter_to_bus(adapter);
+        if (bus == NULL)
+                return -ENODEV;
+        busnode = pmac_i2c_get_bus_node(bus);
+
+        while ((dev = of_get_next_child(busnode, dev)) != NULL) {
+                if (device_is_compatible(dev, "tas3004")) {
+                        u32 *addr;
+                        printk(KERN_DEBUG PFX "found tas3004\n");
+                        addr = (u32 *) get_property(dev, "reg", NULL);
+                        if (!addr)
+                                continue;
+                        return tas_create(adapter, dev, ((*addr) >> 1) & 0x7f);
+                }
+                /* older machines have no 'codec' node with a 'compatible'
+                 * property that says 'tas3004', they just have a 'deq'
+                 * node without any such property... */
+                if (strcmp(dev->name, "deq") == 0) {
+                        u32 *_addr, addr;
+                        printk(KERN_DEBUG PFX "found 'deq' node\n");
+                        _addr = (u32 *) get_property(dev, "i2c-address", NULL);
+                        if (!_addr)
+                                continue;
+                        addr = ((*_addr) >> 1) & 0x7f;
+                        /* now, if the address doesn't match any of the two
+                         * that a tas3004 can have, we cannot handle this.
+                         * I doubt it ever happens but hey. */
+                        if (addr != 0x34 && addr != 0x35)
+                                continue;
+                        return tas_create(adapter, dev, addr);
+                }
+        }
+        return -ENODEV;
+}
+
+static int tas_i2c_detach(struct i2c_client *client)
+{
+        struct tas *tas = container_of(client, struct tas, i2c);
+        int err;
+        u8 tmp = TAS_ACR_ANALOG_PDOWN;
+
+        if ((err = i2c_detach_client(client)))
+                return err;
+        aoa_codec_unregister(&tas->codec);
+        of_node_put(tas->codec.node);
+
+        /* power down codec chip */
+        tas_write_reg(tas, TAS_REG_ACR, 1, &tmp);
+
+        kfree(tas);
+        return 0;
+}
+
+static struct i2c_driver tas_driver = {
+        .driver = {
+                .name = "aoa_codec_tas",
+                .owner = THIS_MODULE,
+        },
+        .attach_adapter = tas_i2c_attach,
+        .detach_client = tas_i2c_detach,
+};
+
+static int __init tas_init(void)
+{
+        return i2c_add_driver(&tas_driver);
+}
+
+static void __exit tas_exit(void)
+{
+        i2c_del_driver(&tas_driver);
+}
+
+module_init(tas_init);
+module_exit(tas_exit);
diff --git a/sound/aoa/codecs/snd-aoa-codec-tas.h b/sound/aoa/codecs/snd-aoa-codec-tas.h
new file mode 100644
index 000000000000..daf81f45d83a
--- /dev/null
+++ b/sound/aoa/codecs/snd-aoa-codec-tas.h
@@ -0,0 +1,47 @@
+/*
+ * Apple Onboard Audio driver for tas codec (header)
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+#ifndef __SND_AOA_CODECTASH
+#define __SND_AOA_CODECTASH
+
+#define TAS_REG_MCS     0x01    /* main control */
+#       define TAS_MCS_FASTLOAD         (1<<7)
+#       define TAS_MCS_SCLK64           (1<<6)
+#       define TAS_MCS_SPORT_MODE_MASK  (3<<4)
+#       define TAS_MCS_SPORT_MODE_I2S   (2<<4)
+#       define TAS_MCS_SPORT_MODE_RJ    (1<<4)
+#       define TAS_MCS_SPORT_MODE_LJ    (0<<4)
+#       define TAS_MCS_SPORT_WL_MASK    (3<<0)
+#       define TAS_MCS_SPORT_WL_16BIT   (0<<0)
+#       define TAS_MCS_SPORT_WL_18BIT   (1<<0)
+#       define TAS_MCS_SPORT_WL_20BIT   (2<<0)
+#       define TAS_MCS_SPORT_WL_24BIT   (3<<0)
+
+#define TAS_REG_DRC     0x02
+#define TAS_REG_VOL     0x04
+#define TAS_REG_TREBLE  0x05
+#define TAS_REG_BASS    0x06
+#define TAS_REG_LMIX    0x07
+#define TAS_REG_RMIX    0x08
+
+#define TAS_REG_ACR     0x40    /* analog control */
+#       define TAS_ACR_B_MONAUREAL      (1<<7)
+#       define TAS_ACR_B_MON_SEL_RIGHT  (1<<6)
+#       define TAS_ACR_DEEMPH_MASK      (3<<2)
+#       define TAS_ACR_DEEMPH_OFF       (0<<2)
+#       define TAS_ACR_DEEMPH_48KHz     (1<<2)
+#       define TAS_ACR_DEEMPH_44KHz     (2<<2)
+#       define TAS_ACR_INPUT_B          (1<<1)
+#       define TAS_ACR_ANALOG_PDOWN     (1<<0)
+
+#define TAS_REG_MCS2    0x43    /* main control 2 */
+#       define TAS_MCS2_ALLPASS         (1<<1)
+
+#define TAS_REG_LEFT_BIQUAD6    0x10
+#define TAS_REG_RIGHT_BIQUAD6   0x19
+
+#endif /* __SND_AOA_CODECTASH */
diff --git a/sound/aoa/codecs/snd-aoa-codec-toonie.c b/sound/aoa/codecs/snd-aoa-codec-toonie.c
new file mode 100644
index 000000000000..bcc555647e79
--- /dev/null
+++ b/sound/aoa/codecs/snd-aoa-codec-toonie.c
@@ -0,0 +1,141 @@
+/*
+ * Apple Onboard Audio driver for Toonie codec
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ *
+ *
+ * This is a driver for the toonie codec chip. This chip is present
+ * on the Mac Mini and is nothing but a DAC.
+ */
+#include <linux/delay.h>
+#include <linux/module.h>
+MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("toonie codec driver for snd-aoa");
+
+#include "../aoa.h"
+#include "../soundbus/soundbus.h"
+
+
+#define PFX "snd-aoa-codec-toonie: "
+
+struct toonie {
+        struct aoa_codec        codec;
+};
+#define codec_to_toonie(c) container_of(c, struct toonie, codec)
+
+static int toonie_dev_register(struct snd_device *dev)
+{
+        return 0;
+}
+
+static struct snd_device_ops ops = {
+        .dev_register = toonie_dev_register,
+};
+
+static struct transfer_info toonie_transfers[] = {
+        /* This thing *only* has analog output,
+         * the rates are taken from Info.plist
+         * from Darwin. */
+        {
+                .formats = SNDRV_PCM_FMTBIT_S16_BE |
+                           SNDRV_PCM_FMTBIT_S24_BE,
+                .rates = SNDRV_PCM_RATE_32000 |
+                         SNDRV_PCM_RATE_44100 |
+                         SNDRV_PCM_RATE_48000 |
+                         SNDRV_PCM_RATE_88200 |
+                         SNDRV_PCM_RATE_96000,
+        },
+        {}
+};
+
+#ifdef CONFIG_PM
+static int toonie_suspend(struct codec_info_item *cii, pm_message_t state)
+{
+        /* can we turn it off somehow? */
+        return 0;
+}
+
+static int toonie_resume(struct codec_info_item *cii)
+{
+        return 0;
+}
+#endif /* CONFIG_PM */
+
+static struct codec_info toonie_codec_info = {
+        .transfers = toonie_transfers,
+        .sysclock_factor = 256,
+        .bus_factor = 64,
+        .owner = THIS_MODULE,
+#ifdef CONFIG_PM
+        .suspend = toonie_suspend,
+        .resume = toonie_resume,
+#endif
+};
+
+static int toonie_init_codec(struct aoa_codec *codec)
+{
+        struct toonie *toonie = codec_to_toonie(codec);
+
+        if (aoa_snd_device_new(SNDRV_DEV_LOWLEVEL, toonie, &ops)) {
+                printk(KERN_ERR PFX "failed to create toonie snd device!\n");
+                return -ENODEV;
+        }
+
+        /* nothing connected? what a joke! */
+        if (toonie->codec.connected != 1)
+                return -ENOTCONN;
+
+        if (toonie->codec.soundbus_dev->attach_codec(toonie->codec.soundbus_dev,
+                                                     aoa_get_card(),
+                                                     &toonie_codec_info, toonie)) {
+                printk(KERN_ERR PFX "error creating toonie pcm\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static void toonie_exit_codec(struct aoa_codec *codec)
+{
+        struct toonie *toonie = codec_to_toonie(codec);
+
+        if (!toonie->codec.soundbus_dev) {
+                printk(KERN_ERR PFX "toonie_exit_codec called without soundbus_dev!\n");
+                return;
+        }
+        toonie->codec.soundbus_dev->detach_codec(toonie->codec.soundbus_dev, toonie);
+}
+
+static struct toonie *toonie;
+
+static int __init toonie_init(void)
+{
+        toonie = kzalloc(sizeof(struct toonie), GFP_KERNEL);
+
+        if (!toonie)
+                return -ENOMEM;
+
+        strlcpy(toonie->codec.name, "toonie", sizeof(toonie->codec.name));
+        toonie->codec.owner = THIS_MODULE;
+        toonie->codec.init = toonie_init_codec;
+        toonie->codec.exit = toonie_exit_codec;
+                                        
+        if (aoa_codec_register(&toonie->codec)) {
+                kfree(toonie);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void __exit toonie_exit(void)
+{
+        aoa_codec_unregister(&toonie->codec);
+        kfree(toonie);
+}
+
+module_init(toonie_init);
+module_exit(toonie_exit);
diff --git a/sound/aoa/core/Makefile b/sound/aoa/core/Makefile
new file mode 100644
index 000000000000..62dc7287f663
--- /dev/null
+++ b/sound/aoa/core/Makefile
@@ -0,0 +1,5 @@
+obj-$(CONFIG_SND_AOA) += snd-aoa.o
+snd-aoa-objs := snd-aoa-core.o \
+                snd-aoa-alsa.o \
+                snd-aoa-gpio-pmf.o \
+                snd-aoa-gpio-feature.o
diff --git a/sound/aoa/core/snd-aoa-alsa.c b/sound/aoa/core/snd-aoa-alsa.c
new file mode 100644
index 000000000000..b42fdea77ed0
--- /dev/null
+++ b/sound/aoa/core/snd-aoa-alsa.c
@@ -0,0 +1,98 @@
+/*
+ * Apple Onboard Audio Alsa helpers
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+#include <linux/module.h>
+#include "snd-aoa-alsa.h"
+
+static int index = -1;
+module_param(index, int, 0444);
+MODULE_PARM_DESC(index, "index for AOA sound card.");
+
+static struct aoa_card *aoa_card;
+
+int aoa_alsa_init(char *name, struct module *mod)
+{
+        struct snd_card *alsa_card;
+        int err;
+
+        if (aoa_card)
+                /* cannot be EEXIST due to usage in aoa_fabric_register */
+                return -EBUSY;
+
+        alsa_card = snd_card_new(index, name, mod, sizeof(struct aoa_card));
+        if (!alsa_card)
+                return -ENOMEM;
+        aoa_card = alsa_card->private_data;
+        aoa_card->alsa_card = alsa_card;
+        strlcpy(alsa_card->driver, "AppleOnbdAudio", sizeof(alsa_card->driver));
+        strlcpy(alsa_card->shortname, name, sizeof(alsa_card->shortname));
+        strlcpy(alsa_card->longname, name, sizeof(alsa_card->longname));
+        strlcpy(alsa_card->mixername, name, sizeof(alsa_card->mixername));
+        err = snd_card_register(aoa_card->alsa_card);
+        if (err < 0) {
+                printk(KERN_ERR "snd-aoa: couldn't register alsa card\n");
+                snd_card_free(aoa_card->alsa_card);
+                aoa_card = NULL;
+                return err;
+        }
+        return 0;
+}
+
+struct snd_card *aoa_get_card(void)
+{
+        if (aoa_card)
+                return aoa_card->alsa_card;
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(aoa_get_card);
+
+void aoa_alsa_cleanup(void)
+{
+        if (aoa_card) {
+                snd_card_free(aoa_card->alsa_card);
+                aoa_card = NULL;
+        }
+}
+
+int aoa_snd_device_new(snd_device_type_t type,
+        void * device_data, struct snd_device_ops * ops)
+{
+        struct snd_card *card = aoa_get_card();
+        int err;
+        
+        if (!card) return -ENOMEM;
+
+        err = snd_device_new(card, type, device_data, ops);
+        if (err) {
+                printk(KERN_ERR "snd-aoa: failed to create snd device (%d)\n", err);
+                return err;
+        }
+        err = snd_device_register(card, device_data);
+        if (err) {
+                printk(KERN_ERR "snd-aoa: failed to register "
+                                "snd device (%d)\n", err);
+                printk(KERN_ERR "snd-aoa: have you forgotten the "
+                                "dev_register callback?\n");
+                snd_device_free(card, device_data);
+        }
+        return err;
+}
+EXPORT_SYMBOL_GPL(aoa_snd_device_new);
+
+int aoa_snd_ctl_add(struct snd_kcontrol* control)
+{
+        int err;
+
+        if (!aoa_card) return -ENODEV;
+
+        err = snd_ctl_add(aoa_card->alsa_card, control);
+        if (err)
+                printk(KERN_ERR "snd-aoa: failed to add alsa control (%d)\n",
+                       err);
+        return err;
+}
+EXPORT_SYMBOL_GPL(aoa_snd_ctl_add);
diff --git a/sound/aoa/core/snd-aoa-alsa.h b/sound/aoa/core/snd-aoa-alsa.h
new file mode 100644
index 000000000000..660d2f1793bb
--- /dev/null
+++ b/sound/aoa/core/snd-aoa-alsa.h
@@ -0,0 +1,16 @@
+/*
+ * Apple Onboard Audio Alsa private helpers
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+
+#ifndef __SND_AOA_ALSA_H
+#define __SND_AOA_ALSA_H
+#include "../aoa.h"
+
+extern int aoa_alsa_init(char *name, struct module *mod);
+extern void aoa_alsa_cleanup(void);
+
+#endif /* __SND_AOA_ALSA_H */
diff --git a/sound/aoa/core/snd-aoa-core.c b/sound/aoa/core/snd-aoa-core.c
new file mode 100644
index 000000000000..ecd2d8263f2d
--- /dev/null
+++ b/sound/aoa/core/snd-aoa-core.c
@@ -0,0 +1,162 @@
+/*
+ * Apple Onboard Audio driver core
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/list.h>
+#include "../aoa.h"
+#include "snd-aoa-alsa.h"
+
+MODULE_DESCRIPTION("Apple Onboard Audio Sound Driver");
+MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
+MODULE_LICENSE("GPL");
+
+/* We allow only one fabric. This simplifies things,
+ * and more don't really make that much sense */
+static struct aoa_fabric *fabric;
+static LIST_HEAD(codec_list);
+
+static int attach_codec_to_fabric(struct aoa_codec *c)
+{
+        int err;
+
+        if (!try_module_get(c->owner))
+                return -EBUSY;
+        /* found_codec has to be assigned */
+        err = -ENOENT;
+        if (fabric->found_codec)
+                err = fabric->found_codec(c);
+        if (err) {
+                module_put(c->owner);
+                printk(KERN_ERR "snd-aoa: fabric didn't like codec %s\n",
+                                c->name);
+                return err;
+        }
+        c->fabric = fabric;
+
+        err = 0;
+        if (c->init)
+                err = c->init(c);
+        if (err) {
+                printk(KERN_ERR "snd-aoa: codec %s didn't init\n", c->name);
+                c->fabric = NULL;
+                if (fabric->remove_codec)
+                        fabric->remove_codec(c);
+                module_put(c->owner);
+                return err;
+        }
+        if (fabric->attached_codec)
+                fabric->attached_codec(c);
+        return 0;
+}
+
+int aoa_codec_register(struct aoa_codec *codec)
+{
+        int err = 0;
+
+        /* if there's a fabric already, we can tell if we
+         * will want to have this codec, so propagate error
+         * through. Otherwise, this will happen later... */
+        if (fabric)
+                err = attach_codec_to_fabric(codec);
+        if (!err)
+                list_add(&codec->list, &codec_list);
+        return err;
+}
+EXPORT_SYMBOL_GPL(aoa_codec_register);
+
+void aoa_codec_unregister(struct aoa_codec *codec)
+{
+        list_del(&codec->list);
+        if (codec->fabric && codec->exit)
+                codec->exit(codec);
+        if (fabric && fabric->remove_codec)
+                fabric->remove_codec(codec);
+        codec->fabric = NULL;
+        module_put(codec->owner);
+}
+EXPORT_SYMBOL_GPL(aoa_codec_unregister);
+
+int aoa_fabric_register(struct aoa_fabric *new_fabric)
+{
+        struct aoa_codec *c;
+        int err;
+
+        /* allow querying for presence of fabric
+         * (i.e. do this test first!) */
+        if (new_fabric == fabric) {
+                err = -EALREADY;
+                goto attach;
+        }
+        if (fabric)
+                return -EEXIST;
+        if (!new_fabric)
+                return -EINVAL;
+
+        err = aoa_alsa_init(new_fabric->name, new_fabric->owner);
+        if (err)
+                return err;
+
+        fabric = new_fabric;
+
+ attach:
+        list_for_each_entry(c, &codec_list, list) {
+                if (c->fabric != fabric)
+                        attach_codec_to_fabric(c);
+        }
+        return err;
+}
+EXPORT_SYMBOL_GPL(aoa_fabric_register);
+
+void aoa_fabric_unregister(struct aoa_fabric *old_fabric)
+{
+        struct aoa_codec *c;
+
+        if (fabric != old_fabric)
+                return;
+
+        list_for_each_entry(c, &codec_list, list) {
+                if (c->fabric)
+                        aoa_fabric_unlink_codec(c);
+        }
+
+        aoa_alsa_cleanup();
+
+        fabric = NULL;
+}
+EXPORT_SYMBOL_GPL(aoa_fabric_unregister);
+
+void aoa_fabric_unlink_codec(struct aoa_codec *codec)
+{
+        if (!codec->fabric) {
+                printk(KERN_ERR "snd-aoa: fabric unassigned "
+                                "in aoa_fabric_unlink_codec\n");
+                dump_stack();
+                return;
+        }
+        if (codec->exit)
+                codec->exit(codec);
+        if (codec->fabric->remove_codec)
+                codec->fabric->remove_codec(codec);
+        codec->fabric = NULL;
+        module_put(codec->owner);
+}
+EXPORT_SYMBOL_GPL(aoa_fabric_unlink_codec);
+
+static int __init aoa_init(void)
+{
+        return 0;
+}
+
+static void __exit aoa_exit(void)
+{
+        aoa_alsa_cleanup();
+}
+
+module_init(aoa_init);
+module_exit(aoa_exit);
diff --git a/sound/aoa/core/snd-aoa-gpio-feature.c b/sound/aoa/core/snd-aoa-gpio-feature.c
new file mode 100644
index 000000000000..2c6eb7784cc9
--- /dev/null
+++ b/sound/aoa/core/snd-aoa-gpio-feature.c
@@ -0,0 +1,399 @@
+/*
+ * Apple Onboard Audio feature call GPIO control
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ *
+ * This file contains the GPIO control routines for 
+ * direct (through feature calls) access to the GPIO
+ * registers.
+ */
+
+#include <asm/pmac_feature.h>
+#include <linux/interrupt.h>
+#include "../aoa.h"
+
+/* TODO: these are 20 global variables
+ * that aren't used on most machines...
+ * Move them into a dynamically allocated
+ * structure and use that.
+ */
+
+/* these are the GPIO numbers (register addresses as offsets into
+ * the GPIO space) */
+static int headphone_mute_gpio;
+static int amp_mute_gpio;
+static int lineout_mute_gpio;
+static int hw_reset_gpio;
+static int lineout_detect_gpio;
+static int headphone_detect_gpio;
+static int linein_detect_gpio;
+
+/* see the SWITCH_GPIO macro */
+static int headphone_mute_gpio_activestate;
+static int amp_mute_gpio_activestate;
+static int lineout_mute_gpio_activestate;
+static int hw_reset_gpio_activestate;
+static int lineout_detect_gpio_activestate;
+static int headphone_detect_gpio_activestate;
+static int linein_detect_gpio_activestate;
+
+/* node pointers that we save when getting the GPIO number
+ * to get the interrupt later */
+static struct device_node *lineout_detect_node;
+static struct device_node *linein_detect_node;
+static struct device_node *headphone_detect_node;
+
+static int lineout_detect_irq;
+static int linein_detect_irq;
+static int headphone_detect_irq;
+
+static struct device_node *get_gpio(char *name,
+                                    char *altname,
+                                    int *gpioptr,
+                                    int *gpioactiveptr)
+{
+        struct device_node *np, *gpio;
+        u32 *reg;
+        char *audio_gpio;
+
+        *gpioptr = -1;
+
+        /* check if we can get it the easy way ... */
+        np = of_find_node_by_name(NULL, name);
+        if (!np) {
+                /* some machines have only gpioX/extint-gpioX nodes,
+                 * and an audio-gpio property saying what it is ...
+                 * So what we have to do is enumerate all children
+                 * of the gpio node and check them all. */
+                gpio = of_find_node_by_name(NULL, "gpio");
+                if (!gpio)
+                        return NULL;
+                while ((np = of_get_next_child(gpio, np))) {
+                        audio_gpio = get_property(np, "audio-gpio", NULL);
+                        if (!audio_gpio)
+                                continue;
+                        if (strcmp(audio_gpio, name) == 0)
+                                break;
+                        if (altname && (strcmp(audio_gpio, altname) == 0))
+                                break;
+                }
+                /* still not found, assume not there */
+                if (!np)
+                        return NULL;
+        }
+
+        reg = (u32 *)get_property(np, "reg", NULL);
+        if (!reg)
+                return NULL;
+
+        *gpioptr = *reg;
+
+        /* this is a hack, usually the GPIOs 'reg' property
+         * should have the offset based from the GPIO space
+         * which is at 0x50, but apparently not always... */
+        if (*gpioptr < 0x50)
+                *gpioptr += 0x50;
+
+        reg = (u32 *)get_property(np, "audio-gpio-active-state", NULL);
+        if (!reg)
+                /* Apple seems to default to 1, but
+                 * that doesn't seem right at least on most
+                 * machines. So until proven that the opposite
+                 * is necessary, we default to 0
+                 * (which, incidentally, snd-powermac also does...) */
+                *gpioactiveptr = 0;
+        else
+                *gpioactiveptr = *reg;
+
+        return np;
+}
+
+static void get_irq(struct device_node * np, int *irqptr)
+{
+        *irqptr = -1;
+        if (!np)
+                return;
+        if (np->n_intrs != 1)
+                return;
+        *irqptr = np->intrs[0].line;
+}
+
+/* 0x4 is outenable, 0x1 is out, thus 4 or 5 */
+#define SWITCH_GPIO(name, v, on)                                \
+        (((v)&~1) | ((on)?                                      \
+                        (name##_gpio_activestate==0?4:5):       \
+                        (name##_gpio_activestate==0?5:4)))
+
+#define FTR_GPIO(name, bit)                                     \
+static void ftr_gpio_set_##name(struct gpio_runtime *rt, int on)\
+{                                                               \
+        int v;                                                  \
+                                                                \
+        if (unlikely(!rt)) return;                              \
+                                                                \
+        if (name##_mute_gpio < 0)                               \
+                return;                                         \
+                                                                \
+        v = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL,         \
+                              name##_mute_gpio,                 \
+                              0);                               \
+                                                                \
+        /* muted = !on... */                                    \
+        v = SWITCH_GPIO(name##_mute, v, !on);                   \
+                                                                \
+        pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL,            \
+                          name##_mute_gpio, v);                 \
+                                                                \
+        rt->implementation_private &= ~(1<<bit);                \
+        rt->implementation_private |= (!!on << bit);            \
+}                                                               \
+static int ftr_gpio_get_##name(struct gpio_runtime *rt)         \
+{                                                               \
+        if (unlikely(!rt)) return 0;                            \
+        return (rt->implementation_private>>bit)&1;             \
+}
+
+FTR_GPIO(headphone, 0);
+FTR_GPIO(amp, 1);
+FTR_GPIO(lineout, 2);
+
+static void ftr_gpio_set_hw_reset(struct gpio_runtime *rt, int on)
+{
+        int v;
+
+        if (unlikely(!rt)) return;
+        if (hw_reset_gpio < 0)
+                return;
+
+        v = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL,
+                              hw_reset_gpio, 0);
+        v = SWITCH_GPIO(hw_reset, v, on);
+        pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL,
+                          hw_reset_gpio, v);
+}
+
+static void ftr_gpio_all_amps_off(struct gpio_runtime *rt)
+{
+        int saved;
+
+        if (unlikely(!rt)) return;
+        saved = rt->implementation_private;
+        ftr_gpio_set_headphone(rt, 0);
+        ftr_gpio_set_amp(rt, 0);
+        ftr_gpio_set_lineout(rt, 0);
+        rt->implementation_private = saved;
+}
+
+static void ftr_gpio_all_amps_restore(struct gpio_runtime *rt)
+{
+        int s;
+
+        if (unlikely(!rt)) return;
+        s = rt->implementation_private;
+        ftr_gpio_set_headphone(rt, (s>>0)&1);
+        ftr_gpio_set_amp(rt, (s>>1)&1);
+        ftr_gpio_set_lineout(rt, (s>>2)&1);
+}
+
+static void ftr_handle_notify(void *data)
+{
+        struct gpio_notification *notif = data;
+
+        mutex_lock(&notif->mutex);
+        if (notif->notify)
+                notif->notify(notif->data);
+        mutex_unlock(&notif->mutex);
+}
+
+static void ftr_gpio_init(struct gpio_runtime *rt)
+{
+        get_gpio("headphone-mute", NULL,
+                 &headphone_mute_gpio,
+                 &headphone_mute_gpio_activestate);
+        get_gpio("amp-mute", NULL,
+                 &amp_mute_gpio,
+                 &amp_mute_gpio_activestate);
+        get_gpio("lineout-mute", NULL,
+                 &lineout_mute_gpio,
+                 &lineout_mute_gpio_activestate);
+        get_gpio("hw-reset", "audio-hw-reset",
+                 &hw_reset_gpio,
+                 &hw_reset_gpio_activestate);
+
+        headphone_detect_node = get_gpio("headphone-detect", NULL,
+                                         &headphone_detect_gpio,
+                                         &headphone_detect_gpio_activestate);
+        /* go Apple, and thanks for giving these different names
+         * across the board... */
+        lineout_detect_node = get_gpio("lineout-detect", "line-output-detect",
+                                       &lineout_detect_gpio,
+                                       &lineout_detect_gpio_activestate);
+        linein_detect_node = get_gpio("linein-detect", "line-input-detect",
+                                      &linein_detect_gpio,
+                                      &linein_detect_gpio_activestate);
+
+        get_irq(headphone_detect_node, &headphone_detect_irq);
+        get_irq(lineout_detect_node, &lineout_detect_irq);
+        get_irq(linein_detect_node, &linein_detect_irq);
+
+        ftr_gpio_all_amps_off(rt);
+        rt->implementation_private = 0;
+        INIT_WORK(&rt->headphone_notify.work, ftr_handle_notify,
+                  &rt->headphone_notify);
+        INIT_WORK(&rt->line_in_notify.work, ftr_handle_notify,
+                  &rt->line_in_notify);
+        INIT_WORK(&rt->line_out_notify.work, ftr_handle_notify,
+                  &rt->line_out_notify);
+        mutex_init(&rt->headphone_notify.mutex);
+        mutex_init(&rt->line_in_notify.mutex);
+        mutex_init(&rt->line_out_notify.mutex);
+}
+
+static void ftr_gpio_exit(struct gpio_runtime *rt)
+{
+        ftr_gpio_all_amps_off(rt);
+        rt->implementation_private = 0;
+        if (rt->headphone_notify.notify)
+                free_irq(headphone_detect_irq, &rt->headphone_notify);
+        if (rt->line_in_notify.gpio_private)
+                free_irq(linein_detect_irq, &rt->line_in_notify);
+        if (rt->line_out_notify.gpio_private)
+                free_irq(lineout_detect_irq, &rt->line_out_notify);
+        cancel_delayed_work(&rt->headphone_notify.work);
+        cancel_delayed_work(&rt->line_in_notify.work);
+        cancel_delayed_work(&rt->line_out_notify.work);
+        flush_scheduled_work();
+        mutex_destroy(&rt->headphone_notify.mutex);
+        mutex_destroy(&rt->line_in_notify.mutex);
+        mutex_destroy(&rt->line_out_notify.mutex);
+}
+
+static irqreturn_t ftr_handle_notify_irq(int xx,
+                                         void *data,
+                                         struct pt_regs *regs)
+{
+        struct gpio_notification *notif = data;
+
+        schedule_work(&notif->work);
+
+        return IRQ_HANDLED;
+}
+
+static int ftr_set_notify(struct gpio_runtime *rt,
+                          enum notify_type type,
+                          notify_func_t notify,
+                          void *data)
+{
+        struct gpio_notification *notif;
+        notify_func_t old;
+        int irq;
+        char *name;
+        int err = -EBUSY;
+
+        switch (type) {
+        case AOA_NOTIFY_HEADPHONE:
+                notif = &rt->headphone_notify;
+                name = "headphone-detect";
+                irq = headphone_detect_irq;
+                break;
+        case AOA_NOTIFY_LINE_IN:
+                notif = &rt->line_in_notify;
+                name = "linein-detect";
+                irq = linein_detect_irq;
+                break;
+        case AOA_NOTIFY_LINE_OUT:
+                notif = &rt->line_out_notify;
+                name = "lineout-detect";
+                irq = lineout_detect_irq;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (irq == -1)
+                return -ENODEV;
+
+        mutex_lock(&notif->mutex);
+
+        old = notif->notify;
+
+        if (!old && !notify) {
+                err = 0;
+                goto out_unlock;
+        }
+
+        if (old && notify) {
+                if (old == notify && notif->data == data)
+                        err = 0;
+                goto out_unlock;
+        }
+
+        if (old && !notify)
+                free_irq(irq, notif);
+
+        if (!old && notify) {
+                err = request_irq(irq, ftr_handle_notify_irq, 0, name, notif);
+                if (err)
+                        goto out_unlock;
+        }
+
+        notif->notify = notify;
+        notif->data = data;
+
+        err = 0;
+ out_unlock:
+        mutex_unlock(&notif->mutex);
+        return err;
+}
+
+static int ftr_get_detect(struct gpio_runtime *rt,
+                          enum notify_type type)
+{
+        int gpio, ret, active;
+
+        switch (type) {
+        case AOA_NOTIFY_HEADPHONE:
+                gpio = headphone_detect_gpio;
+                active = headphone_detect_gpio_activestate;
+                break;
+        case AOA_NOTIFY_LINE_IN:
+                gpio = linein_detect_gpio;
+                active = linein_detect_gpio_activestate;
+                break;
+        case AOA_NOTIFY_LINE_OUT:
+                gpio = lineout_detect_gpio;
+                active = lineout_detect_gpio_activestate;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (gpio == -1)
+                return -ENODEV;
+
+        ret = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, gpio, 0);
+        if (ret < 0)
+                return ret;
+        return ((ret >> 1) & 1) == active;
+}
+
+static struct gpio_methods methods = {
+        .init                   = ftr_gpio_init,
+        .exit                   = ftr_gpio_exit,
+        .all_amps_off           = ftr_gpio_all_amps_off,
+        .all_amps_restore       = ftr_gpio_all_amps_restore,
+        .set_headphone          = ftr_gpio_set_headphone,
+        .set_speakers           = ftr_gpio_set_amp,
+        .set_lineout            = ftr_gpio_set_lineout,
+        .set_hw_reset           = ftr_gpio_set_hw_reset,
+        .get_headphone          = ftr_gpio_get_headphone,
+        .get_speakers           = ftr_gpio_get_amp,
+        .get_lineout            = ftr_gpio_get_lineout,
+        .set_notify             = ftr_set_notify,
+        .get_detect             = ftr_get_detect,
+};
+
+struct gpio_methods *ftr_gpio_methods = &methods;
+EXPORT_SYMBOL_GPL(ftr_gpio_methods);
diff --git a/sound/aoa/core/snd-aoa-gpio-pmf.c b/sound/aoa/core/snd-aoa-gpio-pmf.c
new file mode 100644
index 000000000000..0e9b9bb2a6de
--- /dev/null
+++ b/sound/aoa/core/snd-aoa-gpio-pmf.c
@@ -0,0 +1,246 @@
+/*
+ * Apple Onboard Audio pmf GPIOs
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+
+#include <asm/pmac_feature.h>
+#include <asm/pmac_pfunc.h>
+#include "../aoa.h"
+
+#define PMF_GPIO(name, bit)                                     \
+static void pmf_gpio_set_##name(struct gpio_runtime *rt, int on)\
+{                                                               \
+        struct pmf_args args = { .count = 1, .u[0].v = !on };   \
+                                                                \
+        if (unlikely(!rt)) return;                              \
+        pmf_call_function(rt->node, #name "-mute", &args);      \
+        rt->implementation_private &= ~(1<<bit);                \
+        rt->implementation_private |= (!!on << bit);            \
+}                                                               \
+static int pmf_gpio_get_##name(struct gpio_runtime *rt)         \
+{                                                               \
+        if (unlikely(!rt)) return 0;                            \
+        return (rt->implementation_private>>bit)&1;             \
+}
+
+PMF_GPIO(headphone, 0);
+PMF_GPIO(amp, 1);
+PMF_GPIO(lineout, 2);
+
+static void pmf_gpio_set_hw_reset(struct gpio_runtime *rt, int on)
+{
+        struct pmf_args args = { .count = 1, .u[0].v = !!on };
+
+        if (unlikely(!rt)) return;
+        pmf_call_function(rt->node, "hw-reset", &args);
+}
+
+static void pmf_gpio_all_amps_off(struct gpio_runtime *rt)
+{
+        int saved;
+
+        if (unlikely(!rt)) return;
+        saved = rt->implementation_private;
+        pmf_gpio_set_headphone(rt, 0);
+        pmf_gpio_set_amp(rt, 0);
+        pmf_gpio_set_lineout(rt, 0);
+        rt->implementation_private = saved;
+}
+
+static void pmf_gpio_all_amps_restore(struct gpio_runtime *rt)
+{
+        int s;
+
+        if (unlikely(!rt)) return;
+        s = rt->implementation_private;
+        pmf_gpio_set_headphone(rt, (s>>0)&1);
+        pmf_gpio_set_amp(rt, (s>>1)&1);
+        pmf_gpio_set_lineout(rt, (s>>2)&1);
+}
+
+static void pmf_handle_notify(void *data)
+{
+        struct gpio_notification *notif = data;
+
+        mutex_lock(&notif->mutex);
+        if (notif->notify)
+                notif->notify(notif->data);
+        mutex_unlock(&notif->mutex);
+}
+
+static void pmf_gpio_init(struct gpio_runtime *rt)
+{
+        pmf_gpio_all_amps_off(rt);
+        rt->implementation_private = 0;
+        INIT_WORK(&rt->headphone_notify.work, pmf_handle_notify,
+                  &rt->headphone_notify);
+        INIT_WORK(&rt->line_in_notify.work, pmf_handle_notify,
+                  &rt->line_in_notify);
+        INIT_WORK(&rt->line_out_notify.work, pmf_handle_notify,
+                  &rt->line_out_notify);
+        mutex_init(&rt->headphone_notify.mutex);
+        mutex_init(&rt->line_in_notify.mutex);
+        mutex_init(&rt->line_out_notify.mutex);
+}
+
+static void pmf_gpio_exit(struct gpio_runtime *rt)
+{
+        pmf_gpio_all_amps_off(rt);
+        rt->implementation_private = 0;
+
+        if (rt->headphone_notify.gpio_private)
+                pmf_unregister_irq_client(rt->headphone_notify.gpio_private);
+        if (rt->line_in_notify.gpio_private)
+                pmf_unregister_irq_client(rt->line_in_notify.gpio_private);
+        if (rt->line_out_notify.gpio_private)
+                pmf_unregister_irq_client(rt->line_out_notify.gpio_private);
+
+        /* make sure no work is pending before freeing
+         * all things */
+        cancel_delayed_work(&rt->headphone_notify.work);
+        cancel_delayed_work(&rt->line_in_notify.work);
+        cancel_delayed_work(&rt->line_out_notify.work);
+        flush_scheduled_work();
+
+        mutex_destroy(&rt->headphone_notify.mutex);
+        mutex_destroy(&rt->line_in_notify.mutex);
+        mutex_destroy(&rt->line_out_notify.mutex);
+
+        if (rt->headphone_notify.gpio_private)
+                kfree(rt->headphone_notify.gpio_private);
+        if (rt->line_in_notify.gpio_private)
+                kfree(rt->line_in_notify.gpio_private);
+        if (rt->line_out_notify.gpio_private)
+                kfree(rt->line_out_notify.gpio_private);
+}
+
+static void pmf_handle_notify_irq(void *data)
+{
+        struct gpio_notification *notif = data;
+
+        schedule_work(&notif->work);
+}
+
+static int pmf_set_notify(struct gpio_runtime *rt,
+                          enum notify_type type,
+                          notify_func_t notify,
+                          void *data)
+{
+        struct gpio_notification *notif;
+        notify_func_t old;
+        struct pmf_irq_client *irq_client;
+        char *name;
+        int err = -EBUSY;
+
+        switch (type) {
+        case AOA_NOTIFY_HEADPHONE:
+                notif = &rt->headphone_notify;
+                name = "headphone-detect";
+                break;
+        case AOA_NOTIFY_LINE_IN:
+                notif = &rt->line_in_notify;
+                name = "linein-detect";
+                break;
+        case AOA_NOTIFY_LINE_OUT:
+                notif = &rt->line_out_notify;
+                name = "lineout-detect";
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        mutex_lock(&notif->mutex);
+
+        old = notif->notify;
+
+        if (!old && !notify) {
+                err = 0;
+                goto out_unlock;
+        }
+
+        if (old && notify) {
+                if (old == notify && notif->data == data)
+                        err = 0;
+                goto out_unlock;
+        }
+
+        if (old && !notify) {
+                irq_client = notif->gpio_private;
+                pmf_unregister_irq_client(irq_client);
+                kfree(irq_client);
+                notif->gpio_private = NULL;
+        }
+        if (!old && notify) {
+                irq_client = kzalloc(sizeof(struct pmf_irq_client),
+                                     GFP_KERNEL);
+                irq_client->data = notif;
+                irq_client->handler = pmf_handle_notify_irq;
+                irq_client->owner = THIS_MODULE;
+                err = pmf_register_irq_client(rt->node,
+                                              name,
+                                              irq_client);
+                if (err) {
+                        printk(KERN_ERR "snd-aoa: gpio layer failed to"
+                                        " register %s irq (%d)\n", name, err);
+                        kfree(irq_client);
+                        goto out_unlock;
+                }
+                notif->gpio_private = irq_client;
+        }
+        notif->notify = notify;
+        notif->data = data;
+
+        err = 0;
+ out_unlock:
+        mutex_unlock(&notif->mutex);
+        return err;
+}
+
+static int pmf_get_detect(struct gpio_runtime *rt,
+                          enum notify_type type)
+{
+        char *name;
+        int err = -EBUSY, ret;
+        struct pmf_args args = { .count = 1, .u[0].p = &ret };
+
+        switch (type) {
+        case AOA_NOTIFY_HEADPHONE:
+                name = "headphone-detect";
+                break;
+        case AOA_NOTIFY_LINE_IN:
+                name = "linein-detect";
+                break;
+        case AOA_NOTIFY_LINE_OUT:
+                name = "lineout-detect";
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        err = pmf_call_function(rt->node, name, &args);
+        if (err)
+                return err;
+        return ret;
+}
+
+static struct gpio_methods methods = {
+        .init                   = pmf_gpio_init,
+        .exit                   = pmf_gpio_exit,
+        .all_amps_off           = pmf_gpio_all_amps_off,
+        .all_amps_restore       = pmf_gpio_all_amps_restore,
+        .set_headphone          = pmf_gpio_set_headphone,
+        .set_speakers           = pmf_gpio_set_amp,
+        .set_lineout            = pmf_gpio_set_lineout,
+        .set_hw_reset           = pmf_gpio_set_hw_reset,
+        .get_headphone          = pmf_gpio_get_headphone,
+        .get_speakers           = pmf_gpio_get_amp,
+        .get_lineout            = pmf_gpio_get_lineout,
+        .set_notify             = pmf_set_notify,
+        .get_detect             = pmf_get_detect,
+};
+
+struct gpio_methods *pmf_gpio_methods = &methods;
+EXPORT_SYMBOL_GPL(pmf_gpio_methods);
diff --git a/sound/aoa/fabrics/Kconfig b/sound/aoa/fabrics/Kconfig
new file mode 100644
index 000000000000..c3bc7705c86a
--- /dev/null
+++ b/sound/aoa/fabrics/Kconfig
@@ -0,0 +1,12 @@
+config SND_AOA_FABRIC_LAYOUT
+        tristate "layout-id fabric"
+        depends SND_AOA
+        select SND_AOA_SOUNDBUS
+        select SND_AOA_SOUNDBUS_I2S
+        ---help---
+        This enables the layout-id fabric for the Apple Onboard
+        Audio driver, the module holding it all together
+        based on the device-tree's layout-id property.
+        
+        If you are unsure and have a later Apple machine,
+        compile it as a module.
diff --git a/sound/aoa/fabrics/Makefile b/sound/aoa/fabrics/Makefile
new file mode 100644
index 000000000000..55fc5e7e52cf
--- /dev/null
+++ b/sound/aoa/fabrics/Makefile
@@ -0,0 +1 @@
+obj-$(CONFIG_SND_AOA_FABRIC_LAYOUT) += snd-aoa-fabric-layout.o
diff --git a/sound/aoa/fabrics/snd-aoa-fabric-layout.c b/sound/aoa/fabrics/snd-aoa-fabric-layout.c
new file mode 100644
index 000000000000..04a7238e9494
--- /dev/null
+++ b/sound/aoa/fabrics/snd-aoa-fabric-layout.c
@@ -0,0 +1,1109 @@
+/*
+ * Apple Onboard Audio driver -- layout fabric
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ *
+ *
+ * This fabric module looks for sound codecs
+ * based on the layout-id property in the device tree.
+ *
+ */
+
+#include <asm/prom.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include "../aoa.h"
+#include "../soundbus/soundbus.h"
+
+MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Layout-ID fabric for snd-aoa");
+
+#define MAX_CODECS_PER_BUS      2
+
+/* These are the connections the layout fabric
+ * knows about. It doesn't really care about the
+ * input ones, but I thought I'd separate them
+ * to give them proper names. The thing is that
+ * Apple usually will distinguish the active output
+ * by GPIOs, while the active input is set directly
+ * on the codec. Hence we here tell the codec what
+ * we think is connected. This information is hard-
+ * coded below ... */
+#define CC_SPEAKERS     (1<<0)
+#define CC_HEADPHONE    (1<<1)
+#define CC_LINEOUT      (1<<2)
+#define CC_DIGITALOUT   (1<<3)
+#define CC_LINEIN       (1<<4)
+#define CC_MICROPHONE   (1<<5)
+#define CC_DIGITALIN    (1<<6)
+/* pretty bogus but users complain...
+ * This is a flag saying that the LINEOUT
+ * should be renamed to HEADPHONE.
+ * be careful with input detection! */
+#define CC_LINEOUT_LABELLED_HEADPHONE   (1<<7)
+
+struct codec_connection {
+        /* CC_ flags from above */
+        int connected;
+        /* codec dependent bit to be set in the aoa_codec.connected field.
+         * This intentionally doesn't have any generic flags because the
+         * fabric has to know the codec anyway and all codecs might have
+         * different connectors */
+        int codec_bit;
+};
+
+struct codec_connect_info {
+        char *name;
+        struct codec_connection *connections;
+};
+
+#define LAYOUT_FLAG_COMBO_LINEOUT_SPDIF (1<<0)
+
+struct layout {
+        unsigned int layout_id;
+        struct codec_connect_info codecs[MAX_CODECS_PER_BUS];
+        int flags;
+        
+        /* if busname is not assigned, we use 'Master' below,
+         * so that our layout table doesn't need to be filled
+         * too much.
+         * We only assign these two if we expect to find more
+         * than one soundbus, i.e. on those machines with
+         * multiple layout-ids */
+        char *busname;
+        int pcmid;
+};
+
+MODULE_ALIAS("sound-layout-41");
+MODULE_ALIAS("sound-layout-45");
+MODULE_ALIAS("sound-layout-51");
+MODULE_ALIAS("sound-layout-58");
+MODULE_ALIAS("sound-layout-60");
+MODULE_ALIAS("sound-layout-61");
+MODULE_ALIAS("sound-layout-64");
+MODULE_ALIAS("sound-layout-65");
+MODULE_ALIAS("sound-layout-68");
+MODULE_ALIAS("sound-layout-69");
+MODULE_ALIAS("sound-layout-70");
+MODULE_ALIAS("sound-layout-72");
+MODULE_ALIAS("sound-layout-80");
+MODULE_ALIAS("sound-layout-82");
+MODULE_ALIAS("sound-layout-84");
+MODULE_ALIAS("sound-layout-86");
+MODULE_ALIAS("sound-layout-92");
+
+/* onyx with all but microphone connected */
+static struct codec_connection onyx_connections_nomic[] = {
+        {
+                .connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT,
+                .codec_bit = 0,
+        },
+        {
+                .connected = CC_DIGITALOUT,
+                .codec_bit = 1,
+        },
+        {
+                .connected = CC_LINEIN,
+                .codec_bit = 2,
+        },
+        {} /* terminate array by .connected == 0 */
+};
+
+/* onyx on machines without headphone */
+static struct codec_connection onyx_connections_noheadphones[] = {
+        {
+                .connected = CC_SPEAKERS | CC_LINEOUT |
+                             CC_LINEOUT_LABELLED_HEADPHONE,
+                .codec_bit = 0,
+        },
+        {
+                .connected = CC_DIGITALOUT,
+                .codec_bit = 1,
+        },
+        /* FIXME: are these correct? probably not for all the machines
+         * below ... If not this will need separating. */
+        {
+                .connected = CC_LINEIN,
+                .codec_bit = 2,
+        },
+        {
+                .connected = CC_MICROPHONE,
+                .codec_bit = 3,
+        },
+        {} /* terminate array by .connected == 0 */
+};
+
+/* onyx on machines with real line-out */
+static struct codec_connection onyx_connections_reallineout[] = {
+        {
+                .connected = CC_SPEAKERS | CC_LINEOUT | CC_HEADPHONE,
+                .codec_bit = 0,
+        },
+        {
+                .connected = CC_DIGITALOUT,
+                .codec_bit = 1,
+        },
+        {
+                .connected = CC_LINEIN,
+                .codec_bit = 2,
+        },
+        {} /* terminate array by .connected == 0 */
+};
+
+/* tas on machines without line out */
+static struct codec_connection tas_connections_nolineout[] = {
+        {
+                .connected = CC_SPEAKERS | CC_HEADPHONE,
+                .codec_bit = 0,
+        },
+        {
+                .connected = CC_LINEIN,
+                .codec_bit = 2,
+        },
+        {
+                .connected = CC_MICROPHONE,
+                .codec_bit = 3,
+        },
+        {} /* terminate array by .connected == 0 */
+};
+
+/* tas on machines with neither line out nor line in */
+static struct codec_connection tas_connections_noline[] = {
+        {
+                .connected = CC_SPEAKERS | CC_HEADPHONE,
+                .codec_bit = 0,
+        },
+        {
+                .connected = CC_MICROPHONE,
+                .codec_bit = 3,
+        },
+        {} /* terminate array by .connected == 0 */
+};
+
+/* tas on machines without microphone */
+static struct codec_connection tas_connections_nomic[] = {
+        {
+                .connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT,
+                .codec_bit = 0,
+        },
+        {
+                .connected = CC_LINEIN,
+                .codec_bit = 2,
+        },
+        {} /* terminate array by .connected == 0 */
+};
+
+/* tas on machines with everything connected */
+static struct codec_connection tas_connections_all[] = {
+        {
+                .connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT,
+                .codec_bit = 0,
+        },
+        {
+                .connected = CC_LINEIN,
+                .codec_bit = 2,
+        },
+        {
+                .connected = CC_MICROPHONE,
+                .codec_bit = 3,
+        },
+        {} /* terminate array by .connected == 0 */
+};
+
+static struct codec_connection toonie_connections[] = {
+        {
+                .connected = CC_SPEAKERS | CC_HEADPHONE,
+                .codec_bit = 0,
+        },
+        {} /* terminate array by .connected == 0 */
+};
+
+static struct codec_connection topaz_input[] = {
+        {
+                .connected = CC_DIGITALIN,
+                .codec_bit = 0,
+        },
+        {} /* terminate array by .connected == 0 */
+};
+
+static struct codec_connection topaz_output[] = {
+        {
+                .connected = CC_DIGITALOUT,
+                .codec_bit = 1,
+        },
+        {} /* terminate array by .connected == 0 */
+};
+
+static struct codec_connection topaz_inout[] = {
+        {
+                .connected = CC_DIGITALIN,
+                .codec_bit = 0,
+        },
+        {
+                .connected = CC_DIGITALOUT,
+                .codec_bit = 1,
+        },
+        {} /* terminate array by .connected == 0 */
+};
+
+static struct layout layouts[] = {
+        /* last PowerBooks (15" Oct 2005) */
+        { .layout_id = 82,
+          .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_noheadphones,
+          },
+          .codecs[1] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+        },
+        /* PowerMac9,1 */
+        { .layout_id = 60,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_reallineout,
+          },
+        },
+        /* PowerMac9,1 */
+        { .layout_id = 61,
+          .codecs[0] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+        },
+        /* PowerBook5,7 */
+        { .layout_id = 64,
+          .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_noheadphones,
+          },
+        },
+        /* PowerBook5,7 */
+        { .layout_id = 65,
+          .codecs[0] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+        },
+        /* PowerBook5,9 [17" Oct 2005] */
+        { .layout_id = 84,
+          .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_noheadphones,
+          },
+          .codecs[1] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+        },
+        /* PowerMac8,1 */
+        { .layout_id = 45,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_noheadphones,
+          },
+          .codecs[1] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+        },
+        /* Quad PowerMac (analog in, analog/digital out) */
+        { .layout_id = 68,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_nomic,
+          },
+        },
+        /* Quad PowerMac (digital in) */
+        { .layout_id = 69,
+          .codecs[0] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+          .busname = "digital in", .pcmid = 1 },
+        /* Early 2005 PowerBook (PowerBook 5,6) */
+        { .layout_id = 70,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_nolineout,
+          },
+        },
+        /* PowerBook 5,4 */
+        { .layout_id = 51,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_nolineout,
+          },
+        },
+        /* PowerBook6,7 */
+        { .layout_id = 80,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_noline,
+          },
+        },
+        /* PowerBook6,8 */
+        { .layout_id = 72,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_nolineout,
+          },
+        },
+        /* PowerMac8,2 */
+        { .layout_id = 86,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_nomic,
+          },
+          .codecs[1] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+        },
+        /* PowerBook6,7 */
+        { .layout_id = 92,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_nolineout,
+          },
+        },
+        /* PowerMac10,1 (Mac Mini) */
+        { .layout_id = 58,
+          .codecs[0] = {
+                .name = "toonie",
+                .connections = toonie_connections,
+          },
+        },
+        /* unknown, untested, but this comes from Apple */
+        { .layout_id = 41,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_all,
+          },
+        },
+        { .layout_id = 36,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_nomic,
+          },
+          .codecs[1] = {
+                .name = "topaz",
+                .connections = topaz_inout,
+          },
+        },
+        { .layout_id = 47,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_noheadphones,
+          },
+        },
+        { .layout_id = 48,
+          .codecs[0] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+        },
+        { .layout_id = 49,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_nomic,
+          },
+        },
+        { .layout_id = 50,
+          .codecs[0] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+        },
+        { .layout_id = 56,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_noheadphones,
+          },
+        },
+        { .layout_id = 57,
+          .codecs[0] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+        },
+        { .layout_id = 62,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_noheadphones,
+          },
+          .codecs[1] = {
+                .name = "topaz",
+                .connections = topaz_output,
+          },
+        },
+        { .layout_id = 66,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_noheadphones,
+          },
+        },
+        { .layout_id = 67,
+          .codecs[0] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+        },
+        { .layout_id = 76,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_nomic,
+          },
+          .codecs[1] = {
+                .name = "topaz",
+                .connections = topaz_inout,
+          },
+        },
+        { .layout_id = 90,
+          .codecs[0] = {
+                .name = "tas",
+                .connections = tas_connections_noline,
+          },
+        },
+        { .layout_id = 94,
+          .codecs[0] = {
+                .name = "onyx",
+                /* but it has an external mic?? how to select? */
+                .connections = onyx_connections_noheadphones,
+          },
+        },
+        { .layout_id = 96,
+          .codecs[0] = {
+                .name = "onyx",
+                .connections = onyx_connections_noheadphones,
+          },
+        },
+        { .layout_id = 98,
+          .codecs[0] = {
+                .name = "toonie",
+                .connections = toonie_connections,
+          },
+        },
+        { .layout_id = 100,
+          .codecs[0] = {
+                .name = "topaz",
+                .connections = topaz_input,
+          },
+          .codecs[1] = {
+                .name = "onyx",
+                .connections = onyx_connections_noheadphones,
+          },
+        },
+        {}
+};
+
+static struct layout *find_layout_by_id(unsigned int id)
+{
+        struct layout *l;
+
+        l = layouts;
+        while (l->layout_id) {
+                if (l->layout_id == id)
+                        return l;
+                l++;
+        }
+        return NULL;
+}
+
+static void use_layout(struct layout *l)
+{
+        int i;
+
+        for (i=0; i<MAX_CODECS_PER_BUS; i++) {
+                if (l->codecs[i].name) {
+                        request_module("snd-aoa-codec-%s", l->codecs[i].name);
+                }
+        }
+        /* now we wait for the codecs to call us back */
+}
+
+struct layout_dev;
+
+struct layout_dev_ptr {
+        struct layout_dev *ptr;
+};
+
+struct layout_dev {
+        struct list_head list;
+        struct soundbus_dev *sdev;
+        struct device_node *sound;
+        struct aoa_codec *codecs[MAX_CODECS_PER_BUS];
+        struct layout *layout;
+        struct gpio_runtime gpio;
+
+        /* we need these for headphone/lineout detection */
+        struct snd_kcontrol *headphone_ctrl;
+        struct snd_kcontrol *lineout_ctrl;
+        struct snd_kcontrol *speaker_ctrl;
+        struct snd_kcontrol *headphone_detected_ctrl;
+        struct snd_kcontrol *lineout_detected_ctrl;
+
+        struct layout_dev_ptr selfptr_headphone;
+        struct layout_dev_ptr selfptr_lineout;
+
+        u32 have_lineout_detect:1,
+            have_headphone_detect:1,
+            switch_on_headphone:1,
+            switch_on_lineout:1;
+};
+
+static LIST_HEAD(layouts_list);
+static int layouts_list_items;
+/* this can go away but only if we allow multiple cards,
+ * make the fabric handle all the card stuff, etc... */
+static struct layout_dev *layout_device;
+
+static int control_info(struct snd_kcontrol *kcontrol,
+                        struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
+        return 0;
+}
+
+#define AMP_CONTROL(n, description)                                     \
+static int n##_control_get(struct snd_kcontrol *kcontrol,               \
+                           struct snd_ctl_elem_value *ucontrol)         \
+{                                                                       \
+        struct gpio_runtime *gpio = snd_kcontrol_chip(kcontrol);        \
+        if (gpio->methods && gpio->methods->get_##n)                    \
+                ucontrol->value.integer.value[0] =                      \
+                        gpio->methods->get_##n(gpio);                   \
+        return 0;                                                       \
+}                                                                       \
+static int n##_control_put(struct snd_kcontrol *kcontrol,               \
+                           struct snd_ctl_elem_value *ucontrol)         \
+{                                                                       \
+        struct gpio_runtime *gpio = snd_kcontrol_chip(kcontrol);        \
+        if (gpio->methods && gpio->methods->get_##n)                    \
+                gpio->methods->set_##n(gpio,                            \
+                        ucontrol->value.integer.value[0]);              \
+        return 1;                                                       \
+}                                                                       \
+static struct snd_kcontrol_new n##_ctl = {                              \
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,                            \
+        .name = description,                                            \
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,                      \
+        .info = control_info,                                           \
+        .get = n##_control_get,                                         \
+        .put = n##_control_put,                                         \
+}
+
+AMP_CONTROL(headphone, "Headphone Switch");
+AMP_CONTROL(speakers, "Speakers Switch");
+AMP_CONTROL(lineout, "Line-Out Switch");
+
+static int detect_choice_get(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct layout_dev *ldev = snd_kcontrol_chip(kcontrol);
+
+        switch (kcontrol->private_value) {
+        case 0:
+                ucontrol->value.integer.value[0] = ldev->switch_on_headphone;
+                break;
+        case 1:
+                ucontrol->value.integer.value[0] = ldev->switch_on_lineout;
+                break;
+        default:
+                return -ENODEV;
+        }
+        return 0;
+}
+
+static int detect_choice_put(struct snd_kcontrol *kcontrol,
+                             struct snd_ctl_elem_value *ucontrol)
+{
+        struct layout_dev *ldev = snd_kcontrol_chip(kcontrol);
+
+        switch (kcontrol->private_value) {
+        case 0:
+                ldev->switch_on_headphone = !!ucontrol->value.integer.value[0];
+                break;
+        case 1:
+                ldev->switch_on_lineout = !!ucontrol->value.integer.value[0];
+                break;
+        default:
+                return -ENODEV;
+        }
+        return 1;
+}
+
+static struct snd_kcontrol_new headphone_detect_choice = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Headphone Detect Autoswitch",
+        .info = control_info,
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .get = detect_choice_get,
+        .put = detect_choice_put,
+        .private_value = 0,
+};
+
+static struct snd_kcontrol_new lineout_detect_choice = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Line-Out Detect Autoswitch",
+        .info = control_info,
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .get = detect_choice_get,
+        .put = detect_choice_put,
+        .private_value = 1,
+};
+
+static int detected_get(struct snd_kcontrol *kcontrol,
+                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct layout_dev *ldev = snd_kcontrol_chip(kcontrol);
+        int v;
+
+        switch (kcontrol->private_value) {
+        case 0:
+                v = ldev->gpio.methods->get_detect(&ldev->gpio,
+                                                   AOA_NOTIFY_HEADPHONE);
+                break;
+        case 1:
+                v = ldev->gpio.methods->get_detect(&ldev->gpio,
+                                                   AOA_NOTIFY_LINE_OUT);
+                break;
+        default:
+                return -ENODEV;
+        }
+        ucontrol->value.integer.value[0] = v;
+        return 0;
+}
+
+static struct snd_kcontrol_new headphone_detected = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Headphone Detected",
+        .info = control_info,
+        .access = SNDRV_CTL_ELEM_ACCESS_READ,
+        .get = detected_get,
+        .private_value = 0,
+};
+
+static struct snd_kcontrol_new lineout_detected = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Line-Out Detected",
+        .info = control_info,
+        .access = SNDRV_CTL_ELEM_ACCESS_READ,
+        .get = detected_get,
+        .private_value = 1,
+};
+
+static int check_codec(struct aoa_codec *codec,
+                       struct layout_dev *ldev,
+                       struct codec_connect_info *cci)
+{
+        u32 *ref;
+        char propname[32];
+        struct codec_connection *cc;
+
+        /* if the codec has a 'codec' node, we require a reference */
+        if (codec->node && (strcmp(codec->node->name, "codec") == 0)) {
+                snprintf(propname, sizeof(propname),
+                         "platform-%s-codec-ref", codec->name);
+                ref = (u32*)get_property(ldev->sound, propname, NULL);
+                if (!ref) {
+                        printk(KERN_INFO "snd-aoa-fabric-layout: "
+                                "required property %s not present\n", propname);
+                        return -ENODEV;
+                }
+                if (*ref != codec->node->linux_phandle) {
+                        printk(KERN_INFO "snd-aoa-fabric-layout: "
+                                "%s doesn't match!\n", propname);
+                        return -ENODEV;
+                }
+        } else {
+                if (layouts_list_items != 1) {
+                        printk(KERN_INFO "snd-aoa-fabric-layout: "
+                                "more than one soundbus, but no references.\n");
+                        return -ENODEV;
+                }
+        }
+        codec->soundbus_dev = ldev->sdev;
+        codec->gpio = &ldev->gpio;
+
+        cc = cci->connections;
+        if (!cc)
+                return -EINVAL;
+
+        printk(KERN_INFO "snd-aoa-fabric-layout: can use this codec\n");
+
+        codec->connected = 0;
+        codec->fabric_data = cc;
+
+        while (cc->connected) {
+                codec->connected |= 1<<cc->codec_bit;
+                cc++;
+        }
+
+        return 0;
+}
+
+static int layout_found_codec(struct aoa_codec *codec)
+{
+        struct layout_dev *ldev;
+        int i;
+
+        list_for_each_entry(ldev, &layouts_list, list) {
+                for (i=0; i<MAX_CODECS_PER_BUS; i++) {
+                        if (!ldev->layout->codecs[i].name)
+                                continue;
+                        if (strcmp(ldev->layout->codecs[i].name, codec->name) == 0) {
+                                if (check_codec(codec,
+                                                ldev,
+                                                &ldev->layout->codecs[i]) == 0)
+                                        return 0;
+                        }
+                }
+        }
+        return -ENODEV;
+}
+
+static void layout_remove_codec(struct aoa_codec *codec)
+{
+        int i;
+        /* here remove the codec from the layout dev's
+         * codec reference */
+
+        codec->soundbus_dev = NULL;
+        codec->gpio = NULL;
+        for (i=0; i<MAX_CODECS_PER_BUS; i++) {
+        }
+}
+
+static void layout_notify(void *data)
+{
+        struct layout_dev_ptr *dptr = data;
+        struct layout_dev *ldev;
+        int v, update;
+        struct snd_kcontrol *detected, *c;
+        struct snd_card *card = aoa_get_card();
+
+        ldev = dptr->ptr;
+        if (data == &ldev->selfptr_headphone) {
+                v = ldev->gpio.methods->get_detect(&ldev->gpio, AOA_NOTIFY_HEADPHONE);
+                detected = ldev->headphone_detected_ctrl;
+                update = ldev->switch_on_headphone;
+                if (update) {
+                        ldev->gpio.methods->set_speakers(&ldev->gpio, !v);
+                        ldev->gpio.methods->set_headphone(&ldev->gpio, v);
+                        ldev->gpio.methods->set_lineout(&ldev->gpio, 0);
+                }
+        } else if (data == &ldev->selfptr_lineout) {
+                v = ldev->gpio.methods->get_detect(&ldev->gpio, AOA_NOTIFY_LINE_OUT);
+                detected = ldev->lineout_detected_ctrl;
+                update = ldev->switch_on_lineout;
+                if (update) {
+                        ldev->gpio.methods->set_speakers(&ldev->gpio, !v);
+                        ldev->gpio.methods->set_headphone(&ldev->gpio, 0);
+                        ldev->gpio.methods->set_lineout(&ldev->gpio, v);
+                }
+        } else
+                return;
+
+        if (detected)
+                snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &detected->id);
+        if (update) {
+                c = ldev->headphone_ctrl;
+                if (c)
+                        snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id);
+                c = ldev->speaker_ctrl;
+                if (c)
+                        snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id);
+                c = ldev->lineout_ctrl;
+                if (c)
+                        snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id);
+        }
+}
+
+static void layout_attached_codec(struct aoa_codec *codec)
+{
+        struct codec_connection *cc;
+        struct snd_kcontrol *ctl;
+        int headphones, lineout;
+        struct layout_dev *ldev = layout_device;
+
+        /* need to add this codec to our codec array! */
+
+        cc = codec->fabric_data;
+
+        headphones = codec->gpio->methods->get_detect(codec->gpio,
+                                                      AOA_NOTIFY_HEADPHONE);
+        lineout = codec->gpio->methods->get_detect(codec->gpio,
+                                                   AOA_NOTIFY_LINE_OUT);
+
+        while (cc->connected) {
+                if (cc->connected & CC_SPEAKERS) {
+                        if (headphones <= 0 && lineout <= 0)
+                                ldev->gpio.methods->set_speakers(codec->gpio, 1);
+                        ctl = snd_ctl_new1(&speakers_ctl, codec->gpio);
+                        ldev->speaker_ctrl = ctl;
+                        aoa_snd_ctl_add(ctl);
+                }
+                if (cc->connected & CC_HEADPHONE) {
+                        if (headphones == 1)
+                                ldev->gpio.methods->set_headphone(codec->gpio, 1);
+                        ctl = snd_ctl_new1(&headphone_ctl, codec->gpio);
+                        ldev->headphone_ctrl = ctl;
+                        aoa_snd_ctl_add(ctl);
+                        ldev->have_headphone_detect =
+                                !ldev->gpio.methods
+                                        ->set_notify(&ldev->gpio,
+                                                     AOA_NOTIFY_HEADPHONE,
+                                                     layout_notify,
+                                                     &ldev->selfptr_headphone);
+                        if (ldev->have_headphone_detect) {
+                                ctl = snd_ctl_new1(&headphone_detect_choice,
+                                                   ldev);
+                                aoa_snd_ctl_add(ctl);
+                                ctl = snd_ctl_new1(&headphone_detected,
+                                                   ldev);
+                                ldev->headphone_detected_ctrl = ctl;
+                                aoa_snd_ctl_add(ctl);
+                        }
+                }
+                if (cc->connected & CC_LINEOUT) {
+                        if (lineout == 1)
+                                ldev->gpio.methods->set_lineout(codec->gpio, 1);
+                        ctl = snd_ctl_new1(&lineout_ctl, codec->gpio);
+                        if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE)
+                                strlcpy(ctl->id.name,
+                                        "Headphone Switch", sizeof(ctl->id.name));
+                        ldev->lineout_ctrl = ctl;
+                        aoa_snd_ctl_add(ctl);
+                        ldev->have_lineout_detect =
+                                !ldev->gpio.methods
+                                        ->set_notify(&ldev->gpio,
+                                                     AOA_NOTIFY_LINE_OUT,
+                                                     layout_notify,
+                                                     &ldev->selfptr_lineout);
+                        if (ldev->have_lineout_detect) {
+                                ctl = snd_ctl_new1(&lineout_detect_choice,
+                                                   ldev);
+                                if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE)
+                                        strlcpy(ctl->id.name,
+                                                "Headphone Detect Autoswitch",
+                                                sizeof(ctl->id.name));
+                                aoa_snd_ctl_add(ctl);
+                                ctl = snd_ctl_new1(&lineout_detected,
+                                                   ldev);
+                                if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE)
+                                        strlcpy(ctl->id.name,
+                                                "Headphone Detected",
+                                                sizeof(ctl->id.name));
+                                ldev->lineout_detected_ctrl = ctl;
+                                aoa_snd_ctl_add(ctl);
+                        }
+                }
+                cc++;
+        }
+        /* now update initial state */
+        if (ldev->have_headphone_detect)
+                layout_notify(&ldev->selfptr_headphone);
+        if (ldev->have_lineout_detect)
+                layout_notify(&ldev->selfptr_lineout);
+}
+
+static struct aoa_fabric layout_fabric = {
+        .name = "SoundByLayout",
+        .owner = THIS_MODULE,
+        .found_codec = layout_found_codec,
+        .remove_codec = layout_remove_codec,
+        .attached_codec = layout_attached_codec,
+};
+
+static int aoa_fabric_layout_probe(struct soundbus_dev *sdev)
+{
+        struct device_node *sound = NULL;
+        unsigned int *layout_id;
+        struct layout *layout;
+        struct layout_dev *ldev = NULL;
+        int err;
+
+        /* hm, currently we can only have one ... */
+        if (layout_device)
+                return -ENODEV;
+
+        /* by breaking out we keep a reference */
+        while ((sound = of_get_next_child(sdev->ofdev.node, sound))) {
+                if (sound->type && strcasecmp(sound->type, "soundchip") == 0)
+                        break;
+        }
+        if (!sound) return -ENODEV;
+
+        layout_id = (unsigned int *) get_property(sound, "layout-id", NULL);
+        if (!layout_id)
+                goto outnodev;
+        printk(KERN_INFO "snd-aoa-fabric-layout: found bus with layout %d ", *layout_id);
+
+        layout = find_layout_by_id(*layout_id);
+        if (!layout) {
+                printk("(no idea how to handle)\n");
+                goto outnodev;
+        }
+
+        ldev = kzalloc(sizeof(struct layout_dev), GFP_KERNEL);
+        if (!ldev)
+                goto outnodev;
+
+        layout_device = ldev;
+        ldev->sdev = sdev;
+        ldev->sound = sound;
+        ldev->layout = layout;
+        ldev->gpio.node = sound->parent;
+        switch (layout->layout_id) {
+        case 41: /* that unknown machine no one seems to have */
+        case 51: /* PowerBook5,4 */
+        case 58: /* Mac Mini */
+                ldev->gpio.methods = ftr_gpio_methods;
+                break;
+        default:
+                ldev->gpio.methods = pmf_gpio_methods;
+        }
+        ldev->selfptr_headphone.ptr = ldev;
+        ldev->selfptr_lineout.ptr = ldev;
+        sdev->ofdev.dev.driver_data = ldev;
+
+        printk("(using)\n");
+        list_add(&ldev->list, &layouts_list);
+        layouts_list_items++;
+
+        /* assign these before registering ourselves, so
+         * callbacks that are done during registration
+         * already have the values */
+        sdev->pcmid = ldev->layout->pcmid;
+        if (ldev->layout->busname) {
+                sdev->pcmname = ldev->layout->busname;
+        } else {
+                sdev->pcmname = "Master";
+        }
+
+        ldev->gpio.methods->init(&ldev->gpio);
+
+        err = aoa_fabric_register(&layout_fabric);
+        if (err && err != -EALREADY) {
+                printk(KERN_INFO "snd-aoa-fabric-layout: can't use,"
+                                 " another fabric is active!\n");
+                goto outlistdel;
+        }
+
+        use_layout(layout);
+        ldev->switch_on_headphone = 1;
+        ldev->switch_on_lineout = 1;
+        return 0;
+ outlistdel:
+        /* we won't be using these then... */
+        ldev->gpio.methods->exit(&ldev->gpio);
+        /* reset if we didn't use it */
+        sdev->pcmname = NULL;
+        sdev->pcmid = -1;
+        list_del(&ldev->list);
+        layouts_list_items--;
+ outnodev:
+        if (sound) of_node_put(sound);
+        layout_device = NULL;
+        if (ldev) kfree(ldev);
+        return -ENODEV;
+}
+
+static int aoa_fabric_layout_remove(struct soundbus_dev *sdev)
+{
+        struct layout_dev *ldev = sdev->ofdev.dev.driver_data;
+        int i;
+
+        for (i=0; i<MAX_CODECS_PER_BUS; i++) {
+                if (ldev->codecs[i]) {
+                        aoa_fabric_unlink_codec(ldev->codecs[i]);
+                }
+                ldev->codecs[i] = NULL;
+        }
+        list_del(&ldev->list);
+        layouts_list_items--;
+        of_node_put(ldev->sound);
+
+        ldev->gpio.methods->set_notify(&ldev->gpio,
+                                       AOA_NOTIFY_HEADPHONE,
+                                       NULL,
+                                       NULL);
+        ldev->gpio.methods->set_notify(&ldev->gpio,
+                                       AOA_NOTIFY_LINE_OUT,
+                                       NULL,
+                                       NULL);
+
+        ldev->gpio.methods->exit(&ldev->gpio);
+        layout_device = NULL;
+        kfree(ldev);
+        sdev->pcmid = -1;
+        sdev->pcmname = NULL;
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int aoa_fabric_layout_suspend(struct soundbus_dev *sdev, pm_message_t state)
+{
+        struct layout_dev *ldev = sdev->ofdev.dev.driver_data;
+
+        printk("aoa_fabric_layout_suspend()\n");
+
+        if (ldev->gpio.methods && ldev->gpio.methods->all_amps_off)
+                ldev->gpio.methods->all_amps_off(&ldev->gpio);
+
+        return 0;
+}
+
+static int aoa_fabric_layout_resume(struct soundbus_dev *sdev)
+{
+        struct layout_dev *ldev = sdev->ofdev.dev.driver_data;
+
+        printk("aoa_fabric_layout_resume()\n");
+
+        if (ldev->gpio.methods && ldev->gpio.methods->all_amps_off)
+                ldev->gpio.methods->all_amps_restore(&ldev->gpio);
+
+        return 0;
+}
+#endif
+
+static struct soundbus_driver aoa_soundbus_driver = {
+        .name = "snd_aoa_soundbus_drv",
+        .owner = THIS_MODULE,
+        .probe = aoa_fabric_layout_probe,
+        .remove = aoa_fabric_layout_remove,
+#ifdef CONFIG_PM
+        .suspend = aoa_fabric_layout_suspend,
+        .resume = aoa_fabric_layout_resume,
+#endif
+};
+
+static int __init aoa_fabric_layout_init(void)
+{
+        int err;
+
+        err = soundbus_register_driver(&aoa_soundbus_driver);
+        if (err)
+                return err;
+        return 0;
+}
+
+static void __exit aoa_fabric_layout_exit(void)
+{
+        soundbus_unregister_driver(&aoa_soundbus_driver);
+        aoa_fabric_unregister(&layout_fabric);
+}
+
+module_init(aoa_fabric_layout_init);
+module_exit(aoa_fabric_layout_exit);
diff --git a/sound/aoa/soundbus/Kconfig b/sound/aoa/soundbus/Kconfig
new file mode 100644
index 000000000000..d532d27a9f54
--- /dev/null
+++ b/sound/aoa/soundbus/Kconfig
@@ -0,0 +1,14 @@
+config SND_AOA_SOUNDBUS
+        tristate "Apple Soundbus support"
+        depends on SOUND && SND_PCM && EXPERIMENTAL
+        ---help---
+        This option enables the generic driver for the soundbus
+        support on Apple machines.
+        
+        It is required for the sound bus implementations.
+
+config SND_AOA_SOUNDBUS_I2S
+        tristate "I2S bus support"
+        depends on SND_AOA_SOUNDBUS && PCI
+        ---help---
+        This option enables support for Apple I2S busses.
diff --git a/sound/aoa/soundbus/Makefile b/sound/aoa/soundbus/Makefile
new file mode 100644
index 000000000000..0e61f5aa06b5
--- /dev/null
+++ b/sound/aoa/soundbus/Makefile
@@ -0,0 +1,3 @@
+obj-$(CONFIG_SND_AOA_SOUNDBUS) += snd-aoa-soundbus.o
+snd-aoa-soundbus-objs := core.o sysfs.o
+obj-$(CONFIG_SND_AOA_SOUNDBUS_I2S) += i2sbus/
diff --git a/sound/aoa/soundbus/core.c b/sound/aoa/soundbus/core.c
new file mode 100644
index 000000000000..abe84a76c835
--- /dev/null
+++ b/sound/aoa/soundbus/core.c
@@ -0,0 +1,250 @@
+/*
+ * soundbus
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+
+#include <linux/module.h>
+#include "soundbus.h"
+
+MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Apple Soundbus");
+
+struct soundbus_dev *soundbus_dev_get(struct soundbus_dev *dev)
+{
+        struct device *tmp;
+
+        if (!dev)
+                return NULL;
+        tmp = get_device(&dev->ofdev.dev);
+        if (tmp)
+                return to_soundbus_device(tmp);
+        else
+                return NULL;
+}
+EXPORT_SYMBOL_GPL(soundbus_dev_get);
+
+void soundbus_dev_put(struct soundbus_dev *dev)
+{
+        if (dev)
+                put_device(&dev->ofdev.dev);
+}
+EXPORT_SYMBOL_GPL(soundbus_dev_put);
+
+static int soundbus_probe(struct device *dev)
+{
+        int error = -ENODEV;
+        struct soundbus_driver *drv;
+        struct soundbus_dev *soundbus_dev;
+
+        drv = to_soundbus_driver(dev->driver);
+        soundbus_dev = to_soundbus_device(dev);
+
+        if (!drv->probe)
+                return error;
+
+        soundbus_dev_get(soundbus_dev);
+
+        error = drv->probe(soundbus_dev);
+        if (error)
+                soundbus_dev_put(soundbus_dev);
+
+        return error;
+}
+
+
+static int soundbus_uevent(struct device *dev, char **envp, int num_envp,
+                           char *buffer, int buffer_size)
+{
+        struct soundbus_dev * soundbus_dev;
+        struct of_device * of;
+        char *scratch, *compat, *compat2;
+        int i = 0;
+        int length, cplen, cplen2, seen = 0;
+
+        if (!dev)
+                return -ENODEV;
+
+        soundbus_dev = to_soundbus_device(dev);
+        if (!soundbus_dev)
+                return -ENODEV;
+
+        of = &soundbus_dev->ofdev;
+
+        /* stuff we want to pass to /sbin/hotplug */
+        envp[i++] = scratch = buffer;
+        length = scnprintf (scratch, buffer_size, "OF_NAME=%s", of->node->name);
+        ++length;
+        buffer_size -= length;
+        if ((buffer_size <= 0) || (i >= num_envp))
+                return -ENOMEM;
+        scratch += length;
+
+        envp[i++] = scratch;
+        length = scnprintf (scratch, buffer_size, "OF_TYPE=%s", of->node->type);
+        ++length;
+        buffer_size -= length;
+        if ((buffer_size <= 0) || (i >= num_envp))
+                return -ENOMEM;
+        scratch += length;
+
+        /* Since the compatible field can contain pretty much anything
+         * it's not really legal to split it out with commas. We split it
+         * up using a number of environment variables instead. */
+
+        compat = (char *) get_property(of->node, "compatible", &cplen);
+        compat2 = compat;
+        cplen2= cplen;
+        while (compat && cplen > 0) {
+                envp[i++] = scratch;
+                length = scnprintf (scratch, buffer_size,
+                                     "OF_COMPATIBLE_%d=%s", seen, compat);
+                ++length;
+                buffer_size -= length;
+                if ((buffer_size <= 0) || (i >= num_envp))
+                        return -ENOMEM;
+                scratch += length;
+                length = strlen (compat) + 1;
+                compat += length;
+                cplen -= length;
+                seen++;
+        }
+
+        envp[i++] = scratch;
+        length = scnprintf (scratch, buffer_size, "OF_COMPATIBLE_N=%d", seen);
+        ++length;
+        buffer_size -= length;
+        if ((buffer_size <= 0) || (i >= num_envp))
+                return -ENOMEM;
+        scratch += length;
+
+        envp[i++] = scratch;
+        length = scnprintf (scratch, buffer_size, "MODALIAS=%s",
+                        soundbus_dev->modalias);
+
+        buffer_size -= length;
+        if ((buffer_size <= 0) || (i >= num_envp))
+                return -ENOMEM;
+
+        envp[i] = NULL;
+
+        return 0;
+}
+
+static int soundbus_device_remove(struct device *dev)
+{
+        struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
+        struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
+
+        if (dev->driver && drv->remove)
+                drv->remove(soundbus_dev);
+        soundbus_dev_put(soundbus_dev);
+
+        return 0;
+}
+
+static void soundbus_device_shutdown(struct device *dev)
+{
+        struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
+        struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
+
+        if (dev->driver && drv->shutdown)
+                drv->shutdown(soundbus_dev);
+}
+
+#ifdef CONFIG_PM
+
+static int soundbus_device_suspend(struct device *dev, pm_message_t state)
+{
+        struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
+        struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
+
+        if (dev->driver && drv->suspend)
+                return drv->suspend(soundbus_dev, state);
+        return 0;
+}
+
+static int soundbus_device_resume(struct device * dev)
+{
+        struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
+        struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
+
+        if (dev->driver && drv->resume)
+                return drv->resume(soundbus_dev);
+        return 0;
+}
+
+#endif /* CONFIG_PM */
+
+extern struct device_attribute soundbus_dev_attrs[];
+
+static struct bus_type soundbus_bus_type = {
+        .name           = "aoa-soundbus",
+        .probe          = soundbus_probe,
+        .uevent         = soundbus_uevent,
+        .remove         = soundbus_device_remove,
+        .shutdown       = soundbus_device_shutdown,
+#ifdef CONFIG_PM
+        .suspend        = soundbus_device_suspend,
+        .resume         = soundbus_device_resume,
+#endif
+        .dev_attrs      = soundbus_dev_attrs,
+};
+
+static int __init soundbus_init(void)
+{
+        return bus_register(&soundbus_bus_type);
+}
+
+static void __exit soundbus_exit(void)
+{
+        bus_unregister(&soundbus_bus_type);
+}
+
+int soundbus_add_one(struct soundbus_dev *dev)
+{
+        static int devcount;
+
+        /* sanity checks */
+        if (!dev->attach_codec ||
+            !dev->ofdev.node ||
+            dev->pcmname ||
+            dev->pcmid != -1) {
+                printk(KERN_ERR "soundbus: adding device failed sanity check!\n");
+                return -EINVAL;
+        }
+
+        snprintf(dev->ofdev.dev.bus_id, BUS_ID_SIZE, "soundbus:%x", ++devcount);
+        dev->ofdev.dev.bus = &soundbus_bus_type;
+        return of_device_register(&dev->ofdev);
+}
+EXPORT_SYMBOL_GPL(soundbus_add_one);
+
+void soundbus_remove_one(struct soundbus_dev *dev)
+{
+        of_device_unregister(&dev->ofdev);
+}
+EXPORT_SYMBOL_GPL(soundbus_remove_one);
+
+int soundbus_register_driver(struct soundbus_driver *drv)
+{
+        /* initialize common driver fields */
+        drv->driver.name = drv->name;
+        drv->driver.bus = &soundbus_bus_type;
+
+        /* register with core */
+        return driver_register(&drv->driver);
+}
+EXPORT_SYMBOL_GPL(soundbus_register_driver);
+
+void soundbus_unregister_driver(struct soundbus_driver *drv)
+{
+        driver_unregister(&drv->driver);
+}
+EXPORT_SYMBOL_GPL(soundbus_unregister_driver);
+
+module_init(soundbus_init);
+module_exit(soundbus_exit);
diff --git a/sound/aoa/soundbus/i2sbus/Makefile b/sound/aoa/soundbus/i2sbus/Makefile
new file mode 100644
index 000000000000..e57a5cf65655
--- /dev/null
+++ b/sound/aoa/soundbus/i2sbus/Makefile
@@ -0,0 +1,2 @@
+obj-$(CONFIG_SND_AOA_SOUNDBUS_I2S) += snd-aoa-i2sbus.o
+snd-aoa-i2sbus-objs := i2sbus-core.o i2sbus-pcm.o i2sbus-control.o
diff --git a/sound/aoa/soundbus/i2sbus/i2sbus-control.c b/sound/aoa/soundbus/i2sbus/i2sbus-control.c
new file mode 100644
index 000000000000..f50407952d3c
--- /dev/null
+++ b/sound/aoa/soundbus/i2sbus/i2sbus-control.c
@@ -0,0 +1,192 @@
+/*
+ * i2sbus driver -- bus control routines
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+
+#include <asm/io.h>
+#include <linux/delay.h>
+#include <asm/prom.h>
+#include <asm/macio.h>
+#include <asm/pmac_feature.h>
+#include <asm/pmac_pfunc.h>
+#include "i2sbus.h"
+
+int i2sbus_control_init(struct macio_dev* dev, struct i2sbus_control **c)
+{
+        *c = kzalloc(sizeof(struct i2sbus_control), GFP_KERNEL);
+        if (!*c)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&(*c)->list);
+
+        if (of_address_to_resource(dev->ofdev.node, 0, &(*c)->rsrc))
+                goto err;
+        /* we really should be using feature calls instead of mapping
+         * these registers. It's safe for now since no one else is
+         * touching them... */
+        (*c)->controlregs = ioremap((*c)->rsrc.start,
+                                    sizeof(struct i2s_control_regs));
+        if (!(*c)->controlregs)
+                goto err;
+
+        return 0;
+ err:
+        kfree(*c);
+        *c = NULL;
+        return -ENODEV;
+}
+
+void i2sbus_control_destroy(struct i2sbus_control *c)
+{
+        iounmap(c->controlregs);
+        kfree(c);
+}
+
+/* this is serialised externally */
+int i2sbus_control_add_dev(struct i2sbus_control *c,
+                           struct i2sbus_dev *i2sdev)
+{
+        struct device_node *np;
+
+        np = i2sdev->sound.ofdev.node;
+        i2sdev->enable = pmf_find_function(np, "enable");
+        i2sdev->cell_enable = pmf_find_function(np, "cell-enable");
+        i2sdev->clock_enable = pmf_find_function(np, "clock-enable");
+        i2sdev->cell_disable = pmf_find_function(np, "cell-disable");
+        i2sdev->clock_disable = pmf_find_function(np, "clock-disable");
+
+        /* if the bus number is not 0 or 1 we absolutely need to use
+         * the platform functions -- there's nothing in Darwin that
+         * would allow seeing a system behind what the FCRs are then,
+         * and I don't want to go parsing a bunch of platform functions
+         * by hand to try finding a system... */
+        if (i2sdev->bus_number != 0 && i2sdev->bus_number != 1 &&
+            (!i2sdev->enable ||
+             !i2sdev->cell_enable || !i2sdev->clock_enable ||
+             !i2sdev->cell_disable || !i2sdev->clock_disable)) {
+                pmf_put_function(i2sdev->enable);
+                pmf_put_function(i2sdev->cell_enable);
+                pmf_put_function(i2sdev->clock_enable);
+                pmf_put_function(i2sdev->cell_disable);
+                pmf_put_function(i2sdev->clock_disable);
+                return -ENODEV;
+        }
+
+        list_add(&i2sdev->item, &c->list);
+
+        return 0;
+}
+
+void i2sbus_control_remove_dev(struct i2sbus_control *c,
+                               struct i2sbus_dev *i2sdev)
+{
+        /* this is serialised externally */
+        list_del(&i2sdev->item);
+        if (list_empty(&c->list))
+                i2sbus_control_destroy(c);
+}
+
+int i2sbus_control_enable(struct i2sbus_control *c,
+                          struct i2sbus_dev *i2sdev)
+{
+        struct pmf_args args = { .count = 0 };
+        int cc;
+
+        if (i2sdev->enable)
+                return pmf_call_one(i2sdev->enable, &args);
+
+        switch (i2sdev->bus_number) {
+        case 0:
+                cc = in_le32(&c->controlregs->cell_control);
+                out_le32(&c->controlregs->cell_control, cc | CTRL_CLOCK_INTF_0_ENABLE);
+                break;
+        case 1:
+                cc = in_le32(&c->controlregs->cell_control);
+                out_le32(&c->controlregs->cell_control, cc | CTRL_CLOCK_INTF_1_ENABLE);
+                break;
+        default:
+                return -ENODEV;
+        }
+        return 0;
+}
+
+int i2sbus_control_cell(struct i2sbus_control *c,
+                        struct i2sbus_dev *i2sdev,
+                        int enable)
+{
+        struct pmf_args args = { .count = 0 };
+        int cc;
+
+        switch (enable) {
+        case 0:
+                if (i2sdev->cell_disable)
+                        return pmf_call_one(i2sdev->cell_disable, &args);
+                break;
+        case 1:
+                if (i2sdev->cell_enable)
+                        return pmf_call_one(i2sdev->cell_enable, &args);
+                break;
+        default:
+                printk(KERN_ERR "i2sbus: INVALID CELL ENABLE VALUE\n");
+                return -ENODEV;
+        }
+        switch (i2sdev->bus_number) {
+        case 0:
+                cc = in_le32(&c->controlregs->cell_control);
+                cc &= ~CTRL_CLOCK_CELL_0_ENABLE;
+                cc |= enable * CTRL_CLOCK_CELL_0_ENABLE;
+                out_le32(&c->controlregs->cell_control, cc);
+                break;
+        case 1:
+                cc = in_le32(&c->controlregs->cell_control);
+                cc &= ~CTRL_CLOCK_CELL_1_ENABLE;
+                cc |= enable * CTRL_CLOCK_CELL_1_ENABLE;
+                out_le32(&c->controlregs->cell_control, cc);
+                break;
+        default:
+                return -ENODEV;
+        }
+        return 0;
+}
+
+int i2sbus_control_clock(struct i2sbus_control *c,
+                         struct i2sbus_dev *i2sdev,
+                         int enable)
+{
+        struct pmf_args args = { .count = 0 };
+        int cc;
+
+        switch (enable) {
+        case 0:
+                if (i2sdev->clock_disable)
+                        return pmf_call_one(i2sdev->clock_disable, &args);
+                break;
+        case 1:
+                if (i2sdev->clock_enable)
+                        return pmf_call_one(i2sdev->clock_enable, &args);
+                break;
+        default:
+                printk(KERN_ERR "i2sbus: INVALID CLOCK ENABLE VALUE\n");
+                return -ENODEV;
+        }
+        switch (i2sdev->bus_number) {
+        case 0:
+                cc = in_le32(&c->controlregs->cell_control);
+                cc &= ~CTRL_CLOCK_CLOCK_0_ENABLE;
+                cc |= enable * CTRL_CLOCK_CLOCK_0_ENABLE;
+                out_le32(&c->controlregs->cell_control, cc);
+                break;
+        case 1:
+                cc = in_le32(&c->controlregs->cell_control);
+                cc &= ~CTRL_CLOCK_CLOCK_1_ENABLE;
+                cc |= enable * CTRL_CLOCK_CLOCK_1_ENABLE;
+                out_le32(&c->controlregs->cell_control, cc);
+                break;
+        default:
+                return -ENODEV;
+        }
+        return 0;
+}
diff --git a/sound/aoa/soundbus/i2sbus/i2sbus-control.h b/sound/aoa/soundbus/i2sbus/i2sbus-control.h
new file mode 100644
index 000000000000..bb05550f730b
--- /dev/null
+++ b/sound/aoa/soundbus/i2sbus/i2sbus-control.h
@@ -0,0 +1,37 @@
+/*
+ * i2sbus driver -- bus register definitions
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+#ifndef __I2SBUS_CONTROLREGS_H
+#define __I2SBUS_CONTROLREGS_H
+
+/* i2s control registers, at least what we know about them */
+
+#define __PAD(m,n) u8 __pad##m[n]
+#define _PAD(line, n) __PAD(line, n)
+#define PAD(n) _PAD(__LINE__, (n))
+struct i2s_control_regs {
+        PAD(0x38);
+        __le32 fcr0;            /* 0x38 (unknown) */
+        __le32 cell_control;    /* 0x3c (fcr1) */
+        __le32 fcr2;            /* 0x40 (unknown) */
+        __le32 fcr3;            /* 0x44 (fcr3) */
+        __le32 clock_control;   /* 0x48 (unknown) */
+        PAD(4);
+        /* total size: 0x50 bytes */
+}  __attribute__((__packed__));
+
+#define CTRL_CLOCK_CELL_0_ENABLE        (1<<10)
+#define CTRL_CLOCK_CLOCK_0_ENABLE       (1<<12)
+#define CTRL_CLOCK_SWRESET_0            (1<<11)
+#define CTRL_CLOCK_INTF_0_ENABLE        (1<<13)
+
+#define CTRL_CLOCK_CELL_1_ENABLE        (1<<17)
+#define CTRL_CLOCK_CLOCK_1_ENABLE       (1<<18)
+#define CTRL_CLOCK_SWRESET_1            (1<<19)
+#define CTRL_CLOCK_INTF_1_ENABLE        (1<<20)
+
+#endif /* __I2SBUS_CONTROLREGS_H */
diff --git a/sound/aoa/soundbus/i2sbus/i2sbus-core.c b/sound/aoa/soundbus/i2sbus/i2sbus-core.c
new file mode 100644
index 000000000000..f268dacdaa00
--- /dev/null
+++ b/sound/aoa/soundbus/i2sbus/i2sbus-core.c
@@ -0,0 +1,387 @@
+/*
+ * i2sbus driver
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+
+#include <linux/module.h>
+#include <asm/macio.h>
+#include <asm/dbdma.h>
+#include <linux/pci.h>
+#include <linux/interrupt.h>
+#include <sound/driver.h>
+#include <sound/core.h>
+#include <linux/dma-mapping.h>
+#include "../soundbus.h"
+#include "i2sbus.h"
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
+MODULE_DESCRIPTION("Apple Soundbus: I2S support");
+/* for auto-loading, declare that we handle this weird
+ * string that macio puts into the relevant device */
+MODULE_ALIAS("of:Ni2sTi2sC");
+
+static struct of_device_id i2sbus_match[] = {
+        { .name = "i2s" },
+        { }
+};
+
+static int alloc_dbdma_descriptor_ring(struct i2sbus_dev *i2sdev,
+                                       struct dbdma_command_mem *r,
+                                       int numcmds)
+{
+        /* one more for rounding */
+        r->size = (numcmds+1) * sizeof(struct dbdma_cmd);
+        /* We use the PCI APIs for now until the generic one gets fixed
+         * enough or until we get some macio-specific versions
+         */
+        r->space = dma_alloc_coherent(
+                        &macio_get_pci_dev(i2sdev->macio)->dev,
+                        r->size,
+                        &r->bus_addr,
+                        GFP_KERNEL);
+
+        if (!r->space) return -ENOMEM;
+
+        memset(r->space, 0, r->size);
+        r->cmds = (void*)DBDMA_ALIGN(r->space);
+        r->bus_cmd_start = r->bus_addr +
+                           (dma_addr_t)((char*)r->cmds - (char*)r->space);
+
+        return 0;
+}
+
+static void free_dbdma_descriptor_ring(struct i2sbus_dev *i2sdev,
+                                       struct dbdma_command_mem *r)
+{
+        if (!r->space) return;
+        
+        dma_free_coherent(&macio_get_pci_dev(i2sdev->macio)->dev,
+                            r->size, r->space, r->bus_addr);
+}
+
+static void i2sbus_release_dev(struct device *dev)
+{
+        struct i2sbus_dev *i2sdev;
+        int i;
+
+        i2sdev = container_of(dev, struct i2sbus_dev, sound.ofdev.dev);
+
+        if (i2sdev->intfregs) iounmap(i2sdev->intfregs);
+        if (i2sdev->out.dbdma) iounmap(i2sdev->out.dbdma);
+        if (i2sdev->in.dbdma) iounmap(i2sdev->in.dbdma);
+        for (i=0;i<3;i++)
+                if (i2sdev->allocated_resource[i])
+                        release_and_free_resource(i2sdev->allocated_resource[i]);
+        free_dbdma_descriptor_ring(i2sdev, &i2sdev->out.dbdma_ring);
+        free_dbdma_descriptor_ring(i2sdev, &i2sdev->in.dbdma_ring);
+        for (i=0;i<3;i++)
+                free_irq(i2sdev->interrupts[i], i2sdev);
+        i2sbus_control_remove_dev(i2sdev->control, i2sdev);
+        mutex_destroy(&i2sdev->lock);
+        kfree(i2sdev);
+}
+
+static irqreturn_t i2sbus_bus_intr(int irq, void *devid, struct pt_regs *regs)
+{
+        struct i2sbus_dev *dev = devid;
+        u32 intreg;
+
+        spin_lock(&dev->low_lock);
+        intreg = in_le32(&dev->intfregs->intr_ctl);
+
+        /* acknowledge interrupt reasons */
+        out_le32(&dev->intfregs->intr_ctl, intreg);
+
+        spin_unlock(&dev->low_lock);
+
+        return IRQ_HANDLED;
+}
+
+static int force;
+module_param(force, int, 0444);
+MODULE_PARM_DESC(force, "Force loading i2sbus even when"
+                        " no layout-id property is present");
+
+/* FIXME: look at device node refcounting */
+static int i2sbus_add_dev(struct macio_dev *macio,
+                          struct i2sbus_control *control,
+                          struct device_node *np)
+{
+        struct i2sbus_dev *dev;
+        struct device_node *child = NULL, *sound = NULL;
+        int i;
+        static const char *rnames[] = { "i2sbus: %s (control)",
+                                        "i2sbus: %s (tx)",
+                                        "i2sbus: %s (rx)" };
+        static irqreturn_t (*ints[])(int irq, void *devid,
+                                     struct pt_regs *regs) = {
+                i2sbus_bus_intr,
+                i2sbus_tx_intr,
+                i2sbus_rx_intr
+        };
+
+        if (strlen(np->name) != 5)
+                return 0;
+        if (strncmp(np->name, "i2s-", 4))
+                return 0;
+
+        if (np->n_intrs != 3)
+                return 0;
+
+        dev = kzalloc(sizeof(struct i2sbus_dev), GFP_KERNEL);
+        if (!dev)
+                return 0;
+
+        i = 0;
+        while ((child = of_get_next_child(np, child))) {
+                if (strcmp(child->name, "sound") == 0) {
+                        i++;
+                        sound = child;
+                }
+        }
+        if (i == 1) {
+                u32 *layout_id;
+                layout_id = (u32*) get_property(sound, "layout-id", NULL);
+                if (layout_id) {
+                        snprintf(dev->sound.modalias, 32,
+                                 "sound-layout-%d", *layout_id);
+                        force = 1;
+                }
+        }
+        /* for the time being, until we can handle non-layout-id
+         * things in some fabric, refuse to attach if there is no
+         * layout-id property or we haven't been forced to attach.
+         * When there are two i2s busses and only one has a layout-id,
+         * then this depends on the order, but that isn't important
+         * either as the second one in that case is just a modem. */
+        if (!force) {
+                kfree(dev);
+                return -ENODEV;
+        }
+
+        mutex_init(&dev->lock);
+        spin_lock_init(&dev->low_lock);
+        dev->sound.ofdev.node = np;
+        dev->sound.ofdev.dma_mask = macio->ofdev.dma_mask;
+        dev->sound.ofdev.dev.dma_mask = &dev->sound.ofdev.dma_mask;
+        dev->sound.ofdev.dev.parent = &macio->ofdev.dev;
+        dev->sound.ofdev.dev.release = i2sbus_release_dev;
+        dev->sound.attach_codec = i2sbus_attach_codec;
+        dev->sound.detach_codec = i2sbus_detach_codec;
+        dev->sound.pcmid = -1;
+        dev->macio = macio;
+        dev->control = control;
+        dev->bus_number = np->name[4] - 'a';
+        INIT_LIST_HEAD(&dev->sound.codec_list);
+
+        for (i=0;i<3;i++) {
+                dev->interrupts[i] = -1;
+                snprintf(dev->rnames[i], sizeof(dev->rnames[i]), rnames[i], np->name);
+        }
+        for (i=0;i<3;i++) {
+                if (request_irq(np->intrs[i].line, ints[i], 0, dev->rnames[i], dev))
+                        goto err;
+                dev->interrupts[i] = np->intrs[i].line;
+        }
+
+        for (i=0;i<3;i++) {
+                if (of_address_to_resource(np, i, &dev->resources[i]))
+                        goto err;
+                /* if only we could use our resource dev->resources[i]...
+                 * but request_resource doesn't know about parents and
+                 * contained resources... */
+                dev->allocated_resource[i] = 
+                        request_mem_region(dev->resources[i].start,
+                                           dev->resources[i].end -
+                                           dev->resources[i].start + 1,
+                                           dev->rnames[i]);
+                if (!dev->allocated_resource[i]) {
+                        printk(KERN_ERR "i2sbus: failed to claim resource %d!\n", i);
+                        goto err;
+                }
+        }
+        /* should do sanity checking here about length of them */
+        dev->intfregs = ioremap(dev->resources[0].start,
+                                dev->resources[0].end-dev->resources[0].start+1);
+        dev->out.dbdma = ioremap(dev->resources[1].start,
+                                 dev->resources[1].end-dev->resources[1].start+1);
+        dev->in.dbdma = ioremap(dev->resources[2].start,
+                                dev->resources[2].end-dev->resources[2].start+1);
+        if (!dev->intfregs || !dev->out.dbdma || !dev->in.dbdma)
+                goto err;
+
+        if (alloc_dbdma_descriptor_ring(dev, &dev->out.dbdma_ring,
+                                        MAX_DBDMA_COMMANDS))
+                goto err;
+        if (alloc_dbdma_descriptor_ring(dev, &dev->in.dbdma_ring,
+                                        MAX_DBDMA_COMMANDS))
+                goto err;
+
+        if (i2sbus_control_add_dev(dev->control, dev)) {
+                printk(KERN_ERR "i2sbus: control layer didn't like bus\n");
+                goto err;
+        }
+
+        if (soundbus_add_one(&dev->sound)) {
+                printk(KERN_DEBUG "i2sbus: device registration error!\n");
+                goto err;
+        }
+
+        /* enable this cell */
+        i2sbus_control_cell(dev->control, dev, 1);
+        i2sbus_control_enable(dev->control, dev);
+        i2sbus_control_clock(dev->control, dev, 1);
+
+        return 1;
+ err:
+        for (i=0;i<3;i++)
+                if (dev->interrupts[i] != -1)
+                        free_irq(dev->interrupts[i], dev);
+        free_dbdma_descriptor_ring(dev, &dev->out.dbdma_ring);
+        free_dbdma_descriptor_ring(dev, &dev->in.dbdma_ring);
+        if (dev->intfregs) iounmap(dev->intfregs);
+        if (dev->out.dbdma) iounmap(dev->out.dbdma);
+        if (dev->in.dbdma) iounmap(dev->in.dbdma);
+        for (i=0;i<3;i++)
+                if (dev->allocated_resource[i])
+                        release_and_free_resource(dev->allocated_resource[i]);
+        mutex_destroy(&dev->lock);
+        kfree(dev);
+        return 0;
+}
+
+static int i2sbus_probe(struct macio_dev* dev, const struct of_device_id *match)
+{
+        struct device_node *np = NULL;
+        int got = 0, err;
+        struct i2sbus_control *control = NULL;
+
+        err = i2sbus_control_init(dev, &control);
+        if (err)
+                return err;
+        if (!control) {
+                printk(KERN_ERR "i2sbus_control_init API breakage\n");
+                return -ENODEV;
+        }
+
+        while ((np = of_get_next_child(dev->ofdev.node, np))) {
+                if (device_is_compatible(np, "i2sbus") ||
+                    device_is_compatible(np, "i2s-modem")) {
+                        got += i2sbus_add_dev(dev, control, np);
+                }
+        }
+
+        if (!got) {
+                /* found none, clean up */
+                i2sbus_control_destroy(control);
+                return -ENODEV;
+        }
+
+        dev->ofdev.dev.driver_data = control;
+
+        return 0;
+}
+
+static int i2sbus_remove(struct macio_dev* dev)
+{
+        struct i2sbus_control *control = dev->ofdev.dev.driver_data;
+        struct i2sbus_dev *i2sdev, *tmp;
+
+        list_for_each_entry_safe(i2sdev, tmp, &control->list, item)
+                soundbus_remove_one(&i2sdev->sound);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int i2sbus_suspend(struct macio_dev* dev, pm_message_t state)
+{
+        struct i2sbus_control *control = dev->ofdev.dev.driver_data;
+        struct codec_info_item *cii;
+        struct i2sbus_dev* i2sdev;
+        int err, ret = 0;
+
+        list_for_each_entry(i2sdev, &control->list, item) {
+                /* Notify Alsa */
+                if (i2sdev->sound.pcm) {
+                        /* Suspend PCM streams */
+                        snd_pcm_suspend_all(i2sdev->sound.pcm);
+                        /* Probably useless as we handle
+                         * power transitions ourselves */
+                        snd_power_change_state(i2sdev->sound.pcm->card,
+                                               SNDRV_CTL_POWER_D3hot);
+                }
+                /* Notify codecs */
+                list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
+                        err = 0;
+                        if (cii->codec->suspend)
+                                err = cii->codec->suspend(cii, state);
+                        if (err)
+                                ret = err;
+                }
+        }
+        return ret;
+}
+
+static int i2sbus_resume(struct macio_dev* dev)
+{
+        struct i2sbus_control *control = dev->ofdev.dev.driver_data;
+        struct codec_info_item *cii;
+        struct i2sbus_dev* i2sdev;
+        int err, ret = 0;
+
+        list_for_each_entry(i2sdev, &control->list, item) {
+                /* Notify codecs so they can re-initialize */
+                list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
+                        err = 0;
+                        if (cii->codec->resume)
+                                err = cii->codec->resume(cii);
+                        if (err)
+                                ret = err;
+                }
+                /* Notify Alsa */
+                if (i2sdev->sound.pcm) {
+                        /* Same comment as above, probably useless */
+                        snd_power_change_state(i2sdev->sound.pcm->card,
+                                               SNDRV_CTL_POWER_D0);
+                }
+        }
+
+        return ret;
+}
+#endif /* CONFIG_PM */
+
+static int i2sbus_shutdown(struct macio_dev* dev)
+{
+        return 0;
+}
+
+static struct macio_driver i2sbus_drv = {
+        .name = "soundbus-i2s",
+        .owner = THIS_MODULE,
+        .match_table = i2sbus_match,
+        .probe = i2sbus_probe,
+        .remove = i2sbus_remove,
+#ifdef CONFIG_PM
+        .suspend = i2sbus_suspend,
+        .resume = i2sbus_resume,
+#endif
+        .shutdown = i2sbus_shutdown,
+};
+
+static int __init soundbus_i2sbus_init(void)
+{
+        return macio_register_driver(&i2sbus_drv);
+}
+
+static void __exit soundbus_i2sbus_exit(void)
+{
+        macio_unregister_driver(&i2sbus_drv);
+}
+
+module_init(soundbus_i2sbus_init);
+module_exit(soundbus_i2sbus_exit);
diff --git a/sound/aoa/soundbus/i2sbus/i2sbus-interface.h b/sound/aoa/soundbus/i2sbus/i2sbus-interface.h
new file mode 100644
index 000000000000..c6b5f5452d20
--- /dev/null
+++ b/sound/aoa/soundbus/i2sbus/i2sbus-interface.h
@@ -0,0 +1,187 @@
+/*
+ * i2sbus driver -- interface register definitions
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+#ifndef __I2SBUS_INTERFACE_H
+#define __I2SBUS_INTERFACE_H
+
+/* i2s bus control registers, at least what we know about them */
+
+#define __PAD(m,n) u8 __pad##m[n]
+#define _PAD(line, n) __PAD(line, n)
+#define PAD(n) _PAD(__LINE__, (n))
+struct i2s_interface_regs {
+        __le32 intr_ctl;        /* 0x00 */
+        PAD(12);
+        __le32 serial_format;   /* 0x10 */
+        PAD(12);
+        __le32 codec_msg_out;   /* 0x20 */
+        PAD(12);
+        __le32 codec_msg_in;    /* 0x30 */
+        PAD(12);
+        __le32 frame_count;     /* 0x40 */
+        PAD(12);
+        __le32 frame_match;     /* 0x50 */
+        PAD(12);
+        __le32 data_word_sizes; /* 0x60 */
+        PAD(12);
+        __le32 peak_level_sel;  /* 0x70 */
+        PAD(12);
+        __le32 peak_level_in0;  /* 0x80 */
+        PAD(12);
+        __le32 peak_level_in1;  /* 0x90 */
+        PAD(12);
+        /* total size: 0x100 bytes */
+}  __attribute__((__packed__));
+
+/* interrupt register is just a bitfield with
+ * interrupt enable and pending bits */
+#define I2S_REG_INTR_CTL                0x00
+#       define I2S_INT_FRAME_COUNT              (1<<31)
+#       define I2S_PENDING_FRAME_COUNT          (1<<30)
+#       define I2S_INT_MESSAGE_FLAG             (1<<29)
+#       define I2S_PENDING_MESSAGE_FLAG         (1<<28)
+#       define I2S_INT_NEW_PEAK                 (1<<27)
+#       define I2S_PENDING_NEW_PEAK             (1<<26)
+#       define I2S_INT_CLOCKS_STOPPED           (1<<25)
+#       define I2S_PENDING_CLOCKS_STOPPED       (1<<24)
+#       define I2S_INT_EXTERNAL_SYNC_ERROR      (1<<23)
+#       define I2S_PENDING_EXTERNAL_SYNC_ERROR  (1<<22)
+#       define I2S_INT_EXTERNAL_SYNC_OK         (1<<21)
+#       define I2S_PENDING_EXTERNAL_SYNC_OK     (1<<20)
+#       define I2S_INT_NEW_SAMPLE_RATE          (1<<19)
+#       define I2S_PENDING_NEW_SAMPLE_RATE      (1<<18)
+#       define I2S_INT_STATUS_FLAG              (1<<17)
+#       define I2S_PENDING_STATUS_FLAG          (1<<16)
+
+/* serial format register is more interesting :)
+ * It contains:
+ *  - clock source
+ *  - MClk divisor
+ *  - SClk divisor
+ *  - SClk master flag
+ *  - serial format (sony, i2s 64x, i2s 32x, dav, silabs)
+ *  - external sample frequency interrupt (don't understand)
+ *  - external sample frequency
+ */
+#define I2S_REG_SERIAL_FORMAT           0x10
+/* clock source. You get either 18.432, 45.1584 or 49.1520 MHz */
+#       define I2S_SF_CLOCK_SOURCE_SHIFT        30
+#       define I2S_SF_CLOCK_SOURCE_MASK         (3<<I2S_SF_CLOCK_SOURCE_SHIFT)
+#       define I2S_SF_CLOCK_SOURCE_18MHz        (0<<I2S_SF_CLOCK_SOURCE_SHIFT)
+#       define I2S_SF_CLOCK_SOURCE_45MHz        (1<<I2S_SF_CLOCK_SOURCE_SHIFT)
+#       define I2S_SF_CLOCK_SOURCE_49MHz        (2<<I2S_SF_CLOCK_SOURCE_SHIFT)
+/* also, let's define the exact clock speeds here, in Hz */
+#define I2S_CLOCK_SPEED_18MHz   18432000
+#define I2S_CLOCK_SPEED_45MHz   45158400
+#define I2S_CLOCK_SPEED_49MHz   49152000
+/* MClk is the clock that drives the codec, usually called its 'system clock'.
+ * It is derived by taking only every 'divisor' tick of the clock.
+ */
+#       define I2S_SF_MCLKDIV_SHIFT             24
+#       define I2S_SF_MCLKDIV_MASK              (0x1F<<I2S_SF_MCLKDIV_SHIFT)
+#       define I2S_SF_MCLKDIV_1                 (0x14<<I2S_SF_MCLKDIV_SHIFT)
+#       define I2S_SF_MCLKDIV_3                 (0x13<<I2S_SF_MCLKDIV_SHIFT)
+#       define I2S_SF_MCLKDIV_5                 (0x12<<I2S_SF_MCLKDIV_SHIFT)
+#       define I2S_SF_MCLKDIV_14                (0x0E<<I2S_SF_MCLKDIV_SHIFT)
+#       define I2S_SF_MCLKDIV_OTHER(div)        (((div/2-1)<<I2S_SF_MCLKDIV_SHIFT)&I2S_SF_MCLKDIV_MASK)
+static inline int i2s_sf_mclkdiv(int div, int *out)
+{
+        int d;
+
+        switch(div) {
+        case 1: *out |= I2S_SF_MCLKDIV_1; return 0;
+        case 3: *out |= I2S_SF_MCLKDIV_3; return 0;
+        case 5: *out |= I2S_SF_MCLKDIV_5; return 0;
+        case 14: *out |= I2S_SF_MCLKDIV_14; return 0;
+        default:
+                if (div%2) return -1;
+                d = div/2-1;
+                if (d == 0x14 || d == 0x13 || d == 0x12 || d == 0x0E)
+                        return -1;
+                *out |= I2S_SF_MCLKDIV_OTHER(div);
+                return 0;
+        }
+}
+/* SClk is the clock that drives the i2s wire bus. Note that it is
+ * derived from the MClk above by taking only every 'divisor' tick
+ * of MClk.
+ */
+#       define I2S_SF_SCLKDIV_SHIFT             20
+#       define I2S_SF_SCLKDIV_MASK              (0xF<<I2S_SF_SCLKDIV_SHIFT)
+#       define I2S_SF_SCLKDIV_1                 (8<<I2S_SF_SCLKDIV_SHIFT)
+#       define I2S_SF_SCLKDIV_3                 (9<<I2S_SF_SCLKDIV_SHIFT)
+#       define I2S_SF_SCLKDIV_OTHER(div)        (((div/2-1)<<I2S_SF_SCLKDIV_SHIFT)&I2S_SF_SCLKDIV_MASK)
+static inline int i2s_sf_sclkdiv(int div, int *out)
+{
+        int d;
+
+        switch(div) {
+        case 1: *out |= I2S_SF_SCLKDIV_1; return 0;
+        case 3: *out |= I2S_SF_SCLKDIV_3; return 0;
+        default:
+                if (div%2) return -1;
+                d = div/2-1;
+                if (d == 8 || d == 9) return -1;
+                *out |= I2S_SF_SCLKDIV_OTHER(div);
+                return 0;
+        }
+}
+#       define I2S_SF_SCLK_MASTER               (1<<19)
+/* serial format is the way the data is put to the i2s wire bus */
+#       define I2S_SF_SERIAL_FORMAT_SHIFT       16
+#       define I2S_SF_SERIAL_FORMAT_MASK        (7<<I2S_SF_SERIAL_FORMAT_SHIFT)
+#       define I2S_SF_SERIAL_FORMAT_SONY        (0<<I2S_SF_SERIAL_FORMAT_SHIFT)
+#       define I2S_SF_SERIAL_FORMAT_I2S_64X     (1<<I2S_SF_SERIAL_FORMAT_SHIFT)
+#       define I2S_SF_SERIAL_FORMAT_I2S_32X     (2<<I2S_SF_SERIAL_FORMAT_SHIFT)
+#       define I2S_SF_SERIAL_FORMAT_I2S_DAV     (4<<I2S_SF_SERIAL_FORMAT_SHIFT)
+#       define I2S_SF_SERIAL_FORMAT_I2S_SILABS  (5<<I2S_SF_SERIAL_FORMAT_SHIFT)
+/* unknown */
+#       define I2S_SF_EXT_SAMPLE_FREQ_INT_SHIFT 12
+#       define I2S_SF_EXT_SAMPLE_FREQ_INT_MASK  (0xF<<I2S_SF_SAMPLE_FREQ_INT_SHIFT)
+/* probably gives external frequency? */
+#       define I2S_SF_EXT_SAMPLE_FREQ_MASK      0xFFF
+
+/* used to send codec messages, but how isn't clear */
+#define I2S_REG_CODEC_MSG_OUT           0x20
+
+/* used to receive codec messages, but how isn't clear */
+#define I2S_REG_CODEC_MSG_IN            0x30
+
+/* frame count reg isn't clear to me yet, but probably useful */
+#define I2S_REG_FRAME_COUNT             0x40
+
+/* program to some value, and get interrupt if frame count reaches it */
+#define I2S_REG_FRAME_MATCH             0x50
+
+/* this register describes how the bus transfers data */
+#define I2S_REG_DATA_WORD_SIZES         0x60
+/* number of interleaved input channels */
+#       define I2S_DWS_NUM_CHANNELS_IN_SHIFT    24
+#       define I2S_DWS_NUM_CHANNELS_IN_MASK     (0x1F<<I2S_DWS_NUM_CHANNELS_IN_SHIFT)
+/* word size of input data */
+#       define I2S_DWS_DATA_IN_SIZE_SHIFT       16
+#       define I2S_DWS_DATA_IN_16BIT            (0<<I2S_DWS_DATA_IN_SIZE_SHIFT)
+#       define I2S_DWS_DATA_IN_24BIT            (3<<I2S_DWS_DATA_IN_SIZE_SHIFT)
+/* number of interleaved output channels */
+#       define I2S_DWS_NUM_CHANNELS_OUT_SHIFT   8
+#       define I2S_DWS_NUM_CHANNELS_OUT_MASK    (0x1F<<I2S_DWS_NUM_CHANNELS_OUT_SHIFT)
+/* word size of output data */
+#       define I2S_DWS_DATA_OUT_SIZE_SHIFT      0
+#       define I2S_DWS_DATA_OUT_16BIT           (0<<I2S_DWS_DATA_OUT_SIZE_SHIFT)
+#       define I2S_DWS_DATA_OUT_24BIT           (3<<I2S_DWS_DATA_OUT_SIZE_SHIFT)
+
+
+/* unknown */
+#define I2S_REG_PEAK_LEVEL_SEL          0x70
+
+/* unknown */
+#define I2S_REG_PEAK_LEVEL_IN0          0x80
+
+/* unknown */
+#define I2S_REG_PEAK_LEVEL_IN1          0x90
+
+#endif /* __I2SBUS_INTERFACE_H */
diff --git a/sound/aoa/soundbus/i2sbus/i2sbus-pcm.c b/sound/aoa/soundbus/i2sbus/i2sbus-pcm.c
new file mode 100644
index 000000000000..3049015a04f1
--- /dev/null
+++ b/sound/aoa/soundbus/i2sbus/i2sbus-pcm.c
@@ -0,0 +1,1021 @@
+/*
+ * i2sbus driver -- pcm routines
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+
+#include <asm/io.h>
+#include <linux/delay.h>
+/* So apparently there's a reason for requiring driver.h
+ * to be included first, even if I don't know it... */
+#include <sound/driver.h>
+#include <sound/core.h>
+#include <asm/macio.h>
+#include <linux/pci.h>
+#include "../soundbus.h"
+#include "i2sbus.h"
+
+static inline void get_pcm_info(struct i2sbus_dev *i2sdev, int in,
+                                struct pcm_info **pi, struct pcm_info **other)
+{
+        if (in) {
+                if (pi)
+                        *pi = &i2sdev->in;
+                if (other)
+                        *other = &i2sdev->out;
+        } else {
+                if (pi)
+                        *pi = &i2sdev->out;
+                if (other)
+                        *other = &i2sdev->in;
+        }
+}
+
+static int clock_and_divisors(int mclk, int sclk, int rate, int *out)
+{
+        /* sclk must be derived from mclk! */
+        if (mclk % sclk)
+                return -1;
+        /* derive sclk register value */
+        if (i2s_sf_sclkdiv(mclk / sclk, out))
+                return -1;
+
+        if (I2S_CLOCK_SPEED_18MHz % (rate * mclk) == 0) {
+                if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_18MHz / (rate * mclk), out)) {
+                        *out |= I2S_SF_CLOCK_SOURCE_18MHz;
+                        return 0;
+                }
+        }
+        if (I2S_CLOCK_SPEED_45MHz % (rate * mclk) == 0) {
+                if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_45MHz / (rate * mclk), out)) {
+                        *out |= I2S_SF_CLOCK_SOURCE_45MHz;
+                        return 0;
+                }
+        }
+        if (I2S_CLOCK_SPEED_49MHz % (rate * mclk) == 0) {
+                if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_49MHz / (rate * mclk), out)) {
+                        *out |= I2S_SF_CLOCK_SOURCE_49MHz;
+                        return 0;
+                }
+        }
+        return -1;
+}
+
+#define CHECK_RATE(rate)                                                \
+        do { if (rates & SNDRV_PCM_RATE_ ##rate) {                      \
+                int dummy;                                              \
+                if (clock_and_divisors(sysclock_factor,                 \
+                                       bus_factor, rate, &dummy))       \
+                        rates &= ~SNDRV_PCM_RATE_ ##rate;               \
+        } } while (0)
+
+static int i2sbus_pcm_open(struct i2sbus_dev *i2sdev, int in)
+{
+        struct pcm_info *pi, *other;
+        struct soundbus_dev *sdev;
+        int masks_inited = 0, err;
+        struct codec_info_item *cii, *rev;
+        struct snd_pcm_hardware *hw;
+        u64 formats = 0;
+        unsigned int rates = 0;
+        struct transfer_info v;
+        int result = 0;
+        int bus_factor = 0, sysclock_factor = 0;
+        int found_this;
+
+        mutex_lock(&i2sdev->lock);
+
+        get_pcm_info(i2sdev, in, &pi, &other);
+
+        hw = &pi->substream->runtime->hw;
+        sdev = &i2sdev->sound;
+
+        if (pi->active) {
+                /* alsa messed up */
+                result = -EBUSY;
+                goto out_unlock;
+        }
+
+        /* we now need to assign the hw */
+        list_for_each_entry(cii, &sdev->codec_list, list) {
+                struct transfer_info *ti = cii->codec->transfers;
+                bus_factor = cii->codec->bus_factor;
+                sysclock_factor = cii->codec->sysclock_factor;
+                while (ti->formats && ti->rates) {
+                        v = *ti;
+                        if (ti->transfer_in == in
+                            && cii->codec->usable(cii, ti, &v)) {
+                                if (masks_inited) {
+                                        formats &= v.formats;
+                                        rates &= v.rates;
+                                } else {
+                                        formats = v.formats;
+                                        rates = v.rates;
+                                        masks_inited = 1;
+                                }
+                        }
+                        ti++;
+                }
+        }
+        if (!masks_inited || !bus_factor || !sysclock_factor) {
+                result = -ENODEV;
+                goto out_unlock;
+        }
+        /* bus dependent stuff */
+        hw->info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
+                   SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_RESUME;
+
+        CHECK_RATE(5512);
+        CHECK_RATE(8000);
+        CHECK_RATE(11025);
+        CHECK_RATE(16000);
+        CHECK_RATE(22050);
+        CHECK_RATE(32000);
+        CHECK_RATE(44100);
+        CHECK_RATE(48000);
+        CHECK_RATE(64000);
+        CHECK_RATE(88200);
+        CHECK_RATE(96000);
+        CHECK_RATE(176400);
+        CHECK_RATE(192000);
+        hw->rates = rates;
+
+        /* well. the codec might want 24 bits only, and we'll
+         * ever only transfer 24 bits, but they are top-aligned!
+         * So for alsa, we claim that we're doing full 32 bit
+         * while in reality we'll ignore the lower 8 bits of
+         * that when doing playback (they're transferred as 0
+         * as far as I know, no codecs we have are 32-bit capable
+         * so I can't really test) and when doing recording we'll
+         * always have those lower 8 bits recorded as 0 */
+        if (formats & SNDRV_PCM_FMTBIT_S24_BE)
+                formats |= SNDRV_PCM_FMTBIT_S32_BE;
+        if (formats & SNDRV_PCM_FMTBIT_U24_BE)
+                formats |= SNDRV_PCM_FMTBIT_U32_BE;
+        /* now mask off what we can support. I suppose we could
+         * also support S24_3LE and some similar formats, but I
+         * doubt there's a codec that would be able to use that,
+         * so we don't support it here. */
+        hw->formats = formats & (SNDRV_PCM_FMTBIT_S16_BE |
+                                 SNDRV_PCM_FMTBIT_U16_BE |
+                                 SNDRV_PCM_FMTBIT_S32_BE |
+                                 SNDRV_PCM_FMTBIT_U32_BE);
+
+        /* we need to set the highest and lowest rate possible.
+         * These are the highest and lowest rates alsa can
+         * support properly in its bitfield.
+         * Below, we'll use that to restrict to the rate
+         * currently in use (if any). */
+        hw->rate_min = 5512;
+        hw->rate_max = 192000;
+        /* if the other stream is active, then we can only
+         * support what it is currently using.
+         * FIXME: I lied. This comment is wrong. We can support
+         * anything that works with the same serial format, ie.
+         * when recording 24 bit sound we can well play 16 bit
+         * sound at the same time iff using the same transfer mode.
+         */
+        if (other->active) {
+                /* FIXME: is this guaranteed by the alsa api? */
+                hw->formats &= (1ULL << i2sdev->format);
+                /* see above, restrict rates to the one we already have */
+                hw->rate_min = i2sdev->rate;
+                hw->rate_max = i2sdev->rate;
+        }
+
+        hw->channels_min = 2;
+        hw->channels_max = 2;
+        /* these are somewhat arbitrary */
+        hw->buffer_bytes_max = 131072;
+        hw->period_bytes_min = 256;
+        hw->period_bytes_max = 16384;
+        hw->periods_min = 3;
+        hw->periods_max = MAX_DBDMA_COMMANDS;
+        list_for_each_entry(cii, &sdev->codec_list, list) {
+                if (cii->codec->open) {
+                        err = cii->codec->open(cii, pi->substream);
+                        if (err) {
+                                result = err;
+                                /* unwind */
+                                found_this = 0;
+                                list_for_each_entry_reverse(rev,
+                                    &sdev->codec_list, list) {
+                                        if (found_this && rev->codec->close) {
+                                                rev->codec->close(rev,
+                                                                pi->substream);
+                                        }
+                                        if (rev == cii)
+                                                found_this = 1;
+                                }
+                                goto out_unlock;
+                        }
+                }
+        }
+
+ out_unlock:
+        mutex_unlock(&i2sdev->lock);
+        return result;
+}
+
+#undef CHECK_RATE
+
+static int i2sbus_pcm_close(struct i2sbus_dev *i2sdev, int in)
+{
+        struct codec_info_item *cii;
+        struct pcm_info *pi;
+        int err = 0, tmp;
+
+        mutex_lock(&i2sdev->lock);
+
+        get_pcm_info(i2sdev, in, &pi, NULL);
+
+        list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
+                if (cii->codec->close) {
+                        tmp = cii->codec->close(cii, pi->substream);
+                        if (tmp)
+                                err = tmp;
+                }
+        }
+
+        pi->substream = NULL;
+        pi->active = 0;
+        mutex_unlock(&i2sdev->lock);
+        return err;
+}
+
+static int i2sbus_hw_params(struct snd_pcm_substream *substream,
+                            struct snd_pcm_hw_params *params)
+{
+        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
+}
+
+static int i2sbus_hw_free(struct snd_pcm_substream *substream)
+{
+        snd_pcm_lib_free_pages(substream);
+        return 0;
+}
+
+static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in)
+{
+        /* whee. Hard work now. The user has selected a bitrate
+         * and bit format, so now we have to program our
+         * I2S controller appropriately. */
+        struct snd_pcm_runtime *runtime;
+        struct dbdma_cmd *command;
+        int i, periodsize;
+        dma_addr_t offset;
+        struct bus_info bi;
+        struct codec_info_item *cii;
+        int sfr = 0;            /* serial format register */
+        int dws = 0;            /* data word sizes reg */
+        int input_16bit;
+        struct pcm_info *pi, *other;
+        int cnt;
+        int result = 0;
+
+        mutex_lock(&i2sdev->lock);
+
+        get_pcm_info(i2sdev, in, &pi, &other);
+
+        if (pi->dbdma_ring.running) {
+                result = -EBUSY;
+                goto out_unlock;
+        }
+
+        runtime = pi->substream->runtime;
+        pi->active = 1;
+        if (other->active &&
+            ((i2sdev->format != runtime->format)
+             || (i2sdev->rate != runtime->rate))) {
+                result = -EINVAL;
+                goto out_unlock;
+        }
+
+        i2sdev->format = runtime->format;
+        i2sdev->rate = runtime->rate;
+
+        periodsize = snd_pcm_lib_period_bytes(pi->substream);
+        pi->current_period = 0;
+
+        /* generate dbdma command ring first */
+        command = pi->dbdma_ring.cmds;
+        offset = runtime->dma_addr;
+        for (i = 0; i < pi->substream->runtime->periods;
+             i++, command++, offset += periodsize) {
+                memset(command, 0, sizeof(struct dbdma_cmd));
+                command->command =
+                    cpu_to_le16((in ? INPUT_MORE : OUTPUT_MORE) | INTR_ALWAYS);
+                command->phy_addr = cpu_to_le32(offset);
+                command->req_count = cpu_to_le16(periodsize);
+                command->xfer_status = cpu_to_le16(0);
+        }
+        /* last one branches back to first */
+        command--;
+        command->command |= cpu_to_le16(BR_ALWAYS);
+        command->cmd_dep = cpu_to_le32(pi->dbdma_ring.bus_cmd_start);
+
+        /* ok, let's set the serial format and stuff */
+        switch (runtime->format) {
+        /* 16 bit formats */
+        case SNDRV_PCM_FORMAT_S16_BE:
+        case SNDRV_PCM_FORMAT_U16_BE:
+                /* FIXME: if we add different bus factors we need to
+                 * do more here!! */
+                bi.bus_factor = 0;
+                list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
+                        bi.bus_factor = cii->codec->bus_factor;
+                        break;
+                }
+                if (!bi.bus_factor) {
+                        result = -ENODEV;
+                        goto out_unlock;
+                }
+                input_16bit = 1;
+                break;
+        case SNDRV_PCM_FORMAT_S32_BE:
+        case SNDRV_PCM_FORMAT_U32_BE:
+                /* force 64x bus speed, otherwise the data cannot be
+                 * transferred quickly enough! */
+                bi.bus_factor = 64;
+                input_16bit = 0;
+                break;
+        default:
+                result = -EINVAL;
+                goto out_unlock;
+        }
+        /* we assume all sysclocks are the same! */
+        list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
+                bi.sysclock_factor = cii->codec->sysclock_factor;
+                break;
+        }
+
+        if (clock_and_divisors(bi.sysclock_factor,
+                               bi.bus_factor,
+                               runtime->rate,
+                               &sfr) < 0) {
+                result = -EINVAL;
+                goto out_unlock;
+        }
+        switch (bi.bus_factor) {
+        case 32:
+                sfr |= I2S_SF_SERIAL_FORMAT_I2S_32X;
+                break;
+        case 64:
+                sfr |= I2S_SF_SERIAL_FORMAT_I2S_64X;
+                break;
+        }
+        /* FIXME: THIS ASSUMES MASTER ALL THE TIME */
+        sfr |= I2S_SF_SCLK_MASTER;
+
+        list_for_each_entry(cii, &i2sdev->sound.codec_list, list) {
+                int err = 0;
+                if (cii->codec->prepare)
+                        err = cii->codec->prepare(cii, &bi, pi->substream);
+                if (err) {
+                        result = err;
+                        goto out_unlock;
+                }
+        }
+        /* codecs are fine with it, so set our clocks */
+        if (input_16bit)
+                dws =   (2 << I2S_DWS_NUM_CHANNELS_IN_SHIFT) |
+                        (2 << I2S_DWS_NUM_CHANNELS_OUT_SHIFT) |
+                        I2S_DWS_DATA_IN_16BIT | I2S_DWS_DATA_OUT_16BIT;
+        else
+                dws =   (2 << I2S_DWS_NUM_CHANNELS_IN_SHIFT) |
+                        (2 << I2S_DWS_NUM_CHANNELS_OUT_SHIFT) |
+                        I2S_DWS_DATA_IN_24BIT | I2S_DWS_DATA_OUT_24BIT;
+
+        /* early exit if already programmed correctly */
+        /* not locking these is fine since we touch them only in this function */
+        if (in_le32(&i2sdev->intfregs->serial_format) == sfr
+         && in_le32(&i2sdev->intfregs->data_word_sizes) == dws)
+                goto out_unlock;
+
+        /* let's notify the codecs about clocks going away.
+         * For now we only do mastering on the i2s cell... */
+        list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
+                if (cii->codec->switch_clock)
+                        cii->codec->switch_clock(cii, CLOCK_SWITCH_PREPARE_SLAVE);
+
+        i2sbus_control_enable(i2sdev->control, i2sdev);
+        i2sbus_control_cell(i2sdev->control, i2sdev, 1);
+
+        out_le32(&i2sdev->intfregs->intr_ctl, I2S_PENDING_CLOCKS_STOPPED);
+
+        i2sbus_control_clock(i2sdev->control, i2sdev, 0);
+
+        msleep(1);
+
+        /* wait for clock stopped. This can apparently take a while... */
+        cnt = 100;
+        while (cnt-- &&
+            !(in_le32(&i2sdev->intfregs->intr_ctl) & I2S_PENDING_CLOCKS_STOPPED)) {
+                msleep(5);
+        }
+        out_le32(&i2sdev->intfregs->intr_ctl, I2S_PENDING_CLOCKS_STOPPED);
+
+        /* not locking these is fine since we touch them only in this function */
+        out_le32(&i2sdev->intfregs->serial_format, sfr);
+        out_le32(&i2sdev->intfregs->data_word_sizes, dws);
+
+        i2sbus_control_enable(i2sdev->control, i2sdev);
+        i2sbus_control_cell(i2sdev->control, i2sdev, 1);
+        i2sbus_control_clock(i2sdev->control, i2sdev, 1);
+        msleep(1);
+
+        list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
+                if (cii->codec->switch_clock)
+                        cii->codec->switch_clock(cii, CLOCK_SWITCH_SLAVE);
+
+ out_unlock:
+        mutex_unlock(&i2sdev->lock);
+        return result;
+}
+
+static struct dbdma_cmd STOP_CMD = {
+        .command = __constant_cpu_to_le16(DBDMA_STOP),
+};
+
+static int i2sbus_pcm_trigger(struct i2sbus_dev *i2sdev, int in, int cmd)
+{
+        struct codec_info_item *cii;
+        struct pcm_info *pi;
+        int timeout;
+        struct dbdma_cmd tmp;
+        int result = 0;
+        unsigned long flags;
+
+        spin_lock_irqsave(&i2sdev->low_lock, flags);
+
+        get_pcm_info(i2sdev, in, &pi, NULL);
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+                if (pi->dbdma_ring.running) {
+                        result = -EALREADY;
+                        goto out_unlock;
+                }
+                list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
+                        if (cii->codec->start)
+                                cii->codec->start(cii, pi->substream);
+                pi->dbdma_ring.running = 1;
+
+                /* reset dma engine */
+                out_le32(&pi->dbdma->control,
+                         0 | (RUN | PAUSE | FLUSH | WAKE) << 16);
+                timeout = 100;
+                while (in_le32(&pi->dbdma->status) & RUN && timeout--)
+                        udelay(1);
+                if (timeout <= 0) {
+                        printk(KERN_ERR
+                               "i2sbus: error waiting for dma reset\n");
+                        result = -ENXIO;
+                        goto out_unlock;
+                }
+
+                /* write dma command buffer address to the dbdma chip */
+                out_le32(&pi->dbdma->cmdptr, pi->dbdma_ring.bus_cmd_start);
+                /* post PCI write */
+                mb();
+                (void)in_le32(&pi->dbdma->status);
+
+                /* change first command to STOP */
+                tmp = *pi->dbdma_ring.cmds;
+                *pi->dbdma_ring.cmds = STOP_CMD;
+
+                /* set running state, remember that the first command is STOP */
+                out_le32(&pi->dbdma->control, RUN | (RUN << 16));
+                timeout = 100;
+                /* wait for STOP to be executed */
+                while (in_le32(&pi->dbdma->status) & ACTIVE && timeout--)
+                        udelay(1);
+                if (timeout <= 0) {
+                        printk(KERN_ERR "i2sbus: error waiting for dma stop\n");
+                        result = -ENXIO;
+                        goto out_unlock;
+                }
+                /* again, write dma command buffer address to the dbdma chip,
+                 * this time of the first real command */
+                *pi->dbdma_ring.cmds = tmp;
+                out_le32(&pi->dbdma->cmdptr, pi->dbdma_ring.bus_cmd_start);
+                /* post write */
+                mb();
+                (void)in_le32(&pi->dbdma->status);
+
+                /* reset dma engine again */
+                out_le32(&pi->dbdma->control,
+                         0 | (RUN | PAUSE | FLUSH | WAKE) << 16);
+                timeout = 100;
+                while (in_le32(&pi->dbdma->status) & RUN && timeout--)
+                        udelay(1);
+                if (timeout <= 0) {
+                        printk(KERN_ERR
+                               "i2sbus: error waiting for dma reset\n");
+                        result = -ENXIO;
+                        goto out_unlock;
+                }
+
+                /* wake up the chip with the next descriptor */
+                out_le32(&pi->dbdma->control,
+                         (RUN | WAKE) | ((RUN | WAKE) << 16));
+                /* get the frame count  */
+                pi->frame_count = in_le32(&i2sdev->intfregs->frame_count);
+
+                /* off you go! */
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                if (!pi->dbdma_ring.running) {
+                        result = -EALREADY;
+                        goto out_unlock;
+                }
+
+                /* turn off all relevant bits */
+                out_le32(&pi->dbdma->control,
+                         (RUN | WAKE | FLUSH | PAUSE) << 16);
+                {
+                        /* FIXME: move to own function */
+                        int timeout = 5000;
+                        while ((in_le32(&pi->dbdma->status) & RUN)
+                               && --timeout > 0)
+                                udelay(1);
+                        if (!timeout)
+                                printk(KERN_ERR
+                                       "i2sbus: timed out turning "
+                                       "off dbdma engine!\n");
+                }
+
+                pi->dbdma_ring.running = 0;
+                list_for_each_entry(cii, &i2sdev->sound.codec_list, list)
+                        if (cii->codec->stop)
+                                cii->codec->stop(cii, pi->substream);
+                break;
+        default:
+                result = -EINVAL;
+                goto out_unlock;
+        }
+
+ out_unlock:
+        spin_unlock_irqrestore(&i2sdev->low_lock, flags);
+        return result;
+}
+
+static snd_pcm_uframes_t i2sbus_pcm_pointer(struct i2sbus_dev *i2sdev, int in)
+{
+        struct pcm_info *pi;
+        u32 fc;
+
+        get_pcm_info(i2sdev, in, &pi, NULL);
+
+        fc = in_le32(&i2sdev->intfregs->frame_count);
+        fc = fc - pi->frame_count;
+
+        return (bytes_to_frames(pi->substream->runtime,
+                        pi->current_period *
+                        snd_pcm_lib_period_bytes(pi->substream))
+                + fc) % pi->substream->runtime->buffer_size;
+}
+
+static inline void handle_interrupt(struct i2sbus_dev *i2sdev, int in)
+{
+        struct pcm_info *pi;
+        u32 fc;
+        u32 delta;
+
+        spin_lock(&i2sdev->low_lock);
+        get_pcm_info(i2sdev, in, &pi, NULL);
+
+        if (!pi->dbdma_ring.running) {
+                /* there was still an interrupt pending
+                 * while we stopped. or maybe another
+                 * processor (not the one that was stopping
+                 * the DMA engine) was spinning above
+                 * waiting for the lock. */
+                goto out_unlock;
+        }
+
+        fc = in_le32(&i2sdev->intfregs->frame_count);
+        /* a counter overflow does not change the calculation. */
+        delta = fc - pi->frame_count;
+
+        /* update current_period */
+        while (delta >= pi->substream->runtime->period_size) {
+                pi->current_period++;
+                delta = delta - pi->substream->runtime->period_size;
+        }
+
+        if (unlikely(delta)) {
+                /* Some interrupt came late, so check the dbdma.
+                 * This special case exists to syncronize the frame_count with
+                 * the dbdma transfer, but is hit every once in a while. */
+                int period;
+
+                period = (in_le32(&pi->dbdma->cmdptr)
+                        - pi->dbdma_ring.bus_cmd_start)
+                                / sizeof(struct dbdma_cmd);
+                pi->current_period = pi->current_period
+                                        % pi->substream->runtime->periods;
+
+                while (pi->current_period != period) {
+                        pi->current_period++;
+                        pi->current_period %= pi->substream->runtime->periods;
+                        /* Set delta to zero, as the frame_count value is too
+                         * high (otherwise the code path will not be executed).
+                         * This corrects the fact that the frame_count is too
+                         * low at the beginning due to buffering. */
+                        delta = 0;
+                }
+        }
+
+        pi->frame_count = fc - delta;
+        pi->current_period %= pi->substream->runtime->periods;
+
+        spin_unlock(&i2sdev->low_lock);
+        /* may call _trigger again, hence needs to be unlocked */
+        snd_pcm_period_elapsed(pi->substream);
+        return;
+ out_unlock:
+        spin_unlock(&i2sdev->low_lock);
+}
+
+irqreturn_t i2sbus_tx_intr(int irq, void *devid, struct pt_regs *regs)
+{
+        handle_interrupt((struct i2sbus_dev *)devid, 0);
+        return IRQ_HANDLED;
+}
+
+irqreturn_t i2sbus_rx_intr(int irq, void *devid, struct pt_regs * regs)
+{
+        handle_interrupt((struct i2sbus_dev *)devid, 1);
+        return IRQ_HANDLED;
+}
+
+static int i2sbus_playback_open(struct snd_pcm_substream *substream)
+{
+        struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
+
+        if (!i2sdev)
+                return -EINVAL;
+        i2sdev->out.substream = substream;
+        return i2sbus_pcm_open(i2sdev, 0);
+}
+
+static int i2sbus_playback_close(struct snd_pcm_substream *substream)
+{
+        struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
+        int err;
+
+        if (!i2sdev)
+                return -EINVAL;
+        if (i2sdev->out.substream != substream)
+                return -EINVAL;
+        err = i2sbus_pcm_close(i2sdev, 0);
+        if (!err)
+                i2sdev->out.substream = NULL;
+        return err;
+}
+
+static int i2sbus_playback_prepare(struct snd_pcm_substream *substream)
+{
+        struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
+
+        if (!i2sdev)
+                return -EINVAL;
+        if (i2sdev->out.substream != substream)
+                return -EINVAL;
+        return i2sbus_pcm_prepare(i2sdev, 0);
+}
+
+static int i2sbus_playback_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
+
+        if (!i2sdev)
+                return -EINVAL;
+        if (i2sdev->out.substream != substream)
+                return -EINVAL;
+        return i2sbus_pcm_trigger(i2sdev, 0, cmd);
+}
+
+static snd_pcm_uframes_t i2sbus_playback_pointer(struct snd_pcm_substream
+                                                 *substream)
+{
+        struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
+
+        if (!i2sdev)
+                return -EINVAL;
+        if (i2sdev->out.substream != substream)
+                return 0;
+        return i2sbus_pcm_pointer(i2sdev, 0);
+}
+
+static struct snd_pcm_ops i2sbus_playback_ops = {
+        .open =         i2sbus_playback_open,
+        .close =        i2sbus_playback_close,
+        .ioctl =        snd_pcm_lib_ioctl,
+        .hw_params =    i2sbus_hw_params,
+        .hw_free =      i2sbus_hw_free,
+        .prepare =      i2sbus_playback_prepare,
+        .trigger =      i2sbus_playback_trigger,
+        .pointer =      i2sbus_playback_pointer,
+};
+
+static int i2sbus_record_open(struct snd_pcm_substream *substream)
+{
+        struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
+
+        if (!i2sdev)
+                return -EINVAL;
+        i2sdev->in.substream = substream;
+        return i2sbus_pcm_open(i2sdev, 1);
+}
+
+static int i2sbus_record_close(struct snd_pcm_substream *substream)
+{
+        struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
+        int err;
+
+        if (!i2sdev)
+                return -EINVAL;
+        if (i2sdev->in.substream != substream)
+                return -EINVAL;
+        err = i2sbus_pcm_close(i2sdev, 1);
+        if (!err)
+                i2sdev->in.substream = NULL;
+        return err;
+}
+
+static int i2sbus_record_prepare(struct snd_pcm_substream *substream)
+{
+        struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
+
+        if (!i2sdev)
+                return -EINVAL;
+        if (i2sdev->in.substream != substream)
+                return -EINVAL;
+        return i2sbus_pcm_prepare(i2sdev, 1);
+}
+
+static int i2sbus_record_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
+
+        if (!i2sdev)
+                return -EINVAL;
+        if (i2sdev->in.substream != substream)
+                return -EINVAL;
+        return i2sbus_pcm_trigger(i2sdev, 1, cmd);
+}
+
+static snd_pcm_uframes_t i2sbus_record_pointer(struct snd_pcm_substream
+                                               *substream)
+{
+        struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream);
+
+        if (!i2sdev)
+                return -EINVAL;
+        if (i2sdev->in.substream != substream)
+                return 0;
+        return i2sbus_pcm_pointer(i2sdev, 1);
+}
+
+static struct snd_pcm_ops i2sbus_record_ops = {
+        .open =         i2sbus_record_open,
+        .close =        i2sbus_record_close,
+        .ioctl =        snd_pcm_lib_ioctl,
+        .hw_params =    i2sbus_hw_params,
+        .hw_free =      i2sbus_hw_free,
+        .prepare =      i2sbus_record_prepare,
+        .trigger =      i2sbus_record_trigger,
+        .pointer =      i2sbus_record_pointer,
+};
+
+static void i2sbus_private_free(struct snd_pcm *pcm)
+{
+        struct i2sbus_dev *i2sdev = snd_pcm_chip(pcm);
+        struct codec_info_item *p, *tmp;
+
+        i2sdev->sound.pcm = NULL;
+        i2sdev->out.created = 0;
+        i2sdev->in.created = 0;
+        list_for_each_entry_safe(p, tmp, &i2sdev->sound.codec_list, list) {
+                printk(KERN_ERR "i2sbus: a codec didn't unregister!\n");
+                list_del(&p->list);
+                module_put(p->codec->owner);
+                kfree(p);
+        }
+        soundbus_dev_put(&i2sdev->sound);
+        module_put(THIS_MODULE);
+}
+
+/* FIXME: this function needs an error handling strategy with labels */
+int
+i2sbus_attach_codec(struct soundbus_dev *dev, struct snd_card *card,
+                    struct codec_info *ci, void *data)
+{
+        int err, in = 0, out = 0;
+        struct transfer_info *tmp;
+        struct i2sbus_dev *i2sdev = soundbus_dev_to_i2sbus_dev(dev);
+        struct codec_info_item *cii;
+
+        if (!dev->pcmname || dev->pcmid == -1) {
+                printk(KERN_ERR "i2sbus: pcm name and id must be set!\n");
+                return -EINVAL;
+        }
+
+        list_for_each_entry(cii, &dev->codec_list, list) {
+                if (cii->codec_data == data)
+                        return -EALREADY;
+        }
+
+        if (!ci->transfers || !ci->transfers->formats
+            || !ci->transfers->rates || !ci->usable)
+                return -EINVAL;
+
+        /* we currently code the i2s transfer on the clock, and support only
+         * 32 and 64 */
+        if (ci->bus_factor != 32 && ci->bus_factor != 64)
+                return -EINVAL;
+
+        /* If you want to fix this, you need to keep track of what transport infos
+         * are to be used, which codecs they belong to, and then fix all the
+         * sysclock/busclock stuff above to depend on which is usable */
+        list_for_each_entry(cii, &dev->codec_list, list) {
+                if (cii->codec->sysclock_factor != ci->sysclock_factor) {
+                        printk(KERN_DEBUG
+                               "cannot yet handle multiple different sysclocks!\n");
+                        return -EINVAL;
+                }
+                if (cii->codec->bus_factor != ci->bus_factor) {
+                        printk(KERN_DEBUG
+                               "cannot yet handle multiple different bus clocks!\n");
+                        return -EINVAL;
+                }
+        }
+
+        tmp = ci->transfers;
+        while (tmp->formats && tmp->rates) {
+                if (tmp->transfer_in)
+                        in = 1;
+                else
+                        out = 1;
+                tmp++;
+        }
+
+        cii = kzalloc(sizeof(struct codec_info_item), GFP_KERNEL);
+        if (!cii) {
+                printk(KERN_DEBUG "i2sbus: failed to allocate cii\n");
+                return -ENOMEM;
+        }
+
+        /* use the private data to point to the codec info */
+        cii->sdev = soundbus_dev_get(dev);
+        cii->codec = ci;
+        cii->codec_data = data;
+
+        if (!cii->sdev) {
+                printk(KERN_DEBUG
+                       "i2sbus: failed to get soundbus dev reference\n");
+                kfree(cii);
+                return -ENODEV;
+        }
+
+        if (!try_module_get(THIS_MODULE)) {
+                printk(KERN_DEBUG "i2sbus: failed to get module reference!\n");
+                soundbus_dev_put(dev);
+                kfree(cii);
+                return -EBUSY;
+        }
+
+        if (!try_module_get(ci->owner)) {
+                printk(KERN_DEBUG
+                       "i2sbus: failed to get module reference to codec owner!\n");
+                module_put(THIS_MODULE);
+                soundbus_dev_put(dev);
+                kfree(cii);
+                return -EBUSY;
+        }
+
+        if (!dev->pcm) {
+                err = snd_pcm_new(card,
+                                  dev->pcmname,
+                                  dev->pcmid,
+                                  0,
+                                  0,
+                                  &dev->pcm);
+                if (err) {
+                        printk(KERN_DEBUG "i2sbus: failed to create pcm\n");
+                        kfree(cii);
+                        module_put(ci->owner);
+                        soundbus_dev_put(dev);
+                        module_put(THIS_MODULE);
+                        return err;
+                }
+        }
+
+        /* ALSA yet again sucks.
+         * If it is ever fixed, remove this line. See below. */
+        out = in = 1;
+
+        if (!i2sdev->out.created && out) {
+                if (dev->pcm->card != card) {
+                        /* eh? */
+                        printk(KERN_ERR
+                               "Can't attach same bus to different cards!\n");
+                        module_put(ci->owner);
+                        kfree(cii);
+                        soundbus_dev_put(dev);
+                        module_put(THIS_MODULE);
+                        return -EINVAL;
+                }
+                if ((err =
+                     snd_pcm_new_stream(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK, 1))) {
+                        module_put(ci->owner);
+                        kfree(cii);
+                        soundbus_dev_put(dev);
+                        module_put(THIS_MODULE);
+                        return err;
+                }
+                snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                                &i2sbus_playback_ops);
+                i2sdev->out.created = 1;
+        }
+
+        if (!i2sdev->in.created && in) {
+                if (dev->pcm->card != card) {
+                        printk(KERN_ERR
+                               "Can't attach same bus to different cards!\n");
+                        module_put(ci->owner);
+                        kfree(cii);
+                        soundbus_dev_put(dev);
+                        module_put(THIS_MODULE);
+                        return -EINVAL;
+                }
+                if ((err =
+                     snd_pcm_new_stream(dev->pcm, SNDRV_PCM_STREAM_CAPTURE, 1))) {
+                        module_put(ci->owner);
+                        kfree(cii);
+                        soundbus_dev_put(dev);
+                        module_put(THIS_MODULE);
+                        return err;
+                }
+                snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_CAPTURE,
+                                &i2sbus_record_ops);
+                i2sdev->in.created = 1;
+        }
+
+        /* so we have to register the pcm after adding any substream
+         * to it because alsa doesn't create the devices for the
+         * substreams when we add them later.
+         * Therefore, force in and out on both busses (above) and
+         * register the pcm now instead of just after creating it.
+         */
+        err = snd_device_register(card, dev->pcm);
+        if (err) {
+                printk(KERN_ERR "i2sbus: error registering new pcm\n");
+                module_put(ci->owner);
+                kfree(cii);
+                soundbus_dev_put(dev);
+                module_put(THIS_MODULE);
+                return err;
+        }
+        /* no errors any more, so let's add this to our list */
+        list_add(&cii->list, &dev->codec_list);
+
+        dev->pcm->private_data = i2sdev;
+        dev->pcm->private_free = i2sbus_private_free;
+
+        /* well, we really should support scatter/gather DMA */
+        snd_pcm_lib_preallocate_pages_for_all(
+                dev->pcm, SNDRV_DMA_TYPE_DEV,
+                snd_dma_pci_data(macio_get_pci_dev(i2sdev->macio)),
+                64 * 1024, 64 * 1024);
+
+        return 0;
+}
+
+void i2sbus_detach_codec(struct soundbus_dev *dev, void *data)
+{
+        struct codec_info_item *cii = NULL, *i;
+
+        list_for_each_entry(i, &dev->codec_list, list) {
+                if (i->codec_data == data) {
+                        cii = i;
+                        break;
+                }
+        }
+        if (cii) {
+                list_del(&cii->list);
+                module_put(cii->codec->owner);
+                kfree(cii);
+        }
+        /* no more codecs, but still a pcm? */
+        if (list_empty(&dev->codec_list) && dev->pcm) {
+                /* the actual cleanup is done by the callback above! */
+                snd_device_free(dev->pcm->card, dev->pcm);
+        }
+}
diff --git a/sound/aoa/soundbus/i2sbus/i2sbus.h b/sound/aoa/soundbus/i2sbus/i2sbus.h
new file mode 100644
index 000000000000..cfa5162e3b0f
--- /dev/null
+++ b/sound/aoa/soundbus/i2sbus/i2sbus.h
@@ -0,0 +1,112 @@
+/*
+ * i2sbus driver -- private definitions
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+#ifndef __I2SBUS_H
+#define __I2SBUS_H
+#include <asm/dbdma.h>
+#include <linux/interrupt.h>
+#include <sound/pcm.h>
+#include <linux/spinlock.h>
+#include <linux/mutex.h>
+#include <asm/prom.h>
+#include "i2sbus-interface.h"
+#include "i2sbus-control.h"
+#include "../soundbus.h"
+
+struct i2sbus_control {
+        volatile struct i2s_control_regs __iomem *controlregs;
+        struct resource rsrc;
+        struct list_head list;
+};
+
+#define MAX_DBDMA_COMMANDS      32
+
+struct dbdma_command_mem {
+        dma_addr_t bus_addr;
+        dma_addr_t bus_cmd_start;
+        struct dbdma_cmd *cmds;
+        void *space;
+        int size;
+        u32 running:1;
+};
+
+struct pcm_info {
+        u32 created:1, /* has this direction been created with alsa? */
+            active:1;  /* is this stream active? */
+        /* runtime information */
+        struct snd_pcm_substream *substream;
+        int current_period;
+        u32 frame_count;
+        struct dbdma_command_mem dbdma_ring;
+        volatile struct dbdma_regs __iomem *dbdma;
+};
+
+struct i2sbus_dev {
+        struct soundbus_dev sound;
+        struct macio_dev *macio;
+        struct i2sbus_control *control;
+        volatile struct i2s_interface_regs __iomem *intfregs;
+
+        struct resource resources[3];
+        struct resource *allocated_resource[3];
+        int interrupts[3];
+        char rnames[3][32];
+
+        /* info about currently active substreams */
+        struct pcm_info out, in;
+        snd_pcm_format_t format;
+        unsigned int rate;
+
+        /* list for a single controller */
+        struct list_head item;
+        /* number of bus on controller */
+        int bus_number;
+        /* for use by control layer */
+        struct pmf_function *enable,
+                            *cell_enable,
+                            *cell_disable,
+                            *clock_enable,
+                            *clock_disable;
+
+        /* locks */
+        /* spinlock for low-level interrupt locking */
+        spinlock_t low_lock;
+        /* mutex for high-level consistency */
+        struct mutex lock;
+};
+
+#define soundbus_dev_to_i2sbus_dev(sdev) \
+                container_of(sdev, struct i2sbus_dev, sound)
+
+/* pcm specific functions */
+extern int
+i2sbus_attach_codec(struct soundbus_dev *dev, struct snd_card *card,
+                    struct codec_info *ci, void *data);
+extern void
+i2sbus_detach_codec(struct soundbus_dev *dev, void *data);
+extern irqreturn_t
+i2sbus_tx_intr(int irq, void *devid, struct pt_regs *regs);
+extern irqreturn_t
+i2sbus_rx_intr(int irq, void *devid, struct pt_regs *regs);
+
+/* control specific functions */
+extern int i2sbus_control_init(struct macio_dev* dev,
+                               struct i2sbus_control **c);
+extern void i2sbus_control_destroy(struct i2sbus_control *c);
+extern int i2sbus_control_add_dev(struct i2sbus_control *c,
+                                  struct i2sbus_dev *i2sdev);
+extern void i2sbus_control_remove_dev(struct i2sbus_control *c,
+                                      struct i2sbus_dev *i2sdev);
+extern int i2sbus_control_enable(struct i2sbus_control *c,
+                                 struct i2sbus_dev *i2sdev);
+extern int i2sbus_control_cell(struct i2sbus_control *c,
+                               struct i2sbus_dev *i2sdev,
+                               int enable);
+extern int i2sbus_control_clock(struct i2sbus_control *c,
+                                struct i2sbus_dev *i2sdev,
+                                int enable);
+#endif /* __I2SBUS_H */
diff --git a/sound/aoa/soundbus/soundbus.h b/sound/aoa/soundbus/soundbus.h
new file mode 100644
index 000000000000..5c27297835d7
--- /dev/null
+++ b/sound/aoa/soundbus/soundbus.h
@@ -0,0 +1,202 @@
+/*
+ * soundbus generic definitions
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ *
+ * GPL v2, can be found in COPYING.
+ */
+#ifndef __SOUNDBUS_H
+#define __SOUNDBUS_H
+
+#include <asm/of_device.h>
+#include <sound/pcm.h>
+#include <linux/list.h>
+
+
+/* When switching from master to slave or the other way around,
+ * you don't want to have the codec chip acting as clock source
+ * while the bus still is.
+ * More importantly, while switch from slave to master, you need
+ * to turn off the chip's master function first, but then there's
+ * no clock for a while and other chips might reset, so we notify
+ * their drivers after having switched.
+ * The constants here are codec-point of view, so when we switch
+ * the soundbus to master we tell the codec we're going to switch
+ * and give it CLOCK_SWITCH_PREPARE_SLAVE!
+ */
+enum clock_switch {
+        CLOCK_SWITCH_PREPARE_SLAVE,
+        CLOCK_SWITCH_PREPARE_MASTER,
+        CLOCK_SWITCH_SLAVE,
+        CLOCK_SWITCH_MASTER,
+        CLOCK_SWITCH_NOTIFY,
+};
+
+/* information on a transfer the codec can take */
+struct transfer_info {
+        u64 formats;            /* SNDRV_PCM_FMTBIT_* */
+        unsigned int rates;     /* SNDRV_PCM_RATE_* */
+        /* flags */
+        u32 transfer_in:1, /* input = 1, output = 0 */
+            must_be_clock_source:1;
+        /* for codecs to distinguish among their TIs */
+        int tag;
+};
+
+struct codec_info_item {
+        struct codec_info *codec;
+        void *codec_data;
+        struct soundbus_dev *sdev;
+        /* internal, to be used by the soundbus provider */
+        struct list_head list;
+};
+
+/* for prepare, where the codecs need to know
+ * what we're going to drive the bus with */
+struct bus_info {
+        /* see below */
+        int sysclock_factor;
+        int bus_factor;
+};
+
+/* information on the codec itself, plus function pointers */
+struct codec_info {
+        /* the module this lives in */
+        struct module *owner;
+
+        /* supported transfer possibilities, array terminated by
+         * formats or rates being 0. */
+        struct transfer_info *transfers;
+
+        /* Master clock speed factor
+         * to be used (master clock speed = sysclock_factor * sampling freq)
+         * Unused if the soundbus provider has no such notion.
+         */
+        int sysclock_factor;
+
+        /* Bus factor, bus clock speed = bus_factor * sampling freq)
+         * Unused if the soundbus provider has no such notion.
+         */
+        int bus_factor;
+
+        /* operations */
+        /* clock switching, see above */
+        int (*switch_clock)(struct codec_info_item *cii,
+                            enum clock_switch clock);
+
+        /* called for each transfer_info when the user
+         * opens the pcm device to determine what the
+         * hardware can support at this point in time.
+         * That can depend on other user-switchable controls.
+         * Return 1 if usable, 0 if not.
+         * out points to another instance of a transfer_info
+         * which is initialised to the values in *ti, and
+         * it's format and rate values can be modified by
+         * the callback if it is necessary to further restrict
+         * the formats that can be used at the moment, for
+         * example when one codec has multiple logical codec
+         * info structs for multiple inputs.
+         */
+        int (*usable)(struct codec_info_item *cii,
+                      struct transfer_info *ti,
+                      struct transfer_info *out);
+
+        /* called when pcm stream is opened, probably not implemented
+         * most of the time since it isn't too useful */
+        int (*open)(struct codec_info_item *cii,
+                    struct snd_pcm_substream *substream);
+
+        /* called when the pcm stream is closed, at this point
+         * the user choices can all be unlocked (see below) */
+        int (*close)(struct codec_info_item *cii,
+                     struct snd_pcm_substream *substream);
+
+        /* if the codec must forbid some user choices because
+         * they are not valid with the substream/transfer info,
+         * it must do so here. Example: no digital output for
+         * incompatible framerate, say 8KHz, on Onyx.
+         * If the selected stuff in the substream is NOT
+         * compatible, you have to reject this call! */
+        int (*prepare)(struct codec_info_item *cii,
+                       struct bus_info *bi,
+                       struct snd_pcm_substream *substream);
+
+        /* start() is called before data is pushed to the codec.
+         * Note that start() must be atomic! */
+        int (*start)(struct codec_info_item *cii,
+                     struct snd_pcm_substream *substream);
+
+        /* stop() is called after data is no longer pushed to the codec.
+         * Note that stop() must be atomic! */
+        int (*stop)(struct codec_info_item *cii,
+                    struct snd_pcm_substream *substream);
+
+        int (*suspend)(struct codec_info_item *cii, pm_message_t state);
+        int (*resume)(struct codec_info_item *cii);
+};
+
+/* information on a soundbus device */
+struct soundbus_dev {
+        /* the bus it belongs to */
+        struct list_head onbuslist;
+
+        /* the of device it represents */
+        struct of_device ofdev;
+
+        /* what modules go by */
+        char modalias[32];
+
+        /* These fields must be before attach_codec can be called.
+         * They should be set by the owner of the alsa card object
+         * that is needed, and whoever sets them must make sure
+         * that they are unique within that alsa card object. */
+        char *pcmname;
+        int pcmid;
+
+        /* this is assigned by the soundbus provider in attach_codec */
+        struct snd_pcm *pcm;
+
+        /* operations */
+        /* attach a codec to this soundbus, give the alsa
+         * card object the PCMs for this soundbus should be in.
+         * The 'data' pointer must be unique, it is used as the
+         * key for detach_codec(). */
+        int (*attach_codec)(struct soundbus_dev *dev, struct snd_card *card,
+                            struct codec_info *ci, void *data);
+        void (*detach_codec)(struct soundbus_dev *dev, void *data);
+        /* TODO: suspend/resume */
+
+        /* private for the soundbus provider */
+        struct list_head codec_list;
+        u32 have_out:1, have_in:1;
+};
+#define to_soundbus_device(d) container_of(d, struct soundbus_dev, ofdev.dev)
+#define of_to_soundbus_device(d) container_of(d, struct soundbus_dev, ofdev)
+
+extern int soundbus_add_one(struct soundbus_dev *dev);
+extern void soundbus_remove_one(struct soundbus_dev *dev);
+
+extern struct soundbus_dev *soundbus_dev_get(struct soundbus_dev *dev);
+extern void soundbus_dev_put(struct soundbus_dev *dev);
+
+struct soundbus_driver {
+        char *name;
+        struct module *owner;
+
+        /* we don't implement any matching at all */
+
+        int     (*probe)(struct soundbus_dev* dev);
+        int     (*remove)(struct soundbus_dev* dev);
+
+        int     (*suspend)(struct soundbus_dev* dev, pm_message_t state);
+        int     (*resume)(struct soundbus_dev* dev);
+        int     (*shutdown)(struct soundbus_dev* dev);
+
+        struct device_driver driver;
+};
+#define to_soundbus_driver(drv) container_of(drv,struct soundbus_driver, driver)
+
+extern int soundbus_register_driver(struct soundbus_driver *drv);
+extern void soundbus_unregister_driver(struct soundbus_driver *drv);
+
+#endif /* __SOUNDBUS_H */
diff --git a/sound/aoa/soundbus/sysfs.c b/sound/aoa/soundbus/sysfs.c
new file mode 100644
index 000000000000..d31f8146952a
--- /dev/null
+++ b/sound/aoa/soundbus/sysfs.c
@@ -0,0 +1,43 @@
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/stat.h>
+/* FIX UP */
+#include "soundbus.h"
+
+#define soundbus_config_of_attr(field, format_string)                   \
+static ssize_t                                                          \
+field##_show (struct device *dev, struct device_attribute *attr,        \
+              char *buf)                                                \
+{                                                                       \
+        struct soundbus_dev *mdev = to_soundbus_device (dev);           \
+        return sprintf (buf, format_string, mdev->ofdev.node->field);   \
+}
+
+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;
+        int length;
+
+        if (*sdev->modalias) {
+                strlcpy(buf, sdev->modalias, sizeof(sdev->modalias) + 1);
+                strcat(buf, "\n");
+                length = strlen(buf);
+        } else {
+                length = sprintf(buf, "of:N%sT%s\n",
+                                 of->node->name, of->node->type);
+        }
+
+        return length;
+}
+
+soundbus_config_of_attr (name, "%s\n");
+soundbus_config_of_attr (type, "%s\n");
+
+struct device_attribute soundbus_dev_attrs[] = {
+        __ATTR_RO(name),
+        __ATTR_RO(type),
+        __ATTR_RO(modalias),
+        __ATTR_NULL
+};
diff --git a/sound/arm/sa11xx-uda1341.c b/sound/arm/sa11xx-uda1341.c
index 13057d92f08a..b88fb0c5a68a 100644
--- a/sound/arm/sa11xx-uda1341.c
+++ b/sound/arm/sa11xx-uda1341.c
@@ -112,7 +112,7 @@ MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("SA1100/SA1111 + UDA1341TS driver for ALSA");
 MODULE_SUPPORTED_DEVICE("{{UDA1341,iPAQ H3600 UDA1341TS}}");
 
-static char *id = NULL; /* ID for this card */
+static char *id;        /* ID for this card */
 
 module_param(id, charp, 0444);
 MODULE_PARM_DESC(id, "ID string for SA1100/SA1111 + UDA1341TS soundcard.");
@@ -984,11 +984,15 @@ static int __init sa11xx_uda1341_init(void)
         if ((err = platform_driver_register(&sa11xx_uda1341_driver)) < 0)
                 return err;
         device = platform_device_register_simple(SA11XX_UDA1341_DRIVER, -1, NULL, 0);
-        if (IS_ERR(device)) {
-                platform_driver_unregister(&sa11xx_uda1341_driver);
-                return PTR_ERR(device);
-        }
-        return 0;
+        if (!IS_ERR(device)) {
+                if (platform_get_drvdata(device))
+                        return 0;
+                platform_device_unregister(device);
+                err = -ENODEV
+        } else
+                err = PTR_ERR(device);
+        platform_driver_unregister(&sa11xx_uda1341_driver);
+        return err;
 }
 
 static void __exit sa11xx_uda1341_exit(void)
diff --git a/sound/core/control.c b/sound/core/control.c
index 22565c9b9603..bb397eaa7187 100644
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -176,6 +176,8 @@ void snd_ctl_notify(struct snd_card *card, unsigned int mask,
         read_unlock(&card->ctl_files_rwlock);
 }
 
+EXPORT_SYMBOL(snd_ctl_notify);
+
 /**
  * snd_ctl_new - create a control instance from the template
  * @control: the control template
@@ -204,6 +206,8 @@ struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control, unsigned int acce
         return kctl;
 }
 
+EXPORT_SYMBOL(snd_ctl_new);
+
 /**
  * snd_ctl_new1 - create a control instance from the template
  * @ncontrol: the initialization record
@@ -242,6 +246,8 @@ struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new *ncontrol,
         return snd_ctl_new(&kctl, access);
 }
 
+EXPORT_SYMBOL(snd_ctl_new1);
+
 /**
  * snd_ctl_free_one - release the control instance
  * @kcontrol: the control instance
@@ -259,6 +265,8 @@ void snd_ctl_free_one(struct snd_kcontrol *kcontrol)
         }
 }
 
+EXPORT_SYMBOL(snd_ctl_free_one);
+
 static unsigned int snd_ctl_hole_check(struct snd_card *card,
                                        unsigned int count)
 {
@@ -347,6 +355,8 @@ int snd_ctl_add(struct snd_card *card, struct snd_kcontrol *kcontrol)
         return err;
 }
 
+EXPORT_SYMBOL(snd_ctl_add);
+
 /**
  * snd_ctl_remove - remove the control from the card and release it
  * @card: the card instance
@@ -373,6 +383,8 @@ int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_ctl_remove);
+
 /**
  * snd_ctl_remove_id - remove the control of the given id and release it
  * @card: the card instance
@@ -399,6 +411,8 @@ int snd_ctl_remove_id(struct snd_card *card, struct snd_ctl_elem_id *id)
         return ret;
 }
 
+EXPORT_SYMBOL(snd_ctl_remove_id);
+
 /**
  * snd_ctl_remove_unlocked_id - remove the unlocked control of the given id and release it
  * @file: active control handle
@@ -461,6 +475,8 @@ int snd_ctl_rename_id(struct snd_card *card, struct snd_ctl_elem_id *src_id,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_ctl_rename_id);
+
 /**
  * snd_ctl_find_numid - find the control instance with the given number-id
  * @card: the card instance
@@ -487,6 +503,8 @@ struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numi
         return NULL;
 }
 
+EXPORT_SYMBOL(snd_ctl_find_numid);
+
 /**
  * snd_ctl_find_id - find the control instance with the given id
  * @card: the card instance
@@ -527,6 +545,8 @@ struct snd_kcontrol *snd_ctl_find_id(struct snd_card *card,
         return NULL;
 }
 
+EXPORT_SYMBOL(snd_ctl_find_id);
+
 static int snd_ctl_card_info(struct snd_card *card, struct snd_ctl_file * ctl,
                              unsigned int cmd, void __user *arg)
 {
@@ -704,6 +724,8 @@ int snd_ctl_elem_read(struct snd_card *card, struct snd_ctl_elem_value *control)
         return result;
 }
 
+EXPORT_SYMBOL(snd_ctl_elem_read);
+
 static int snd_ctl_elem_read_user(struct snd_card *card,
                                   struct snd_ctl_elem_value __user *_control)
 {
@@ -767,6 +789,8 @@ int snd_ctl_elem_write(struct snd_card *card, struct snd_ctl_file *file,
         return result;
 }
 
+EXPORT_SYMBOL(snd_ctl_elem_write);
+
 static int snd_ctl_elem_write_user(struct snd_ctl_file *file,
                                    struct snd_ctl_elem_value __user *_control)
 {
@@ -1199,11 +1223,15 @@ int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
         return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
 }
 
+EXPORT_SYMBOL(snd_ctl_register_ioctl);
+
 #ifdef CONFIG_COMPAT
 int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
 {
         return _snd_ctl_register_ioctl(fcn, &snd_control_compat_ioctls);
 }
+
+EXPORT_SYMBOL(snd_ctl_register_ioctl_compat);
 #endif
 
 /*
@@ -1236,12 +1264,15 @@ int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
         return _snd_ctl_unregister_ioctl(fcn, &snd_control_ioctls);
 }
 
+EXPORT_SYMBOL(snd_ctl_unregister_ioctl);
+
 #ifdef CONFIG_COMPAT
 int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
 {
         return _snd_ctl_unregister_ioctl(fcn, &snd_control_compat_ioctls);
 }
 
+EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat);
 #endif
 
 static int snd_ctl_fasync(int fd, struct file * file, int on)
diff --git a/sound/core/device.c b/sound/core/device.c
index b1cf6ec56784..6ce4da4a1081 100644
--- a/sound/core/device.c
+++ b/sound/core/device.c
@@ -63,6 +63,8 @@ int snd_device_new(struct snd_card *card, snd_device_type_t type,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_device_new);
+
 /**
  * snd_device_free - release the device from the card
  * @card: the card instance
@@ -107,6 +109,8 @@ int snd_device_free(struct snd_card *card, void *device_data)
         return -ENXIO;
 }
 
+EXPORT_SYMBOL(snd_device_free);
+
 /**
  * snd_device_disconnect - disconnect the device
  * @card: the card instance
@@ -182,6 +186,8 @@ int snd_device_register(struct snd_card *card, void *device_data)
         return -ENXIO;
 }
 
+EXPORT_SYMBOL(snd_device_register);
+
 /*
  * register all the devices on the card.
  * called from init.c
diff --git a/sound/core/hwdep.c b/sound/core/hwdep.c
index 2524e66eccdd..8bd0dcc93eba 100644
--- a/sound/core/hwdep.c
+++ b/sound/core/hwdep.c
@@ -486,7 +486,6 @@ static void __init snd_hwdep_proc_init(void)
         struct snd_info_entry *entry;
 
         if ((entry = snd_info_create_module_entry(THIS_MODULE, "hwdep", NULL)) != NULL) {
-                entry->c.text.read_size = PAGE_SIZE;
                 entry->c.text.read = snd_hwdep_proc_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
diff --git a/sound/core/info.c b/sound/core/info.c
index 2582b74d3199..10c1772bf3ea 100644
--- a/sound/core/info.c
+++ b/sound/core/info.c
@@ -21,7 +21,6 @@
 
 #include <sound/driver.h>
 #include <linux/init.h>
-#include <linux/vmalloc.h>
 #include <linux/time.h>
 #include <linux/smp_lock.h>
 #include <linux/string.h>
@@ -82,6 +81,24 @@ static int snd_info_version_init(void);
 static int snd_info_version_done(void);
 
 
+/* resize the proc r/w buffer */
+static int resize_info_buffer(struct snd_info_buffer *buffer,
+                              unsigned int nsize)
+{
+        char *nbuf;
+
+        nsize = PAGE_ALIGN(nsize);
+        nbuf = kmalloc(nsize, GFP_KERNEL);
+        if (! nbuf)
+                return -ENOMEM;
+
+        memcpy(nbuf, buffer->buffer, buffer->len);
+        kfree(buffer->buffer);
+        buffer->buffer = nbuf;
+        buffer->len = nsize;
+        return 0;
+}
+
 /**
  * snd_iprintf - printf on the procfs buffer
  * @buffer: the procfs buffer
@@ -95,30 +112,43 @@ int snd_iprintf(struct snd_info_buffer *buffer, char *fmt,...)
 {
         va_list args;
         int len, res;
+        int err = 0;
 
+        might_sleep();
         if (buffer->stop || buffer->error)
                 return 0;
         len = buffer->len - buffer->size;
         va_start(args, fmt);
-        res = vsnprintf(buffer->curr, len, fmt, args);
-        va_end(args);
-        if (res >= len) {
-                buffer->stop = 1;
-                return 0;
+        for (;;) {
+                res = vsnprintf(buffer->buffer + buffer->curr, len, fmt, args);
+                if (res < len)
+                        break;
+                err = resize_info_buffer(buffer, buffer->len + PAGE_SIZE);
+                if (err < 0)
+                        break;
+                len = buffer->len - buffer->size;
         }
+        va_end(args);
+
+        if (err < 0)
+                return err;
         buffer->curr += res;
         buffer->size += res;
         return res;
 }
 
+EXPORT_SYMBOL(snd_iprintf);
+
 /*
 
  */
 
-static struct proc_dir_entry *snd_proc_root = NULL;
-struct snd_info_entry *snd_seq_root = NULL;
+static struct proc_dir_entry *snd_proc_root;
+struct snd_info_entry *snd_seq_root;
+EXPORT_SYMBOL(snd_seq_root);
+
 #ifdef CONFIG_SND_OSSEMUL
-struct snd_info_entry *snd_oss_root = NULL;
+struct snd_info_entry *snd_oss_root;
 #endif
 
 static inline void snd_info_entry_prepare(struct proc_dir_entry *de)
@@ -221,7 +251,7 @@ static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer
         struct snd_info_private_data *data;
         struct snd_info_entry *entry;
         struct snd_info_buffer *buf;
-        size_t size = 0;
+        ssize_t size = 0;
         loff_t pos;
 
         data = file->private_data;
@@ -237,14 +267,20 @@ static ssize_t snd_info_entry_write(struct file *file, const char __user *buffer
                 buf = data->wbuffer;
                 if (buf == NULL)
                         return -EIO;
-                if (pos >= buf->len)
-                        return -ENOMEM;
-                size = buf->len - pos;
-                size = min(count, size);
-                if (copy_from_user(buf->buffer + pos, buffer, size))
+                mutex_lock(&entry->access);
+                if (pos + count >= buf->len) {
+                        if (resize_info_buffer(buf, pos + count)) {
+                                mutex_unlock(&entry->access);
+                                return -ENOMEM;
+                        }
+                }
+                if (copy_from_user(buf->buffer + pos, buffer, count)) {
+                        mutex_unlock(&entry->access);
                         return -EFAULT;
-                if ((long)buf->size < pos + size)
-                        buf->size = pos + size;
+                }
+                buf->size = pos + count;
+                mutex_unlock(&entry->access);
+                size = count;
                 break;
         case SNDRV_INFO_CONTENT_DATA:
                 if (entry->c.ops->write)
@@ -279,18 +315,14 @@ static int snd_info_entry_open(struct inode *inode, struct file *file)
         }
         mode = file->f_flags & O_ACCMODE;
         if (mode == O_RDONLY || mode == O_RDWR) {
-                if ((entry->content == SNDRV_INFO_CONTENT_TEXT &&
-                     !entry->c.text.read_size) ||
-                    (entry->content == SNDRV_INFO_CONTENT_DATA &&
+                if ((entry->content == SNDRV_INFO_CONTENT_DATA &&
                      entry->c.ops->read == NULL)) {
                         err = -ENODEV;
                         goto __error;
                 }
         }
         if (mode == O_WRONLY || mode == O_RDWR) {
-                if ((entry->content == SNDRV_INFO_CONTENT_TEXT &&
-                     !entry->c.text.write_size) ||
-                    (entry->content == SNDRV_INFO_CONTENT_DATA &&
+                if ((entry->content == SNDRV_INFO_CONTENT_DATA &&
                      entry->c.ops->write == NULL)) {
                         err = -ENODEV;
                         goto __error;
@@ -306,49 +338,23 @@ static int snd_info_entry_open(struct inode *inode, struct file *file)
         case SNDRV_INFO_CONTENT_TEXT:
                 if (mode == O_RDONLY || mode == O_RDWR) {
                         buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
-                        if (buffer == NULL) {
-                                kfree(data);
-                                err = -ENOMEM;
-                                goto __error;
-                        }
-                        buffer->len = (entry->c.text.read_size +
-                                      (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
-                        buffer->buffer = vmalloc(buffer->len);
-                        if (buffer->buffer == NULL) {
-                                kfree(buffer);
-                                kfree(data);
-                                err = -ENOMEM;
-                                goto __error;
-                        }
-                        buffer->curr = buffer->buffer;
+                        if (buffer == NULL)
+                                goto __nomem;
                         data->rbuffer = buffer;
+                        buffer->len = PAGE_SIZE;
+                        buffer->buffer = kmalloc(buffer->len, GFP_KERNEL);
+                        if (buffer->buffer == NULL)
+                                goto __nomem;
                 }
                 if (mode == O_WRONLY || mode == O_RDWR) {
                         buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
-                        if (buffer == NULL) {
-                                if (mode == O_RDWR) {
-                                        vfree(data->rbuffer->buffer);
-                                        kfree(data->rbuffer);
-                                }
-                                kfree(data);
-                                err = -ENOMEM;
-                                goto __error;
-                        }
-                        buffer->len = (entry->c.text.write_size +
-                                      (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
-                        buffer->buffer = vmalloc(buffer->len);
-                        if (buffer->buffer == NULL) {
-                                if (mode == O_RDWR) {
-                                        vfree(data->rbuffer->buffer);
-                                        kfree(data->rbuffer);
-                                }
-                                kfree(buffer);
-                                kfree(data);
-                                err = -ENOMEM;
-                                goto __error;
-                        }
-                        buffer->curr = buffer->buffer;
+                        if (buffer == NULL)
+                                goto __nomem;
                         data->wbuffer = buffer;
+                        buffer->len = PAGE_SIZE;
+                        buffer->buffer = kmalloc(buffer->len, GFP_KERNEL);
+                        if (buffer->buffer == NULL)
+                                goto __nomem;
                 }
                 break;
         case SNDRV_INFO_CONTENT_DATA:   /* data */
@@ -373,6 +379,17 @@ static int snd_info_entry_open(struct inode *inode, struct file *file)
         }
         return 0;
 
+ __nomem:
+        if (data->rbuffer) {
+                kfree(data->rbuffer->buffer);
+                kfree(data->rbuffer);
+        }
+        if (data->wbuffer) {
+                kfree(data->wbuffer->buffer);
+                kfree(data->wbuffer);
+        }
+        kfree(data);
+        err = -ENOMEM;
       __error:
         module_put(entry->module);
       __error1:
@@ -391,11 +408,11 @@ static int snd_info_entry_release(struct inode *inode, struct file *file)
         entry = data->entry;
         switch (entry->content) {
         case SNDRV_INFO_CONTENT_TEXT:
-                if (mode == O_RDONLY || mode == O_RDWR) {
-                        vfree(data->rbuffer->buffer);
+                if (data->rbuffer) {
+                        kfree(data->rbuffer->buffer);
                         kfree(data->rbuffer);
                 }
-                if (mode == O_WRONLY || mode == O_RDWR) {
+                if (data->wbuffer) {
                         if (entry->c.text.write) {
                                 entry->c.text.write(entry, data->wbuffer);
                                 if (data->wbuffer->error) {
@@ -404,7 +421,7 @@ static int snd_info_entry_release(struct inode *inode, struct file *file)
                                                 data->wbuffer->error);
                                 }
                         }
-                        vfree(data->wbuffer->buffer);
+                        kfree(data->wbuffer->buffer);
                         kfree(data->wbuffer);
                 }
                 break;
@@ -664,29 +681,29 @@ int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len)
         if (len <= 0 || buffer->stop || buffer->error)
                 return 1;
         while (--len > 0) {
-                c = *buffer->curr++;
+                c = buffer->buffer[buffer->curr++];
                 if (c == '\n') {
-                        if ((buffer->curr - buffer->buffer) >= (long)buffer->size) {
+                        if (buffer->curr >= buffer->size)
                                 buffer->stop = 1;
-                        }
                         break;
                 }
                 *line++ = c;
-                if ((buffer->curr - buffer->buffer) >= (long)buffer->size) {
+                if (buffer->curr >= buffer->size) {
                         buffer->stop = 1;
                         break;
                 }
         }
         while (c != '\n' && !buffer->stop) {
-                c = *buffer->curr++;
-                if ((buffer->curr - buffer->buffer) >= (long)buffer->size) {
+                c = buffer->buffer[buffer->curr++];
+                if (buffer->curr >= buffer->size)
                         buffer->stop = 1;
-                }
         }
         *line = '\0';
         return 0;
 }
 
+EXPORT_SYMBOL(snd_info_get_line);
+
 /**
  * snd_info_get_str - parse a string token
  * @dest: the buffer to store the string token
@@ -723,6 +740,8 @@ char *snd_info_get_str(char *dest, char *src, int len)
         return src;
 }
 
+EXPORT_SYMBOL(snd_info_get_str);
+
 /**
  * snd_info_create_entry - create an info entry
  * @name: the proc file name
@@ -774,6 +793,8 @@ struct snd_info_entry *snd_info_create_module_entry(struct module * module,
         return entry;
 }
 
+EXPORT_SYMBOL(snd_info_create_module_entry);
+
 /**
  * snd_info_create_card_entry - create an info entry for the given card
  * @card: the card instance
@@ -797,6 +818,8 @@ struct snd_info_entry *snd_info_create_card_entry(struct snd_card *card,
         return entry;
 }
 
+EXPORT_SYMBOL(snd_info_create_card_entry);
+
 static int snd_info_dev_free_entry(struct snd_device *device)
 {
         struct snd_info_entry *entry = device->device_data;
@@ -867,6 +890,8 @@ int snd_card_proc_new(struct snd_card *card, const char *name,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_card_proc_new);
+
 /**
  * snd_info_free_entry - release the info entry
  * @entry: the info entry
@@ -883,6 +908,8 @@ void snd_info_free_entry(struct snd_info_entry * entry)
         kfree(entry);
 }
 
+EXPORT_SYMBOL(snd_info_free_entry);
+
 /**
  * snd_info_register - register the info entry
  * @entry: the info entry
@@ -913,6 +940,8 @@ int snd_info_register(struct snd_info_entry * entry)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_info_register);
+
 /**
  * snd_info_unregister - de-register the info entry
  * @entry: the info entry
@@ -937,11 +966,13 @@ int snd_info_unregister(struct snd_info_entry * entry)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_info_unregister);
+
 /*
 
  */
 
-static struct snd_info_entry *snd_info_version_entry = NULL;
+static struct snd_info_entry *snd_info_version_entry;
 
 static void snd_info_version_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 {
@@ -958,7 +989,6 @@ static int __init snd_info_version_init(void)
         entry = snd_info_create_module_entry(THIS_MODULE, "version", NULL);
         if (entry == NULL)
                 return -ENOMEM;
-        entry->c.text.read_size = 256;
         entry->c.text.read = snd_info_version_read;
         if (snd_info_register(entry) < 0) {
                 snd_info_free_entry(entry);
diff --git a/sound/core/info_oss.c b/sound/core/info_oss.c
index f9ce854b3d11..bb2c40d0ab66 100644
--- a/sound/core/info_oss.c
+++ b/sound/core/info_oss.c
@@ -64,6 +64,8 @@ int snd_oss_info_register(int dev, int num, char *string)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_oss_info_register);
+
 extern void snd_card_info_read_oss(struct snd_info_buffer *buffer);
 
 static int snd_sndstat_show_strings(struct snd_info_buffer *buf, char *id, int dev)
@@ -117,7 +119,6 @@ int snd_info_minor_register(void)
 
         memset(snd_sndstat_strings, 0, sizeof(snd_sndstat_strings));
         if ((entry = snd_info_create_module_entry(THIS_MODULE, "sndstat", snd_oss_root)) != NULL) {
-                entry->c.text.read_size = 2048;
                 entry->c.text.read = snd_sndstat_proc_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
diff --git a/sound/core/init.c b/sound/core/init.c
index 39ed2e5bb0af..4d9258884e44 100644
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -38,12 +38,15 @@ struct snd_shutdown_f_ops {
         struct snd_shutdown_f_ops *next;
 };
 
-unsigned int snd_cards_lock = 0;        /* locked for registering/using */
-struct snd_card *snd_cards[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = NULL};
-DEFINE_RWLOCK(snd_card_rwlock);
+static unsigned int snd_cards_lock;     /* locked for registering/using */
+struct snd_card *snd_cards[SNDRV_CARDS];
+EXPORT_SYMBOL(snd_cards);
+
+static DEFINE_MUTEX(snd_card_mutex);
 
 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
 int (*snd_mixer_oss_notify_callback)(struct snd_card *card, int free_flag);
+EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
 #endif
 
 #ifdef CONFIG_PROC_FS
@@ -66,7 +69,6 @@ static inline int init_info_for_card(struct snd_card *card)
                 snd_printd("unable to create card entry\n");
                 return err;
         }
-        entry->c.text.read_size = PAGE_SIZE;
         entry->c.text.read = snd_card_id_read;
         if (snd_info_register(entry) < 0) {
                 snd_info_free_entry(entry);
@@ -110,7 +112,7 @@ struct snd_card *snd_card_new(int idx, const char *xid,
                 strlcpy(card->id, xid, sizeof(card->id));
         }
         err = 0;
-        write_lock(&snd_card_rwlock);
+        mutex_lock(&snd_card_mutex);
         if (idx < 0) {
                 int idx2;
                 for (idx2 = 0; idx2 < SNDRV_CARDS; idx2++)
@@ -128,12 +130,12 @@ struct snd_card *snd_card_new(int idx, const char *xid,
         else
                 err = -ENODEV;
         if (idx < 0 || err < 0) {
-                write_unlock(&snd_card_rwlock);
+                mutex_unlock(&snd_card_mutex);
                 snd_printk(KERN_ERR "cannot find the slot for index %d (range 0-%i)\n", idx, snd_ecards_limit - 1);
                 goto __error;
         }
         snd_cards_lock |= 1 << idx;             /* lock it */
-        write_unlock(&snd_card_rwlock);
+        mutex_unlock(&snd_card_mutex);
         card->number = idx;
         card->module = module;
         INIT_LIST_HEAD(&card->devices);
@@ -169,6 +171,19 @@ struct snd_card *snd_card_new(int idx, const char *xid,
         return NULL;
 }
 
+EXPORT_SYMBOL(snd_card_new);
+
+/* return non-zero if a card is already locked */
+int snd_card_locked(int card)
+{
+        int locked;
+
+        mutex_lock(&snd_card_mutex);
+        locked = snd_cards_lock & (1 << card);
+        mutex_unlock(&snd_card_mutex);
+        return locked;
+}
+
 static loff_t snd_disconnect_llseek(struct file *file, loff_t offset, int orig)
 {
         return -ENODEV;
@@ -236,9 +251,9 @@ int snd_card_disconnect(struct snd_card *card)
         spin_unlock(&card->files_lock);
 
         /* phase 1: disable fops (user space) operations for ALSA API */
-        write_lock(&snd_card_rwlock);
+        mutex_lock(&snd_card_mutex);
         snd_cards[card->number] = NULL;
-        write_unlock(&snd_card_rwlock);
+        mutex_unlock(&snd_card_mutex);
         
         /* phase 2: replace file->f_op with special dummy operations */
         
@@ -298,6 +313,8 @@ int snd_card_disconnect(struct snd_card *card)
         return 0;       
 }
 
+EXPORT_SYMBOL(snd_card_disconnect);
+
 /**
  *  snd_card_free - frees given soundcard structure
  *  @card: soundcard structure
@@ -315,9 +332,9 @@ int snd_card_free(struct snd_card *card)
 
         if (card == NULL)
                 return -EINVAL;
-        write_lock(&snd_card_rwlock);
+        mutex_lock(&snd_card_mutex);
         snd_cards[card->number] = NULL;
-        write_unlock(&snd_card_rwlock);
+        mutex_unlock(&snd_card_mutex);
 
 #ifdef CONFIG_PM
         wake_up(&card->power_sleep);
@@ -353,13 +370,15 @@ int snd_card_free(struct snd_card *card)
                 card->s_f_ops = s_f_ops->next;
                 kfree(s_f_ops);
         }
-        write_lock(&snd_card_rwlock);
+        mutex_lock(&snd_card_mutex);
         snd_cards_lock &= ~(1 << card->number);
-        write_unlock(&snd_card_rwlock);
+        mutex_unlock(&snd_card_mutex);
         kfree(card);
         return 0;
 }
 
+EXPORT_SYMBOL(snd_card_free);
+
 static void snd_card_free_thread(void * __card)
 {
         struct snd_card *card = __card;
@@ -405,6 +424,8 @@ int snd_card_free_in_thread(struct snd_card *card)
         return -EFAULT;
 }
 
+EXPORT_SYMBOL(snd_card_free_in_thread);
+
 static void choose_default_id(struct snd_card *card)
 {
         int i, len, idx_flag = 0, loops = SNDRV_CARDS;
@@ -487,16 +508,16 @@ int snd_card_register(struct snd_card *card)
         snd_assert(card != NULL, return -EINVAL);
         if ((err = snd_device_register_all(card)) < 0)
                 return err;
-        write_lock(&snd_card_rwlock);
+        mutex_lock(&snd_card_mutex);
         if (snd_cards[card->number]) {
                 /* already registered */
-                write_unlock(&snd_card_rwlock);
+                mutex_unlock(&snd_card_mutex);
                 return 0;
         }
         if (card->id[0] == '\0')
                 choose_default_id(card);
         snd_cards[card->number] = card;
-        write_unlock(&snd_card_rwlock);
+        mutex_unlock(&snd_card_mutex);
         init_info_for_card(card);
 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
         if (snd_mixer_oss_notify_callback)
@@ -505,8 +526,10 @@ int snd_card_register(struct snd_card *card)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_card_register);
+
 #ifdef CONFIG_PROC_FS
-static struct snd_info_entry *snd_card_info_entry = NULL;
+static struct snd_info_entry *snd_card_info_entry;
 
 static void snd_card_info_read(struct snd_info_entry *entry,
                                struct snd_info_buffer *buffer)
@@ -515,7 +538,7 @@ static void snd_card_info_read(struct snd_info_entry *entry,
         struct snd_card *card;
 
         for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
-                read_lock(&snd_card_rwlock);
+                mutex_lock(&snd_card_mutex);
                 if ((card = snd_cards[idx]) != NULL) {
                         count++;
                         snd_iprintf(buffer, "%2i [%-15s]: %s - %s\n",
@@ -526,7 +549,7 @@ static void snd_card_info_read(struct snd_info_entry *entry,
                         snd_iprintf(buffer, "                      %s\n",
                                         card->longname);
                 }
-                read_unlock(&snd_card_rwlock);
+                mutex_unlock(&snd_card_mutex);
         }
         if (!count)
                 snd_iprintf(buffer, "--- no soundcards ---\n");
@@ -540,12 +563,12 @@ void snd_card_info_read_oss(struct snd_info_buffer *buffer)
         struct snd_card *card;
 
         for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
-                read_lock(&snd_card_rwlock);
+                mutex_lock(&snd_card_mutex);
                 if ((card = snd_cards[idx]) != NULL) {
                         count++;
                         snd_iprintf(buffer, "%s\n", card->longname);
                 }
-                read_unlock(&snd_card_rwlock);
+                mutex_unlock(&snd_card_mutex);
         }
         if (!count) {
                 snd_iprintf(buffer, "--- no soundcards ---\n");
@@ -563,11 +586,11 @@ static void snd_card_module_info_read(struct snd_info_entry *entry,
         struct snd_card *card;
 
         for (idx = 0; idx < SNDRV_CARDS; idx++) {
-                read_lock(&snd_card_rwlock);
+                mutex_lock(&snd_card_mutex);
                 if ((card = snd_cards[idx]) != NULL)
                         snd_iprintf(buffer, "%2i %s\n",
                                     idx, card->module->name);
-                read_unlock(&snd_card_rwlock);
+                mutex_unlock(&snd_card_mutex);
         }
 }
 #endif
@@ -579,7 +602,6 @@ int __init snd_card_info_init(void)
         entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
         if (! entry)
                 return -ENOMEM;
-        entry->c.text.read_size = PAGE_SIZE;
         entry->c.text.read = snd_card_info_read;
         if (snd_info_register(entry) < 0) {
                 snd_info_free_entry(entry);
@@ -590,7 +612,6 @@ int __init snd_card_info_init(void)
 #ifdef MODULE
         entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
         if (entry) {
-                entry->c.text.read_size = PAGE_SIZE;
                 entry->c.text.read = snd_card_module_info_read;
                 if (snd_info_register(entry) < 0)
                         snd_info_free_entry(entry);
@@ -644,6 +665,8 @@ int snd_component_add(struct snd_card *card, const char *component)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_component_add);
+
 /**
  *  snd_card_file_add - add the file to the file list of the card
  *  @card: soundcard structure
@@ -676,6 +699,8 @@ int snd_card_file_add(struct snd_card *card, struct file *file)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_card_file_add);
+
 /**
  *  snd_card_file_remove - remove the file from the file list
  *  @card: soundcard structure
@@ -717,6 +742,8 @@ int snd_card_file_remove(struct snd_card *card, struct file *file)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_card_file_remove);
+
 #ifdef CONFIG_PM
 /**
  *  snd_power_wait - wait until the power-state is changed.
@@ -753,4 +780,5 @@ int snd_power_wait(struct snd_card *card, unsigned int power_state)
         return result;
 }
 
+EXPORT_SYMBOL(snd_power_wait);
 #endif /* CONFIG_PM */
diff --git a/sound/core/isadma.c b/sound/core/isadma.c
index 1a378951da5b..d52398727f0a 100644
--- a/sound/core/isadma.c
+++ b/sound/core/isadma.c
@@ -56,6 +56,8 @@ void snd_dma_program(unsigned long dma,
         release_dma_lock(flags);
 }
 
+EXPORT_SYMBOL(snd_dma_program);
+
 /**
  * snd_dma_disable - stop the ISA DMA transfer
  * @dma: the dma number
@@ -72,6 +74,8 @@ void snd_dma_disable(unsigned long dma)
         release_dma_lock(flags);
 }
 
+EXPORT_SYMBOL(snd_dma_disable);
+
 /**
  * snd_dma_pointer - return the current pointer to DMA transfer buffer in bytes
  * @dma: the dma number
@@ -101,3 +105,5 @@ unsigned int snd_dma_pointer(unsigned long dma, unsigned int size)
         else
                 return size - result;
 }
+
+EXPORT_SYMBOL(snd_dma_pointer);
diff --git a/sound/core/memory.c b/sound/core/memory.c
index 862d62d2e144..fe59850be868 100644
--- a/sound/core/memory.c
+++ b/sound/core/memory.c
@@ -21,6 +21,7 @@
  */
 
 #include <linux/config.h>
+#include <linux/module.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 
@@ -55,6 +56,8 @@ int copy_to_user_fromio(void __user *dst, const volatile void __iomem *src, size
 #endif
 }
 
+EXPORT_SYMBOL(copy_to_user_fromio);
+
 /**
  * copy_from_user_toio - copy data from user-space to mmio-space
  * @dst: the destination pointer on mmio-space
@@ -85,3 +88,5 @@ int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size
         return 0;
 #endif
 }
+
+EXPORT_SYMBOL(copy_from_user_toio);
diff --git a/sound/core/misc.c b/sound/core/misc.c
index b53e563c09e6..03fc711f4127 100644
--- a/sound/core/misc.c
+++ b/sound/core/misc.c
@@ -34,6 +34,8 @@ void release_and_free_resource(struct resource *res)
         }
 }
 
+EXPORT_SYMBOL(release_and_free_resource);
+
 #ifdef CONFIG_SND_VERBOSE_PRINTK
 void snd_verbose_printk(const char *file, int line, const char *format, ...)
 {
@@ -51,6 +53,8 @@ void snd_verbose_printk(const char *file, int line, const char *format, ...)
         vprintk(format, args);
         va_end(args);
 }
+
+EXPORT_SYMBOL(snd_verbose_printk);
 #endif
 
 #if defined(CONFIG_SND_DEBUG) && defined(CONFIG_SND_VERBOSE_PRINTK)
@@ -71,4 +75,6 @@ void snd_verbose_printd(const char *file, int line, const char *format, ...)
         va_end(args);
 
 }
+
+EXPORT_SYMBOL(snd_verbose_printd);
 #endif
diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index 9c68bc3f97aa..71b5080fa66d 100644
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -1182,9 +1182,7 @@ static void snd_mixer_oss_proc_init(struct snd_mixer_oss *mixer)
                 return;
         entry->content = SNDRV_INFO_CONTENT_TEXT;
         entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-        entry->c.text.read_size = 8192;
         entry->c.text.read = snd_mixer_oss_proc_read;
-        entry->c.text.write_size = 8192;
         entry->c.text.write = snd_mixer_oss_proc_write;
         entry->private_data = mixer;
         if (snd_info_register(entry) < 0) {
diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index ac990bf0b48f..f5ff4f4a16ee 100644
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -45,7 +45,7 @@
 
 #define OSS_ALSAEMULVER         _SIOR ('M', 249, int)
 
-static int dsp_map[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 0};
+static int dsp_map[SNDRV_CARDS];
 static int adsp_map[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 1};
 static int nonblock_open = 1;
 
@@ -78,6 +78,487 @@ static inline void snd_leave_user(mm_segment_t fs)
         set_fs(fs);
 }
 
+/*
+ * helper functions to process hw_params
+ */
+static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int openmin)
+{
+        int changed = 0;
+        if (i->min < min) {
+                i->min = min;
+                i->openmin = openmin;
+                changed = 1;
+        } else if (i->min == min && !i->openmin && openmin) {
+                i->openmin = 1;
+                changed = 1;
+        }
+        if (i->integer) {
+                if (i->openmin) {
+                        i->min++;
+                        i->openmin = 0;
+                }
+        }
+        if (snd_interval_checkempty(i)) {
+                snd_interval_none(i);
+                return -EINVAL;
+        }
+        return changed;
+}
+
+static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int openmax)
+{
+        int changed = 0;
+        if (i->max > max) {
+                i->max = max;
+                i->openmax = openmax;
+                changed = 1;
+        } else if (i->max == max && !i->openmax && openmax) {
+                i->openmax = 1;
+                changed = 1;
+        }
+        if (i->integer) {
+                if (i->openmax) {
+                        i->max--;
+                        i->openmax = 0;
+                }
+        }
+        if (snd_interval_checkempty(i)) {
+                snd_interval_none(i);
+                return -EINVAL;
+        }
+        return changed;
+}
+
+static int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
+{
+        struct snd_interval t;
+        t.empty = 0;
+        t.min = t.max = val;
+        t.openmin = t.openmax = 0;
+        t.integer = 1;
+        return snd_interval_refine(i, &t);
+}
+
+/**
+ * snd_pcm_hw_param_value_min
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Return the minimum value for field PAR.
+ */
+static unsigned int
+snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params,
+                           snd_pcm_hw_param_t var, int *dir)
+{
+        if (hw_is_mask(var)) {
+                if (dir)
+                        *dir = 0;
+                return snd_mask_min(hw_param_mask_c(params, var));
+        }
+        if (hw_is_interval(var)) {
+                const struct snd_interval *i = hw_param_interval_c(params, var);
+                if (dir)
+                        *dir = i->openmin;
+                return snd_interval_min(i);
+        }
+        return -EINVAL;
+}
+
+/**
+ * snd_pcm_hw_param_value_max
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Return the maximum value for field PAR.
+ */
+static unsigned int
+snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
+                           snd_pcm_hw_param_t var, int *dir)
+{
+        if (hw_is_mask(var)) {
+                if (dir)
+                        *dir = 0;
+                return snd_mask_max(hw_param_mask_c(params, var));
+        }
+        if (hw_is_interval(var)) {
+                const struct snd_interval *i = hw_param_interval_c(params, var);
+                if (dir)
+                        *dir = - (int) i->openmax;
+                return snd_interval_max(i);
+        }
+        return -EINVAL;
+}
+
+static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params,
+                                  snd_pcm_hw_param_t var,
+                                  const struct snd_mask *val)
+{
+        int changed;
+        changed = snd_mask_refine(hw_param_mask(params, var), val);
+        if (changed) {
+                params->cmask |= 1 << var;
+                params->rmask |= 1 << var;
+        }
+        return changed;
+}
+
+static int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm,
+                                 struct snd_pcm_hw_params *params,
+                                 snd_pcm_hw_param_t var,
+                                 const struct snd_mask *val)
+{
+        int changed = _snd_pcm_hw_param_mask(params, var, val);
+        if (changed < 0)
+                return changed;
+        if (params->rmask) {
+                int err = snd_pcm_hw_refine(pcm, params);
+                if (err < 0)
+                        return err;
+        }
+        return 0;
+}
+
+static int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params,
+                                 snd_pcm_hw_param_t var, unsigned int val,
+                                 int dir)
+{
+        int changed;
+        int open = 0;
+        if (dir) {
+                if (dir > 0) {
+                        open = 1;
+                } else if (dir < 0) {
+                        if (val > 0) {
+                                open = 1;
+                                val--;
+                        }
+                }
+        }
+        if (hw_is_mask(var))
+                changed = snd_mask_refine_min(hw_param_mask(params, var),
+                                              val + !!open);
+        else if (hw_is_interval(var))
+                changed = snd_interval_refine_min(hw_param_interval(params, var),
+                                                  val, open);
+        else
+                return -EINVAL;
+        if (changed) {
+                params->cmask |= 1 << var;
+                params->rmask |= 1 << var;
+        }
+        return changed;
+}
+
+/**
+ * snd_pcm_hw_param_min
+ * @pcm: PCM instance
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @val: minimal value
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Inside configuration space defined by PARAMS remove from PAR all 
+ * values < VAL. Reduce configuration space accordingly.
+ * Return new minimum or -EINVAL if the configuration space is empty
+ */
+static int snd_pcm_hw_param_min(struct snd_pcm_substream *pcm,
+                                struct snd_pcm_hw_params *params,
+                                snd_pcm_hw_param_t var, unsigned int val,
+                                int *dir)
+{
+        int changed = _snd_pcm_hw_param_min(params, var, val, dir ? *dir : 0);
+        if (changed < 0)
+                return changed;
+        if (params->rmask) {
+                int err = snd_pcm_hw_refine(pcm, params);
+                if (err < 0)
+                        return err;
+        }
+        return snd_pcm_hw_param_value_min(params, var, dir);
+}
+
+static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params,
+                                 snd_pcm_hw_param_t var, unsigned int val,
+                                 int dir)
+{
+        int changed;
+        int open = 0;
+        if (dir) {
+                if (dir < 0) {
+                        open = 1;
+                } else if (dir > 0) {
+                        open = 1;
+                        val++;
+                }
+        }
+        if (hw_is_mask(var)) {
+                if (val == 0 && open) {
+                        snd_mask_none(hw_param_mask(params, var));
+                        changed = -EINVAL;
+                } else
+                        changed = snd_mask_refine_max(hw_param_mask(params, var),
+                                                      val - !!open);
+        } else if (hw_is_interval(var))
+                changed = snd_interval_refine_max(hw_param_interval(params, var),
+                                                  val, open);
+        else
+                return -EINVAL;
+        if (changed) {
+                params->cmask |= 1 << var;
+                params->rmask |= 1 << var;
+        }
+        return changed;
+}
+
+/**
+ * snd_pcm_hw_param_max
+ * @pcm: PCM instance
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @val: maximal value
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Inside configuration space defined by PARAMS remove from PAR all 
+ *  values >= VAL + 1. Reduce configuration space accordingly.
+ *  Return new maximum or -EINVAL if the configuration space is empty
+ */
+static int snd_pcm_hw_param_max(struct snd_pcm_substream *pcm,
+                                struct snd_pcm_hw_params *params,
+                                snd_pcm_hw_param_t var, unsigned int val,
+                                int *dir)
+{
+        int changed = _snd_pcm_hw_param_max(params, var, val, dir ? *dir : 0);
+        if (changed < 0)
+                return changed;
+        if (params->rmask) {
+                int err = snd_pcm_hw_refine(pcm, params);
+                if (err < 0)
+                        return err;
+        }
+        return snd_pcm_hw_param_value_max(params, var, dir);
+}
+
+static int boundary_sub(int a, int adir,
+                        int b, int bdir,
+                        int *c, int *cdir)
+{
+        adir = adir < 0 ? -1 : (adir > 0 ? 1 : 0);
+        bdir = bdir < 0 ? -1 : (bdir > 0 ? 1 : 0);
+        *c = a - b;
+        *cdir = adir - bdir;
+        if (*cdir == -2) {
+                (*c)--;
+        } else if (*cdir == 2) {
+                (*c)++;
+        }
+        return 0;
+}
+
+static int boundary_lt(unsigned int a, int adir,
+                       unsigned int b, int bdir)
+{
+        if (adir < 0) {
+                a--;
+                adir = 1;
+        } else if (adir > 0)
+                adir = 1;
+        if (bdir < 0) {
+                b--;
+                bdir = 1;
+        } else if (bdir > 0)
+                bdir = 1;
+        return a < b || (a == b && adir < bdir);
+}
+
+/* Return 1 if min is nearer to best than max */
+static int boundary_nearer(int min, int mindir,
+                           int best, int bestdir,
+                           int max, int maxdir)
+{
+        int dmin, dmindir;
+        int dmax, dmaxdir;
+        boundary_sub(best, bestdir, min, mindir, &dmin, &dmindir);
+        boundary_sub(max, maxdir, best, bestdir, &dmax, &dmaxdir);
+        return boundary_lt(dmin, dmindir, dmax, dmaxdir);
+}
+
+/**
+ * snd_pcm_hw_param_near
+ * @pcm: PCM instance
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @best: value to set
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Inside configuration space defined by PARAMS set PAR to the available value
+ * nearest to VAL. Reduce configuration space accordingly.
+ * This function cannot be called for SNDRV_PCM_HW_PARAM_ACCESS,
+ * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT.
+ * Return the value found.
+  */
+static int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm,
+                                 struct snd_pcm_hw_params *params,
+                                 snd_pcm_hw_param_t var, unsigned int best,
+                                 int *dir)
+{
+        struct snd_pcm_hw_params *save = NULL;
+        int v;
+        unsigned int saved_min;
+        int last = 0;
+        int min, max;
+        int mindir, maxdir;
+        int valdir = dir ? *dir : 0;
+        /* FIXME */
+        if (best > INT_MAX)
+                best = INT_MAX;
+        min = max = best;
+        mindir = maxdir = valdir;
+        if (maxdir > 0)
+                maxdir = 0;
+        else if (maxdir == 0)
+                maxdir = -1;
+        else {
+                maxdir = 1;
+                max--;
+        }
+        save = kmalloc(sizeof(*save), GFP_KERNEL);
+        if (save == NULL)
+                return -ENOMEM;
+        *save = *params;
+        saved_min = min;
+        min = snd_pcm_hw_param_min(pcm, params, var, min, &mindir);
+        if (min >= 0) {
+                struct snd_pcm_hw_params *params1;
+                if (max < 0)
+                        goto _end;
+                if ((unsigned int)min == saved_min && mindir == valdir)
+                        goto _end;
+                params1 = kmalloc(sizeof(*params1), GFP_KERNEL);
+                if (params1 == NULL) {
+                        kfree(save);
+                        return -ENOMEM;
+                }
+                *params1 = *save;
+                max = snd_pcm_hw_param_max(pcm, params1, var, max, &maxdir);
+                if (max < 0) {
+                        kfree(params1);
+                        goto _end;
+                }
+                if (boundary_nearer(max, maxdir, best, valdir, min, mindir)) {
+                        *params = *params1;
+                        last = 1;
+                }
+                kfree(params1);
+        } else {
+                *params = *save;
+                max = snd_pcm_hw_param_max(pcm, params, var, max, &maxdir);
+                snd_assert(max >= 0, return -EINVAL);
+                last = 1;
+        }
+ _end:
+        kfree(save);
+        if (last)
+                v = snd_pcm_hw_param_last(pcm, params, var, dir);
+        else
+                v = snd_pcm_hw_param_first(pcm, params, var, dir);
+        snd_assert(v >= 0, return -EINVAL);
+        return v;
+}
+
+static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
+                                 snd_pcm_hw_param_t var, unsigned int val,
+                                 int dir)
+{
+        int changed;
+        if (hw_is_mask(var)) {
+                struct snd_mask *m = hw_param_mask(params, var);
+                if (val == 0 && dir < 0) {
+                        changed = -EINVAL;
+                        snd_mask_none(m);
+                } else {
+                        if (dir > 0)
+                                val++;
+                        else if (dir < 0)
+                                val--;
+                        changed = snd_mask_refine_set(hw_param_mask(params, var), val);
+                }
+        } else if (hw_is_interval(var)) {
+                struct snd_interval *i = hw_param_interval(params, var);
+                if (val == 0 && dir < 0) {
+                        changed = -EINVAL;
+                        snd_interval_none(i);
+                } else if (dir == 0)
+                        changed = snd_interval_refine_set(i, val);
+                else {
+                        struct snd_interval t;
+                        t.openmin = 1;
+                        t.openmax = 1;
+                        t.empty = 0;
+                        t.integer = 0;
+                        if (dir < 0) {
+                                t.min = val - 1;
+                                t.max = val;
+                        } else {
+                                t.min = val;
+                                t.max = val+1;
+                        }
+                        changed = snd_interval_refine(i, &t);
+                }
+        } else
+                return -EINVAL;
+        if (changed) {
+                params->cmask |= 1 << var;
+                params->rmask |= 1 << var;
+        }
+        return changed;
+}
+
+/**
+ * snd_pcm_hw_param_set
+ * @pcm: PCM instance
+ * @params: the hw_params instance
+ * @var: parameter to retrieve
+ * @val: value to set
+ * @dir: pointer to the direction (-1,0,1) or NULL
+ *
+ * Inside configuration space defined by PARAMS remove from PAR all 
+ * values != VAL. Reduce configuration space accordingly.
+ *  Return VAL or -EINVAL if the configuration space is empty
+ */
+static int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm,
+                                struct snd_pcm_hw_params *params,
+                                snd_pcm_hw_param_t var, unsigned int val,
+                                int dir)
+{
+        int changed = _snd_pcm_hw_param_set(params, var, val, dir);
+        if (changed < 0)
+                return changed;
+        if (params->rmask) {
+                int err = snd_pcm_hw_refine(pcm, params);
+                if (err < 0)
+                        return err;
+        }
+        return snd_pcm_hw_param_value(params, var, NULL);
+}
+
+static int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params,
+                                        snd_pcm_hw_param_t var)
+{
+        int changed;
+        changed = snd_interval_setinteger(hw_param_interval(params, var));
+        if (changed) {
+                params->cmask |= 1 << var;
+                params->rmask |= 1 << var;
+        }
+        return changed;
+}
+        
+/*
+ * plugin
+ */
+
 #ifdef CONFIG_SND_PCM_OSS_PLUGINS
 static int snd_pcm_oss_plugin_clear(struct snd_pcm_substream *substream)
 {
@@ -203,7 +684,7 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream,
         oss_buffer_size = snd_pcm_plug_client_size(substream,
                                                    snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, NULL)) * oss_frame_size;
         oss_buffer_size = 1 << ld2(oss_buffer_size);
-        if (atomic_read(&runtime->mmap_count)) {
+        if (atomic_read(&substream->mmap_count)) {
                 if (oss_buffer_size > runtime->oss.mmap_bytes)
                         oss_buffer_size = runtime->oss.mmap_bytes;
         }
@@ -338,7 +819,7 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
                 goto failure;
         }
 
-        if (atomic_read(&runtime->mmap_count))
+        if (atomic_read(&substream->mmap_count))
                 direct = 1;
         else
                 direct = substream->oss.setup.direct;
@@ -347,7 +828,7 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         _snd_pcm_hw_param_setinteger(sparams, SNDRV_PCM_HW_PARAM_PERIODS);
         _snd_pcm_hw_param_min(sparams, SNDRV_PCM_HW_PARAM_PERIODS, 2, 0);
         snd_mask_none(&mask);
-        if (atomic_read(&runtime->mmap_count))
+        if (atomic_read(&substream->mmap_count))
                 snd_mask_set(&mask, SNDRV_PCM_ACCESS_MMAP_INTERLEAVED);
         else {
                 snd_mask_set(&mask, SNDRV_PCM_ACCESS_RW_INTERLEAVED);
@@ -466,7 +947,8 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         } else {
                 sw_params->start_threshold = runtime->boundary;
         }
-        if (atomic_read(&runtime->mmap_count) || substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+        if (atomic_read(&substream->mmap_count) ||
+            substream->stream == SNDRV_PCM_STREAM_CAPTURE)
                 sw_params->stop_threshold = runtime->boundary;
         else
                 sw_params->stop_threshold = runtime->buffer_size;
@@ -476,7 +958,7 @@ static int snd_pcm_oss_change_params(struct snd_pcm_substream *substream)
         sw_params->avail_min = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
                 1 : runtime->period_size;
         sw_params->xfer_align = 1;
-        if (atomic_read(&runtime->mmap_count) ||
+        if (atomic_read(&substream->mmap_count) ||
             substream->oss.setup.nosilence) {
                 sw_params->silence_threshold = 0;
                 sw_params->silence_size = 0;
@@ -820,7 +1302,7 @@ static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const cha
         ssize_t tmp;
         struct snd_pcm_runtime *runtime = substream->runtime;
 
-        if (atomic_read(&runtime->mmap_count))
+        if (atomic_read(&substream->mmap_count))
                 return -ENXIO;
 
         if ((tmp = snd_pcm_oss_make_ready(substream)) < 0)
@@ -850,7 +1332,7 @@ static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const cha
                                 if (runtime->oss.period_ptr == 0 ||
                                     runtime->oss.period_ptr == runtime->oss.buffer_used)
                                         runtime->oss.buffer_used = 0;
-                                else if ((substream->ffile->f_flags & O_NONBLOCK) != 0)
+                                else if ((substream->f_flags & O_NONBLOCK) != 0)
                                         return xfer > 0 ? xfer : -EAGAIN;
                         }
                 } else {
@@ -863,7 +1345,7 @@ static ssize_t snd_pcm_oss_write1(struct snd_pcm_substream *substream, const cha
                         buf += tmp;
                         bytes -= tmp;
                         xfer += tmp;
-                        if ((substream->ffile->f_flags & O_NONBLOCK) != 0 &&
+                        if ((substream->f_flags & O_NONBLOCK) != 0 &&
                             tmp != runtime->oss.period_bytes)
                                 break;
                 }
@@ -910,7 +1392,7 @@ static ssize_t snd_pcm_oss_read1(struct snd_pcm_substream *substream, char __use
         ssize_t tmp;
         struct snd_pcm_runtime *runtime = substream->runtime;
 
-        if (atomic_read(&runtime->mmap_count))
+        if (atomic_read(&substream->mmap_count))
                 return -ENXIO;
 
         if ((tmp = snd_pcm_oss_make_ready(substream)) < 0)
@@ -1040,7 +1522,7 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
         substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
         if (substream != NULL) {
                 runtime = substream->runtime;
-                if (atomic_read(&runtime->mmap_count))
+                if (atomic_read(&substream->mmap_count))
                         goto __direct;
                 if ((err = snd_pcm_oss_make_ready(substream)) < 0)
                         return err;
@@ -1101,10 +1583,10 @@ static int snd_pcm_oss_sync(struct snd_pcm_oss_file *pcm_oss_file)
                  * finish sync: drain the buffer
                  */
               __direct:
-                saved_f_flags = substream->ffile->f_flags;
-                substream->ffile->f_flags &= ~O_NONBLOCK;
+                saved_f_flags = substream->f_flags;
+                substream->f_flags &= ~O_NONBLOCK;
                 err = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DRAIN, NULL);
-                substream->ffile->f_flags = saved_f_flags;
+                substream->f_flags = saved_f_flags;
                 if (err < 0)
                         return err;
                 runtime->oss.prepare = 1;
@@ -1209,7 +1691,7 @@ static int snd_pcm_oss_get_formats(struct snd_pcm_oss_file *pcm_oss_file)
 
         if ((err = snd_pcm_oss_get_active_substream(pcm_oss_file, &substream)) < 0)
                 return err;
-        if (atomic_read(&substream->runtime->mmap_count))
+        if (atomic_read(&substream->mmap_count))
                 direct = 1;
         else
                 direct = substream->oss.setup.direct;
@@ -1419,7 +1901,7 @@ static int snd_pcm_oss_set_trigger(struct snd_pcm_oss_file *pcm_oss_file, int tr
                 if (trigger & PCM_ENABLE_OUTPUT) {
                         if (runtime->oss.trigger)
                                 goto _skip1;
-                        if (atomic_read(&psubstream->runtime->mmap_count))
+                        if (atomic_read(&psubstream->mmap_count))
                                 snd_pcm_oss_simulate_fill(psubstream, runtime->hw_ptr_interrupt);
                         runtime->oss.trigger = 1;
                         runtime->start_threshold = 1;
@@ -1537,7 +2019,7 @@ static int snd_pcm_oss_get_ptr(struct snd_pcm_oss_file *pcm_oss_file, int stream
         if (err < 0)
                 return err;
         info.ptr = snd_pcm_oss_bytes(substream, runtime->status->hw_ptr % runtime->buffer_size);
-        if (atomic_read(&runtime->mmap_count)) {
+        if (atomic_read(&substream->mmap_count)) {
                 snd_pcm_sframes_t n;
                 n = (delay = runtime->hw_ptr_interrupt) - runtime->oss.prev_hw_ptr_interrupt;
                 if (n < 0)
@@ -1683,9 +2165,9 @@ static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream,
         substream->oss.oss = 1;
         substream->oss.setup = *setup;
         if (setup->nonblock)
-                substream->ffile->f_flags |= O_NONBLOCK;
+                substream->f_flags |= O_NONBLOCK;
         else if (setup->block)
-                substream->ffile->f_flags &= ~O_NONBLOCK;
+                substream->f_flags &= ~O_NONBLOCK;
         runtime = substream->runtime;
         runtime->oss.params = 1;
         runtime->oss.trigger = 1;
@@ -1742,6 +2224,7 @@ static int snd_pcm_oss_open_file(struct file *file,
             (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX))
                 f_mode = FMODE_WRITE;
 
+        file->f_flags &= ~O_APPEND;
         for (idx = 0; idx < 2; idx++) {
                 if (setup[idx].disable)
                         continue;
@@ -2059,6 +2542,7 @@ static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t coun
         substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_CAPTURE];
         if (substream == NULL)
                 return -ENXIO;
+        substream->f_flags = file->f_flags & O_NONBLOCK;
 #ifndef OSS_DEBUG
         return snd_pcm_oss_read1(substream, buf, count);
 #else
@@ -2080,6 +2564,7 @@ static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size
         substream = pcm_oss_file->streams[SNDRV_PCM_STREAM_PLAYBACK];
         if (substream == NULL)
                 return -ENXIO;
+        substream->f_flags = file->f_flags & O_NONBLOCK;
         result = snd_pcm_oss_write1(substream, buf, count);
 #ifdef OSS_DEBUG
         printk("pcm_oss: write %li bytes (wrote %li bytes)\n", (long)count, (long)result);
@@ -2090,7 +2575,7 @@ static ssize_t snd_pcm_oss_write(struct file *file, const char __user *buf, size
 static int snd_pcm_oss_playback_ready(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        if (atomic_read(&runtime->mmap_count))
+        if (atomic_read(&substream->mmap_count))
                 return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt;
         else
                 return snd_pcm_playback_avail(runtime) >= runtime->oss.period_frames;
@@ -2099,7 +2584,7 @@ static int snd_pcm_oss_playback_ready(struct snd_pcm_substream *substream)
 static int snd_pcm_oss_capture_ready(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        if (atomic_read(&runtime->mmap_count))
+        if (atomic_read(&substream->mmap_count))
                 return runtime->oss.prev_hw_ptr_interrupt != runtime->hw_ptr_interrupt;
         else
                 return snd_pcm_capture_avail(runtime) >= runtime->oss.period_frames;
@@ -2342,9 +2827,7 @@ static void snd_pcm_oss_proc_init(struct snd_pcm *pcm)
                 if ((entry = snd_info_create_card_entry(pcm->card, "oss", pstr->proc_root)) != NULL) {
                         entry->content = SNDRV_INFO_CONTENT_TEXT;
                         entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                        entry->c.text.read_size = 8192;
                         entry->c.text.read = snd_pcm_oss_proc_read;
-                        entry->c.text.write_size = 8192;
                         entry->c.text.write = snd_pcm_oss_proc_write;
                         entry->private_data = pstr;
                         if (snd_info_register(entry) < 0) {
diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index 84b00038236d..7581edd7b9ff 100644
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -351,10 +351,8 @@ static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
                 snd_iprintf(buffer, "closed\n");
                 return;
         }
-        snd_pcm_stream_lock_irq(substream);
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
                 snd_iprintf(buffer, "no setup\n");
-                snd_pcm_stream_unlock_irq(substream);
                 return;
         }
         snd_iprintf(buffer, "access: %s\n", snd_pcm_access_name(runtime->access));
@@ -375,7 +373,6 @@ static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry,
                 snd_iprintf(buffer, "OSS period frames: %lu\n", (unsigned long)runtime->oss.period_frames);
         }
 #endif
-        snd_pcm_stream_unlock_irq(substream);
 }
 
 static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
@@ -387,10 +384,8 @@ static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
                 snd_iprintf(buffer, "closed\n");
                 return;
         }
-        snd_pcm_stream_lock_irq(substream);
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN) {
                 snd_iprintf(buffer, "no setup\n");
-                snd_pcm_stream_unlock_irq(substream);
                 return;
         }
         snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode));
@@ -403,7 +398,6 @@ static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry,
         snd_iprintf(buffer, "silence_threshold: %lu\n", runtime->silence_threshold);
         snd_iprintf(buffer, "silence_size: %lu\n", runtime->silence_size);
         snd_iprintf(buffer, "boundary: %lu\n", runtime->boundary);
-        snd_pcm_stream_unlock_irq(substream);
 }
 
 static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry,
@@ -472,7 +466,7 @@ static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
         pstr->proc_root = entry;
 
         if ((entry = snd_info_create_card_entry(pcm->card, "info", pstr->proc_root)) != NULL) {
-                snd_info_set_text_ops(entry, pstr, 256, snd_pcm_stream_proc_info_read);
+                snd_info_set_text_ops(entry, pstr, snd_pcm_stream_proc_info_read);
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
                         entry = NULL;
@@ -483,9 +477,7 @@ static int snd_pcm_stream_proc_init(struct snd_pcm_str *pstr)
 #ifdef CONFIG_SND_PCM_XRUN_DEBUG
         if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug",
                                                 pstr->proc_root)) != NULL) {
-                entry->c.text.read_size = 64;
                 entry->c.text.read = snd_pcm_xrun_debug_read;
-                entry->c.text.write_size = 64;
                 entry->c.text.write = snd_pcm_xrun_debug_write;
                 entry->mode |= S_IWUSR;
                 entry->private_data = pstr;
@@ -537,7 +529,8 @@ static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
         substream->proc_root = entry;
 
         if ((entry = snd_info_create_card_entry(card, "info", substream->proc_root)) != NULL) {
-                snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_info_read);
+                snd_info_set_text_ops(entry, substream,
+                                      snd_pcm_substream_proc_info_read);
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
                         entry = NULL;
@@ -546,7 +539,8 @@ static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
         substream->proc_info_entry = entry;
 
         if ((entry = snd_info_create_card_entry(card, "hw_params", substream->proc_root)) != NULL) {
-                snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_hw_params_read);
+                snd_info_set_text_ops(entry, substream,
+                                      snd_pcm_substream_proc_hw_params_read);
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
                         entry = NULL;
@@ -555,7 +549,8 @@ static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
         substream->proc_hw_params_entry = entry;
 
         if ((entry = snd_info_create_card_entry(card, "sw_params", substream->proc_root)) != NULL) {
-                snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_sw_params_read);
+                snd_info_set_text_ops(entry, substream,
+                                      snd_pcm_substream_proc_sw_params_read);
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
                         entry = NULL;
@@ -564,7 +559,8 @@ static int snd_pcm_substream_proc_init(struct snd_pcm_substream *substream)
         substream->proc_sw_params_entry = entry;
 
         if ((entry = snd_info_create_card_entry(card, "status", substream->proc_root)) != NULL) {
-                snd_info_set_text_ops(entry, substream, 256, snd_pcm_substream_proc_status_read);
+                snd_info_set_text_ops(entry, substream,
+                                      snd_pcm_substream_proc_status_read);
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
                         entry = NULL;
@@ -666,11 +662,14 @@ int snd_pcm_new_stream(struct snd_pcm *pcm, int stream, int substream_count)
                 INIT_LIST_HEAD(&substream->self_group.substreams);
                 list_add_tail(&substream->link_list, &substream->self_group.substreams);
                 spin_lock_init(&substream->timer_lock);
+                atomic_set(&substream->mmap_count, 0);
                 prev = substream;
         }
         return 0;
 }                               
 
+EXPORT_SYMBOL(snd_pcm_new_stream);
+
 /**
  * snd_pcm_new - create a new PCM instance
  * @card: the card instance
@@ -730,6 +729,8 @@ int snd_pcm_new(struct snd_card *card, char *id, int device,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_new);
+
 static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
 {
         struct snd_pcm_substream *substream, *substream_next;
@@ -829,6 +830,26 @@ int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
                 return -EINVAL;
         }
 
+        if (file->f_flags & O_APPEND) {
+                if (prefer_subdevice < 0) {
+                        if (pstr->substream_count > 1)
+                                return -EINVAL; /* must be unique */
+                        substream = pstr->substream;
+                } else {
+                        for (substream = pstr->substream; substream;
+                             substream = substream->next)
+                                if (substream->number == prefer_subdevice)
+                                        break;
+                }
+                if (! substream)
+                        return -ENODEV;
+                if (! SUBSTREAM_BUSY(substream))
+                        return -EBADFD;
+                substream->ref_count++;
+                *rsubstream = substream;
+                return 0;
+        }
+
         if (prefer_subdevice >= 0) {
                 for (substream = pstr->substream; substream; substream = substream->next)
                         if (!SUBSTREAM_BUSY(substream) && substream->number == prefer_subdevice)
@@ -864,7 +885,6 @@ int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
         memset((void*)runtime->control, 0, size);
 
         init_waitqueue_head(&runtime->sleep);
-        atomic_set(&runtime->mmap_count, 0);
         init_timer(&runtime->tick_timer);
         runtime->tick_timer.function = snd_pcm_tick_timer_func;
         runtime->tick_timer.data = (unsigned long) substream;
@@ -873,7 +893,8 @@ int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
 
         substream->runtime = runtime;
         substream->private_data = pcm->private_data;
-        substream->ffile = file;
+        substream->ref_count = 1;
+        substream->f_flags = file->f_flags;
         pstr->substream_opened++;
         *rsubstream = substream;
         return 0;
@@ -882,7 +903,7 @@ int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
 void snd_pcm_detach_substream(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime;
-        substream->file = NULL;
+
         runtime = substream->runtime;
         snd_assert(runtime != NULL, return);
         if (runtime->private_free != NULL)
@@ -1022,6 +1043,8 @@ int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_notify);
+
 #ifdef CONFIG_PROC_FS
 /*
  *  Info interface
@@ -1049,15 +1072,14 @@ static void snd_pcm_proc_read(struct snd_info_entry *entry,
         mutex_unlock(&register_mutex);
 }
 
-static struct snd_info_entry *snd_pcm_proc_entry = NULL;
+static struct snd_info_entry *snd_pcm_proc_entry;
 
 static void snd_pcm_proc_init(void)
 {
         struct snd_info_entry *entry;
 
         if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) {
-                snd_info_set_text_ops(entry, NULL, SNDRV_CARDS * SNDRV_PCM_DEVICES * 128,
-                                      snd_pcm_proc_read);
+                snd_info_set_text_ops(entry, NULL, snd_pcm_proc_read);
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
                         entry = NULL;
@@ -1099,33 +1121,3 @@ static void __exit alsa_pcm_exit(void)
 
 module_init(alsa_pcm_init)
 module_exit(alsa_pcm_exit)
-
-EXPORT_SYMBOL(snd_pcm_new);
-EXPORT_SYMBOL(snd_pcm_new_stream);
-EXPORT_SYMBOL(snd_pcm_notify);
-EXPORT_SYMBOL(snd_pcm_open_substream);
-EXPORT_SYMBOL(snd_pcm_release_substream);
-  /* pcm_native.c */
-EXPORT_SYMBOL(snd_pcm_link_rwlock);
-#ifdef CONFIG_PM
-EXPORT_SYMBOL(snd_pcm_suspend);
-EXPORT_SYMBOL(snd_pcm_suspend_all);
-#endif
-EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
-EXPORT_SYMBOL(snd_pcm_mmap_data);
-#if SNDRV_PCM_INFO_MMAP_IOMEM
-EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
-#endif
- /* pcm_misc.c */
-EXPORT_SYMBOL(snd_pcm_format_signed);
-EXPORT_SYMBOL(snd_pcm_format_unsigned);
-EXPORT_SYMBOL(snd_pcm_format_linear);
-EXPORT_SYMBOL(snd_pcm_format_little_endian);
-EXPORT_SYMBOL(snd_pcm_format_big_endian);
-EXPORT_SYMBOL(snd_pcm_format_width);
-EXPORT_SYMBOL(snd_pcm_format_physical_width);
-EXPORT_SYMBOL(snd_pcm_format_size);
-EXPORT_SYMBOL(snd_pcm_format_silence_64);
-EXPORT_SYMBOL(snd_pcm_format_set_silence);
-EXPORT_SYMBOL(snd_pcm_build_linear_format);
-EXPORT_SYMBOL(snd_pcm_limit_hw_rates);
diff --git a/sound/core/pcm_compat.c b/sound/core/pcm_compat.c
index e5133033de5e..2b8aab6fd6cd 100644
--- a/sound/core/pcm_compat.c
+++ b/sound/core/pcm_compat.c
@@ -497,9 +497,9 @@ static long snd_pcm_ioctl_compat(struct file *file, unsigned int cmd, unsigned l
         case SNDRV_PCM_IOCTL_LINK:
         case SNDRV_PCM_IOCTL_UNLINK:
                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                        return snd_pcm_playback_ioctl1(substream, cmd, argp);
+                        return snd_pcm_playback_ioctl1(file, substream, cmd, argp);
                 else
-                        return snd_pcm_capture_ioctl1(substream, cmd, argp);
+                        return snd_pcm_capture_ioctl1(file, substream, cmd, argp);
         case SNDRV_PCM_IOCTL_HW_REFINE32:
                 return snd_pcm_ioctl_hw_params_compat(substream, 1, argp);
         case SNDRV_PCM_IOCTL_HW_PARAMS32:
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index eedc6cb038bb..0bb142a28539 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -289,6 +289,7 @@ void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops
                 substream->ops = ops;
 }
 
+EXPORT_SYMBOL(snd_pcm_set_ops);
 
 /**
  * snd_pcm_sync - set the PCM sync id
@@ -306,13 +307,12 @@ void snd_pcm_set_sync(struct snd_pcm_substream *substream)
         runtime->sync.id32[3] = -1;
 }
 
+EXPORT_SYMBOL(snd_pcm_set_sync);
+
 /*
  *  Standard ioctl routine
  */
 
-/* Code taken from alsa-lib */
-#define assert(a) snd_assert((a), return -EINVAL)
-
 static inline unsigned int div32(unsigned int a, unsigned int b, 
                                  unsigned int *r)
 {
@@ -369,56 +369,6 @@ static inline unsigned int muldiv32(unsigned int a, unsigned int b,
         return n;
 }
 
-static int snd_interval_refine_min(struct snd_interval *i, unsigned int min, int openmin)
-{
-        int changed = 0;
-        assert(!snd_interval_empty(i));
-        if (i->min < min) {
-                i->min = min;
-                i->openmin = openmin;
-                changed = 1;
-        } else if (i->min == min && !i->openmin && openmin) {
-                i->openmin = 1;
-                changed = 1;
-        }
-        if (i->integer) {
-                if (i->openmin) {
-                        i->min++;
-                        i->openmin = 0;
-                }
-        }
-        if (snd_interval_checkempty(i)) {
-                snd_interval_none(i);
-                return -EINVAL;
-        }
-        return changed;
-}
-
-static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int openmax)
-{
-        int changed = 0;
-        assert(!snd_interval_empty(i));
-        if (i->max > max) {
-                i->max = max;
-                i->openmax = openmax;
-                changed = 1;
-        } else if (i->max == max && !i->openmax && openmax) {
-                i->openmax = 1;
-                changed = 1;
-        }
-        if (i->integer) {
-                if (i->openmax) {
-                        i->max--;
-                        i->openmax = 0;
-                }
-        }
-        if (snd_interval_checkempty(i)) {
-                snd_interval_none(i);
-                return -EINVAL;
-        }
-        return changed;
-}
-
 /**
  * snd_interval_refine - refine the interval value of configurator
  * @i: the interval value to refine
@@ -433,7 +383,7 @@ static int snd_interval_refine_max(struct snd_interval *i, unsigned int max, int
 int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
 {
         int changed = 0;
-        assert(!snd_interval_empty(i));
+        snd_assert(!snd_interval_empty(i), return -EINVAL);
         if (i->min < v->min) {
                 i->min = v->min;
                 i->openmin = v->openmin;
@@ -472,9 +422,11 @@ int snd_interval_refine(struct snd_interval *i, const struct snd_interval *v)
         return changed;
 }
 
+EXPORT_SYMBOL(snd_interval_refine);
+
 static int snd_interval_refine_first(struct snd_interval *i)
 {
-        assert(!snd_interval_empty(i));
+        snd_assert(!snd_interval_empty(i), return -EINVAL);
         if (snd_interval_single(i))
                 return 0;
         i->max = i->min;
@@ -486,7 +438,7 @@ static int snd_interval_refine_first(struct snd_interval *i)
 
 static int snd_interval_refine_last(struct snd_interval *i)
 {
-        assert(!snd_interval_empty(i));
+        snd_assert(!snd_interval_empty(i), return -EINVAL);
         if (snd_interval_single(i))
                 return 0;
         i->min = i->max;
@@ -496,16 +448,6 @@ static int snd_interval_refine_last(struct snd_interval *i)
         return 1;
 }
 
-static int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
-{
-        struct snd_interval t;
-        t.empty = 0;
-        t.min = t.max = val;
-        t.openmin = t.openmax = 0;
-        t.integer = 1;
-        return snd_interval_refine(i, &t);
-}
-
 void snd_interval_mul(const struct snd_interval *a, const struct snd_interval *b, struct snd_interval *c)
 {
         if (a->empty || b->empty) {
@@ -621,7 +563,6 @@ void snd_interval_mulkdiv(const struct snd_interval *a, unsigned int k,
         c->integer = 0;
 }
 
-#undef assert
 /* ---- */
 
 
@@ -727,6 +668,8 @@ int snd_interval_ratnum(struct snd_interval *i,
         return err;
 }
 
+EXPORT_SYMBOL(snd_interval_ratnum);
+
 /**
  * snd_interval_ratden - refine the interval value
  * @i: interval to refine
@@ -877,6 +820,8 @@ int snd_interval_list(struct snd_interval *i, unsigned int count, unsigned int *
         return changed;
 }
 
+EXPORT_SYMBOL(snd_interval_list);
+
 static int snd_interval_step(struct snd_interval *i, unsigned int min, unsigned int step)
 {
         unsigned int n;
@@ -953,6 +898,8 @@ int snd_pcm_hw_rule_add(struct snd_pcm_runtime *runtime, unsigned int cond,
         return 0;
 }                                   
 
+EXPORT_SYMBOL(snd_pcm_hw_rule_add);
+
 /**
  * snd_pcm_hw_constraint_mask
  * @runtime: PCM runtime instance
@@ -1007,6 +954,8 @@ int snd_pcm_hw_constraint_integer(struct snd_pcm_runtime *runtime, snd_pcm_hw_pa
         return snd_interval_setinteger(constrs_interval(constrs, var));
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);
+
 /**
  * snd_pcm_hw_constraint_minmax
  * @runtime: PCM runtime instance
@@ -1028,6 +977,8 @@ int snd_pcm_hw_constraint_minmax(struct snd_pcm_runtime *runtime, snd_pcm_hw_par
         return snd_interval_refine(constrs_interval(constrs, var), &t);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);
+
 static int snd_pcm_hw_rule_list(struct snd_pcm_hw_params *params,
                                 struct snd_pcm_hw_rule *rule)
 {
@@ -1055,6 +1006,8 @@ int snd_pcm_hw_constraint_list(struct snd_pcm_runtime *runtime,
                                    var, -1);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_list);
+
 static int snd_pcm_hw_rule_ratnums(struct snd_pcm_hw_params *params,
                                    struct snd_pcm_hw_rule *rule)
 {
@@ -1087,6 +1040,8 @@ int snd_pcm_hw_constraint_ratnums(struct snd_pcm_runtime *runtime,
                                    var, -1);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);
+
 static int snd_pcm_hw_rule_ratdens(struct snd_pcm_hw_params *params,
                                    struct snd_pcm_hw_rule *rule)
 {
@@ -1118,6 +1073,8 @@ int snd_pcm_hw_constraint_ratdens(struct snd_pcm_runtime *runtime,
                                    var, -1);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);
+
 static int snd_pcm_hw_rule_msbits(struct snd_pcm_hw_params *params,
                                   struct snd_pcm_hw_rule *rule)
 {
@@ -1149,6 +1106,8 @@ int snd_pcm_hw_constraint_msbits(struct snd_pcm_runtime *runtime,
                                     SNDRV_PCM_HW_PARAM_SAMPLE_BITS, -1);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);
+
 static int snd_pcm_hw_rule_step(struct snd_pcm_hw_params *params,
                                 struct snd_pcm_hw_rule *rule)
 {
@@ -1173,6 +1132,8 @@ int snd_pcm_hw_constraint_step(struct snd_pcm_runtime *runtime,
                                    var, -1);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_constraint_step);
+
 static int snd_pcm_hw_rule_pow2(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule)
 {
         static int pow2_sizes[] = {
@@ -1200,11 +1161,7 @@ int snd_pcm_hw_constraint_pow2(struct snd_pcm_runtime *runtime,
                                    var, -1);
 }
 
-/* To use the same code we have in alsa-lib */
-#define assert(i) snd_assert((i), return -EINVAL)
-#ifndef INT_MIN
-#define INT_MIN ((int)((unsigned int)INT_MAX+1))
-#endif
+EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);
 
 static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,
                                   snd_pcm_hw_param_t var)
@@ -1224,18 +1181,6 @@ static void _snd_pcm_hw_param_any(struct snd_pcm_hw_params *params,
         snd_BUG();
 }
 
-#if 0
-/*
- * snd_pcm_hw_param_any
- */
-int snd_pcm_hw_param_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                         snd_pcm_hw_param_t var)
-{
-        _snd_pcm_hw_param_any(params, var);
-        return snd_pcm_hw_refine(pcm, params);
-}
-#endif  /*  0  */
-
 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
 {
         unsigned int k;
@@ -1247,18 +1192,7 @@ void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params)
         params->info = ~0U;
 }
 
-#if 0
-/*
- * snd_pcm_hw_params_any
- *
- * Fill PARAMS with full configuration space boundaries
- */
-int snd_pcm_hw_params_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params)
-{
-        _snd_pcm_hw_params_any(params);
-        return snd_pcm_hw_refine(pcm, params);
-}
-#endif  /*  0  */
+EXPORT_SYMBOL(_snd_pcm_hw_params_any);
 
 /**
  * snd_pcm_hw_param_value
@@ -1269,8 +1203,8 @@ int snd_pcm_hw_params_any(struct snd_pcm_substream *pcm, struct snd_pcm_hw_param
  * Return the value for field PAR if it's fixed in configuration space 
  *  defined by PARAMS. Return -EINVAL otherwise
  */
-static int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
-                                  snd_pcm_hw_param_t var, int *dir)
+int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
+                           snd_pcm_hw_param_t var, int *dir)
 {
         if (hw_is_mask(var)) {
                 const struct snd_mask *mask = hw_param_mask_c(params, var);
@@ -1288,61 +1222,10 @@ static int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
                         *dir = i->openmin;
                 return snd_interval_value(i);
         }
-        assert(0);
-        return -EINVAL;
-}
-
-/**
- * snd_pcm_hw_param_value_min
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Return the minimum value for field PAR.
- */
-unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params,
-                                        snd_pcm_hw_param_t var, int *dir)
-{
-        if (hw_is_mask(var)) {
-                if (dir)
-                        *dir = 0;
-                return snd_mask_min(hw_param_mask_c(params, var));
-        }
-        if (hw_is_interval(var)) {
-                const struct snd_interval *i = hw_param_interval_c(params, var);
-                if (dir)
-                        *dir = i->openmin;
-                return snd_interval_min(i);
-        }
-        assert(0);
         return -EINVAL;
 }
 
-/**
- * snd_pcm_hw_param_value_max
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Return the maximum value for field PAR.
- */
-unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
-                                        snd_pcm_hw_param_t var, int *dir)
-{
-        if (hw_is_mask(var)) {
-                if (dir)
-                        *dir = 0;
-                return snd_mask_max(hw_param_mask_c(params, var));
-        }
-        if (hw_is_interval(var)) {
-                const struct snd_interval *i = hw_param_interval_c(params, var);
-                if (dir)
-                        *dir = - (int) i->openmax;
-                return snd_interval_max(i);
-        }
-        assert(0);
-        return -EINVAL;
-}
+EXPORT_SYMBOL(snd_pcm_hw_param_value);
 
 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
                                 snd_pcm_hw_param_t var)
@@ -1360,42 +1243,7 @@ void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params,
         }
 }
 
-int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params,
-                                 snd_pcm_hw_param_t var)
-{
-        int changed;
-        assert(hw_is_interval(var));
-        changed = snd_interval_setinteger(hw_param_interval(params, var));
-        if (changed) {
-                params->cmask |= 1 << var;
-                params->rmask |= 1 << var;
-        }
-        return changed;
-}
-        
-#if 0
-/*
- * snd_pcm_hw_param_setinteger
- *
- * Inside configuration space defined by PARAMS remove from PAR all 
- * non integer values. Reduce configuration space accordingly.
- * Return -EINVAL if the configuration space is empty
- */
-int snd_pcm_hw_param_setinteger(struct snd_pcm_substream *pcm, 
-                                struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var)
-{
-        int changed = _snd_pcm_hw_param_setinteger(params, var);
-        if (changed < 0)
-                return changed;
-        if (params->rmask) {
-                int err = snd_pcm_hw_refine(pcm, params);
-                if (err < 0)
-                        return err;
-        }
-        return 0;
-}
-#endif  /*  0  */
+EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);
 
 static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
                                    snd_pcm_hw_param_t var)
@@ -1405,10 +1253,8 @@ static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
                 changed = snd_mask_refine_first(hw_param_mask(params, var));
         else if (hw_is_interval(var))
                 changed = snd_interval_refine_first(hw_param_interval(params, var));
-        else {
-                assert(0);
+        else
                 return -EINVAL;
-        }
         if (changed) {
                 params->cmask |= 1 << var;
                 params->rmask |= 1 << var;
@@ -1428,20 +1274,22 @@ static int _snd_pcm_hw_param_first(struct snd_pcm_hw_params *params,
  * values > minimum. Reduce configuration space accordingly.
  * Return the minimum.
  */
-static int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, 
-                                  struct snd_pcm_hw_params *params, 
-                                  snd_pcm_hw_param_t var, int *dir)
+int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, 
+                           struct snd_pcm_hw_params *params, 
+                           snd_pcm_hw_param_t var, int *dir)
 {
         int changed = _snd_pcm_hw_param_first(params, var);
         if (changed < 0)
                 return changed;
         if (params->rmask) {
                 int err = snd_pcm_hw_refine(pcm, params);
-                assert(err >= 0);
+                snd_assert(err >= 0, return err);
         }
         return snd_pcm_hw_param_value(params, var, dir);
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_param_first);
+
 static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
                                   snd_pcm_hw_param_t var)
 {
@@ -1450,10 +1298,8 @@ static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
                 changed = snd_mask_refine_last(hw_param_mask(params, var));
         else if (hw_is_interval(var))
                 changed = snd_interval_refine_last(hw_param_interval(params, var));
-        else {
-                assert(0);
+        else
                 return -EINVAL;
-        }
         if (changed) {
                 params->cmask |= 1 << var;
                 params->rmask |= 1 << var;
@@ -1473,381 +1319,21 @@ static int _snd_pcm_hw_param_last(struct snd_pcm_hw_params *params,
  * values < maximum. Reduce configuration space accordingly.
  * Return the maximum.
  */
-static int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, 
-                                 struct snd_pcm_hw_params *params,
-                                 snd_pcm_hw_param_t var, int *dir)
+int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, 
+                          struct snd_pcm_hw_params *params,
+                          snd_pcm_hw_param_t var, int *dir)
 {
         int changed = _snd_pcm_hw_param_last(params, var);
         if (changed < 0)
                 return changed;
         if (params->rmask) {
                 int err = snd_pcm_hw_refine(pcm, params);
-                assert(err >= 0);
+                snd_assert(err >= 0, return err);
         }
         return snd_pcm_hw_param_value(params, var, dir);
 }
 
-int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params,
-                          snd_pcm_hw_param_t var, unsigned int val, int dir)
-{
-        int changed;
-        int open = 0;
-        if (dir) {
-                if (dir > 0) {
-                        open = 1;
-                } else if (dir < 0) {
-                        if (val > 0) {
-                                open = 1;
-                                val--;
-                        }
-                }
-        }
-        if (hw_is_mask(var))
-                changed = snd_mask_refine_min(hw_param_mask(params, var), val + !!open);
-        else if (hw_is_interval(var))
-                changed = snd_interval_refine_min(hw_param_interval(params, var), val, open);
-        else {
-                assert(0);
-                return -EINVAL;
-        }
-        if (changed) {
-                params->cmask |= 1 << var;
-                params->rmask |= 1 << var;
-        }
-        return changed;
-}
-
-/**
- * snd_pcm_hw_param_min
- * @pcm: PCM instance
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @val: minimal value
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Inside configuration space defined by PARAMS remove from PAR all 
- * values < VAL. Reduce configuration space accordingly.
- * Return new minimum or -EINVAL if the configuration space is empty
- */
-static int snd_pcm_hw_param_min(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var, unsigned int val,
-                                int *dir)
-{
-        int changed = _snd_pcm_hw_param_min(params, var, val, dir ? *dir : 0);
-        if (changed < 0)
-                return changed;
-        if (params->rmask) {
-                int err = snd_pcm_hw_refine(pcm, params);
-                if (err < 0)
-                        return err;
-        }
-        return snd_pcm_hw_param_value_min(params, var, dir);
-}
-
-static int _snd_pcm_hw_param_max(struct snd_pcm_hw_params *params,
-                                 snd_pcm_hw_param_t var, unsigned int val,
-                                 int dir)
-{
-        int changed;
-        int open = 0;
-        if (dir) {
-                if (dir < 0) {
-                        open = 1;
-                } else if (dir > 0) {
-                        open = 1;
-                        val++;
-                }
-        }
-        if (hw_is_mask(var)) {
-                if (val == 0 && open) {
-                        snd_mask_none(hw_param_mask(params, var));
-                        changed = -EINVAL;
-                } else
-                        changed = snd_mask_refine_max(hw_param_mask(params, var), val - !!open);
-        } else if (hw_is_interval(var))
-                changed = snd_interval_refine_max(hw_param_interval(params, var), val, open);
-        else {
-                assert(0);
-                return -EINVAL;
-        }
-        if (changed) {
-                params->cmask |= 1 << var;
-                params->rmask |= 1 << var;
-        }
-        return changed;
-}
-
-/**
- * snd_pcm_hw_param_max
- * @pcm: PCM instance
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @val: maximal value
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Inside configuration space defined by PARAMS remove from PAR all 
- *  values >= VAL + 1. Reduce configuration space accordingly.
- *  Return new maximum or -EINVAL if the configuration space is empty
- */
-static int snd_pcm_hw_param_max(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var, unsigned int val,
-                                int *dir)
-{
-        int changed = _snd_pcm_hw_param_max(params, var, val, dir ? *dir : 0);
-        if (changed < 0)
-                return changed;
-        if (params->rmask) {
-                int err = snd_pcm_hw_refine(pcm, params);
-                if (err < 0)
-                        return err;
-        }
-        return snd_pcm_hw_param_value_max(params, var, dir);
-}
-
-int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
-                          snd_pcm_hw_param_t var, unsigned int val, int dir)
-{
-        int changed;
-        if (hw_is_mask(var)) {
-                struct snd_mask *m = hw_param_mask(params, var);
-                if (val == 0 && dir < 0) {
-                        changed = -EINVAL;
-                        snd_mask_none(m);
-                } else {
-                        if (dir > 0)
-                                val++;
-                        else if (dir < 0)
-                                val--;
-                        changed = snd_mask_refine_set(hw_param_mask(params, var), val);
-                }
-        } else if (hw_is_interval(var)) {
-                struct snd_interval *i = hw_param_interval(params, var);
-                if (val == 0 && dir < 0) {
-                        changed = -EINVAL;
-                        snd_interval_none(i);
-                } else if (dir == 0)
-                        changed = snd_interval_refine_set(i, val);
-                else {
-                        struct snd_interval t;
-                        t.openmin = 1;
-                        t.openmax = 1;
-                        t.empty = 0;
-                        t.integer = 0;
-                        if (dir < 0) {
-                                t.min = val - 1;
-                                t.max = val;
-                        } else {
-                                t.min = val;
-                                t.max = val+1;
-                        }
-                        changed = snd_interval_refine(i, &t);
-                }
-        } else {
-                assert(0);
-                return -EINVAL;
-        }
-        if (changed) {
-                params->cmask |= 1 << var;
-                params->rmask |= 1 << var;
-        }
-        return changed;
-}
-
-/**
- * snd_pcm_hw_param_set
- * @pcm: PCM instance
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @val: value to set
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Inside configuration space defined by PARAMS remove from PAR all 
- * values != VAL. Reduce configuration space accordingly.
- *  Return VAL or -EINVAL if the configuration space is empty
- */
-int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                         snd_pcm_hw_param_t var, unsigned int val, int dir)
-{
-        int changed = _snd_pcm_hw_param_set(params, var, val, dir);
-        if (changed < 0)
-                return changed;
-        if (params->rmask) {
-                int err = snd_pcm_hw_refine(pcm, params);
-                if (err < 0)
-                        return err;
-        }
-        return snd_pcm_hw_param_value(params, var, NULL);
-}
-
-static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params,
-                                  snd_pcm_hw_param_t var, const struct snd_mask *val)
-{
-        int changed;
-        assert(hw_is_mask(var));
-        changed = snd_mask_refine(hw_param_mask(params, var), val);
-        if (changed) {
-                params->cmask |= 1 << var;
-                params->rmask |= 1 << var;
-        }
-        return changed;
-}
-
-/**
- * snd_pcm_hw_param_mask
- * @pcm: PCM instance
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @val: mask to apply
- *
- * Inside configuration space defined by PARAMS remove from PAR all values
- * not contained in MASK. Reduce configuration space accordingly.
- * This function can be called only for SNDRV_PCM_HW_PARAM_ACCESS,
- * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT.
- * Return 0 on success or -EINVAL
- * if the configuration space is empty
- */
-int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                          snd_pcm_hw_param_t var, const struct snd_mask *val)
-{
-        int changed = _snd_pcm_hw_param_mask(params, var, val);
-        if (changed < 0)
-                return changed;
-        if (params->rmask) {
-                int err = snd_pcm_hw_refine(pcm, params);
-                if (err < 0)
-                        return err;
-        }
-        return 0;
-}
-
-static int boundary_sub(int a, int adir,
-                        int b, int bdir,
-                        int *c, int *cdir)
-{
-        adir = adir < 0 ? -1 : (adir > 0 ? 1 : 0);
-        bdir = bdir < 0 ? -1 : (bdir > 0 ? 1 : 0);
-        *c = a - b;
-        *cdir = adir - bdir;
-        if (*cdir == -2) {
-                assert(*c > INT_MIN);
-                (*c)--;
-        } else if (*cdir == 2) {
-                assert(*c < INT_MAX);
-                (*c)++;
-        }
-        return 0;
-}
-
-static int boundary_lt(unsigned int a, int adir,
-                       unsigned int b, int bdir)
-{
-        assert(a > 0 || adir >= 0);
-        assert(b > 0 || bdir >= 0);
-        if (adir < 0) {
-                a--;
-                adir = 1;
-        } else if (adir > 0)
-                adir = 1;
-        if (bdir < 0) {
-                b--;
-                bdir = 1;
-        } else if (bdir > 0)
-                bdir = 1;
-        return a < b || (a == b && adir < bdir);
-}
-
-/* Return 1 if min is nearer to best than max */
-static int boundary_nearer(int min, int mindir,
-                           int best, int bestdir,
-                           int max, int maxdir)
-{
-        int dmin, dmindir;
-        int dmax, dmaxdir;
-        boundary_sub(best, bestdir, min, mindir, &dmin, &dmindir);
-        boundary_sub(max, maxdir, best, bestdir, &dmax, &dmaxdir);
-        return boundary_lt(dmin, dmindir, dmax, dmaxdir);
-}
-
-/**
- * snd_pcm_hw_param_near
- * @pcm: PCM instance
- * @params: the hw_params instance
- * @var: parameter to retrieve
- * @best: value to set
- * @dir: pointer to the direction (-1,0,1) or NULL
- *
- * Inside configuration space defined by PARAMS set PAR to the available value
- * nearest to VAL. Reduce configuration space accordingly.
- * This function cannot be called for SNDRV_PCM_HW_PARAM_ACCESS,
- * SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_SUBFORMAT.
- * Return the value found.
-  */
-int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                          snd_pcm_hw_param_t var, unsigned int best, int *dir)
-{
-        struct snd_pcm_hw_params *save = NULL;
-        int v;
-        unsigned int saved_min;
-        int last = 0;
-        int min, max;
-        int mindir, maxdir;
-        int valdir = dir ? *dir : 0;
-        /* FIXME */
-        if (best > INT_MAX)
-                best = INT_MAX;
-        min = max = best;
-        mindir = maxdir = valdir;
-        if (maxdir > 0)
-                maxdir = 0;
-        else if (maxdir == 0)
-                maxdir = -1;
-        else {
-                maxdir = 1;
-                max--;
-        }
-        save = kmalloc(sizeof(*save), GFP_KERNEL);
-        if (save == NULL)
-                return -ENOMEM;
-        *save = *params;
-        saved_min = min;
-        min = snd_pcm_hw_param_min(pcm, params, var, min, &mindir);
-        if (min >= 0) {
-                struct snd_pcm_hw_params *params1;
-                if (max < 0)
-                        goto _end;
-                if ((unsigned int)min == saved_min && mindir == valdir)
-                        goto _end;
-                params1 = kmalloc(sizeof(*params1), GFP_KERNEL);
-                if (params1 == NULL) {
-                        kfree(save);
-                        return -ENOMEM;
-                }
-                *params1 = *save;
-                max = snd_pcm_hw_param_max(pcm, params1, var, max, &maxdir);
-                if (max < 0) {
-                        kfree(params1);
-                        goto _end;
-                }
-                if (boundary_nearer(max, maxdir, best, valdir, min, mindir)) {
-                        *params = *params1;
-                        last = 1;
-                }
-                kfree(params1);
-        } else {
-                *params = *save;
-                max = snd_pcm_hw_param_max(pcm, params, var, max, &maxdir);
-                assert(max >= 0);
-                last = 1;
-        }
- _end:
-        kfree(save);
-        if (last)
-                v = snd_pcm_hw_param_last(pcm, params, var, dir);
-        else
-                v = snd_pcm_hw_param_first(pcm, params, var, dir);
-        assert(v >= 0);
-        return v;
-}
+EXPORT_SYMBOL(snd_pcm_hw_param_last);
 
 /**
  * snd_pcm_hw_param_choose
@@ -1859,39 +1345,32 @@ int snd_pcm_hw_param_near(struct snd_pcm_substream *pcm, struct snd_pcm_hw_param
  * first access, first format, first subformat, min channels,
  * min rate, min period time, max buffer size, min tick time
  */
-int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params)
-{
-        int err;
-
-        err = snd_pcm_hw_param_first(pcm, params, SNDRV_PCM_HW_PARAM_ACCESS, NULL);
-        assert(err >= 0);
-
-        err = snd_pcm_hw_param_first(pcm, params, SNDRV_PCM_HW_PARAM_FORMAT, NULL);
-        assert(err >= 0);
-
-        err = snd_pcm_hw_param_first(pcm, params, SNDRV_PCM_HW_PARAM_SUBFORMAT, NULL);
-        assert(err >= 0);
-
-        err = snd_pcm_hw_param_first(pcm, params, SNDRV_PCM_HW_PARAM_CHANNELS, NULL);
-        assert(err >= 0);
-
-        err = snd_pcm_hw_param_first(pcm, params, SNDRV_PCM_HW_PARAM_RATE, NULL);
-        assert(err >= 0);
-
-        err = snd_pcm_hw_param_first(pcm, params, SNDRV_PCM_HW_PARAM_PERIOD_TIME, NULL);
-        assert(err >= 0);
-
-        err = snd_pcm_hw_param_last(pcm, params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, NULL);
-        assert(err >= 0);
-
-        err = snd_pcm_hw_param_first(pcm, params, SNDRV_PCM_HW_PARAM_TICK_TIME, NULL);
-        assert(err >= 0);
+int snd_pcm_hw_params_choose(struct snd_pcm_substream *pcm,
+                             struct snd_pcm_hw_params *params)
+{
+        static int vars[] = {
+                SNDRV_PCM_HW_PARAM_ACCESS,
+                SNDRV_PCM_HW_PARAM_FORMAT,
+                SNDRV_PCM_HW_PARAM_SUBFORMAT,
+                SNDRV_PCM_HW_PARAM_CHANNELS,
+                SNDRV_PCM_HW_PARAM_RATE,
+                SNDRV_PCM_HW_PARAM_PERIOD_TIME,
+                SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
+                SNDRV_PCM_HW_PARAM_TICK_TIME,
+                -1
+        };
+        int err, *v;
 
+        for (v = vars; *v != -1; v++) {
+                if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE)
+                        err = snd_pcm_hw_param_first(pcm, params, *v, NULL);
+                else
+                        err = snd_pcm_hw_param_last(pcm, params, *v, NULL);
+                snd_assert(err >= 0, return err);
+        }
         return 0;
 }
 
-#undef assert
-
 static int snd_pcm_lib_ioctl_reset(struct snd_pcm_substream *substream,
                                    void *arg)
 {
@@ -1967,6 +1446,8 @@ int snd_pcm_lib_ioctl(struct snd_pcm_substream *substream,
         return -ENXIO;
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_ioctl);
+
 /*
  *  Conditions
  */
@@ -2101,6 +1582,8 @@ void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
         kill_fasync(&runtime->fasync, SIGIO, POLL_IN);
 }
 
+EXPORT_SYMBOL(snd_pcm_period_elapsed);
+
 static int snd_pcm_lib_write_transfer(struct snd_pcm_substream *substream,
                                       unsigned int hwoff,
                                       unsigned long data, unsigned int off,
@@ -2299,7 +1782,7 @@ snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const v
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
 
-        nonblock = !!(substream->ffile->f_flags & O_NONBLOCK);
+        nonblock = !!(substream->f_flags & O_NONBLOCK);
 
         if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED &&
             runtime->channels > 1)
@@ -2308,6 +1791,8 @@ snd_pcm_sframes_t snd_pcm_lib_write(struct snd_pcm_substream *substream, const v
                                   snd_pcm_lib_write_transfer);
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_write);
+
 static int snd_pcm_lib_writev_transfer(struct snd_pcm_substream *substream,
                                        unsigned int hwoff,
                                        unsigned long data, unsigned int off,
@@ -2362,7 +1847,7 @@ snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
 
-        nonblock = !!(substream->ffile->f_flags & O_NONBLOCK);
+        nonblock = !!(substream->f_flags & O_NONBLOCK);
 
         if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
                 return -EINVAL;
@@ -2370,6 +1855,8 @@ snd_pcm_sframes_t snd_pcm_lib_writev(struct snd_pcm_substream *substream,
                                   nonblock, snd_pcm_lib_writev_transfer);
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_writev);
+
 static int snd_pcm_lib_read_transfer(struct snd_pcm_substream *substream, 
                                      unsigned int hwoff,
                                      unsigned long data, unsigned int off,
@@ -2572,12 +2059,14 @@ snd_pcm_sframes_t snd_pcm_lib_read(struct snd_pcm_substream *substream, void __u
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
 
-        nonblock = !!(substream->ffile->f_flags & O_NONBLOCK);
+        nonblock = !!(substream->f_flags & O_NONBLOCK);
         if (runtime->access != SNDRV_PCM_ACCESS_RW_INTERLEAVED)
                 return -EINVAL;
         return snd_pcm_lib_read1(substream, (unsigned long)buf, size, nonblock, snd_pcm_lib_read_transfer);
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_read);
+
 static int snd_pcm_lib_readv_transfer(struct snd_pcm_substream *substream,
                                       unsigned int hwoff,
                                       unsigned long data, unsigned int off,
@@ -2629,58 +2118,10 @@ snd_pcm_sframes_t snd_pcm_lib_readv(struct snd_pcm_substream *substream,
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
 
-        nonblock = !!(substream->ffile->f_flags & O_NONBLOCK);
+        nonblock = !!(substream->f_flags & O_NONBLOCK);
         if (runtime->access != SNDRV_PCM_ACCESS_RW_NONINTERLEAVED)
                 return -EINVAL;
         return snd_pcm_lib_read1(substream, (unsigned long)bufs, frames, nonblock, snd_pcm_lib_readv_transfer);
 }
 
-/*
- *  Exported symbols
- */
-
-EXPORT_SYMBOL(snd_interval_refine);
-EXPORT_SYMBOL(snd_interval_list);
-EXPORT_SYMBOL(snd_interval_ratnum);
-EXPORT_SYMBOL(_snd_pcm_hw_params_any);
-EXPORT_SYMBOL(_snd_pcm_hw_param_min);
-EXPORT_SYMBOL(_snd_pcm_hw_param_set);
-EXPORT_SYMBOL(_snd_pcm_hw_param_setempty);
-EXPORT_SYMBOL(_snd_pcm_hw_param_setinteger);
-EXPORT_SYMBOL(snd_pcm_hw_param_value_min);
-EXPORT_SYMBOL(snd_pcm_hw_param_value_max);
-EXPORT_SYMBOL(snd_pcm_hw_param_mask);
-EXPORT_SYMBOL(snd_pcm_hw_param_first);
-EXPORT_SYMBOL(snd_pcm_hw_param_last);
-EXPORT_SYMBOL(snd_pcm_hw_param_near);
-EXPORT_SYMBOL(snd_pcm_hw_param_set);
-EXPORT_SYMBOL(snd_pcm_hw_refine);
-EXPORT_SYMBOL(snd_pcm_hw_constraints_init);
-EXPORT_SYMBOL(snd_pcm_hw_constraints_complete);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_list);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_step);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_ratnums);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_ratdens);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_msbits);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_minmax);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_integer);
-EXPORT_SYMBOL(snd_pcm_hw_constraint_pow2);
-EXPORT_SYMBOL(snd_pcm_hw_rule_add);
-EXPORT_SYMBOL(snd_pcm_set_ops);
-EXPORT_SYMBOL(snd_pcm_set_sync);
-EXPORT_SYMBOL(snd_pcm_lib_ioctl);
-EXPORT_SYMBOL(snd_pcm_stop);
-EXPORT_SYMBOL(snd_pcm_period_elapsed);
-EXPORT_SYMBOL(snd_pcm_lib_write);
-EXPORT_SYMBOL(snd_pcm_lib_read);
-EXPORT_SYMBOL(snd_pcm_lib_writev);
 EXPORT_SYMBOL(snd_pcm_lib_readv);
-EXPORT_SYMBOL(snd_pcm_lib_buffer_bytes);
-EXPORT_SYMBOL(snd_pcm_lib_period_bytes);
-/* pcm_memory.c */
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_free_for_all);
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages);
-EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages_for_all);
-EXPORT_SYMBOL(snd_pcm_sgbuf_ops_page);
-EXPORT_SYMBOL(snd_pcm_lib_malloc_pages);
-EXPORT_SYMBOL(snd_pcm_lib_free_pages);
diff --git a/sound/core/pcm_memory.c b/sound/core/pcm_memory.c
index 428f8c169ee1..067d2056db9a 100644
--- a/sound/core/pcm_memory.c
+++ b/sound/core/pcm_memory.c
@@ -126,6 +126,8 @@ int snd_pcm_lib_preallocate_free_for_all(struct snd_pcm *pcm)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_preallocate_free_for_all);
+
 #ifdef CONFIG_SND_VERBOSE_PROCFS
 /*
  * read callback for prealloc proc file
@@ -191,9 +193,7 @@ static inline void preallocate_info_init(struct snd_pcm_substream *substream)
         struct snd_info_entry *entry;
 
         if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc", substream->proc_root)) != NULL) {
-                entry->c.text.read_size = 64;
                 entry->c.text.read = snd_pcm_lib_preallocate_proc_read;
-                entry->c.text.write_size = 64;
                 entry->c.text.write = snd_pcm_lib_preallocate_proc_write;
                 entry->mode |= S_IWUSR;
                 entry->private_data = substream;
@@ -253,6 +253,8 @@ int snd_pcm_lib_preallocate_pages(struct snd_pcm_substream *substream,
         return snd_pcm_lib_preallocate_pages1(substream, size, max);
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages);
+
 /**
  * snd_pcm_lib_preallocate_pages_for_all - pre-allocation for continous memory type (all substreams)
  * @pcm: the pcm instance
@@ -280,6 +282,8 @@ int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_preallocate_pages_for_all);
+
 /**
  * snd_pcm_sgbuf_ops_page - get the page struct at the given offset
  * @substream: the pcm substream instance
@@ -298,6 +302,8 @@ struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigne
         return sgbuf->page_table[idx];
 }
 
+EXPORT_SYMBOL(snd_pcm_sgbuf_ops_page);
+
 /**
  * snd_pcm_lib_malloc_pages - allocate the DMA buffer
  * @substream: the substream to allocate the DMA buffer to
@@ -349,6 +355,8 @@ int snd_pcm_lib_malloc_pages(struct snd_pcm_substream *substream, size_t size)
         return 1;                       /* area was changed */
 }
 
+EXPORT_SYMBOL(snd_pcm_lib_malloc_pages);
+
 /**
  * snd_pcm_lib_free_pages - release the allocated DMA buffer.
  * @substream: the substream to release the DMA buffer
@@ -374,3 +382,5 @@ int snd_pcm_lib_free_pages(struct snd_pcm_substream *substream)
         snd_pcm_set_runtime_buffer(substream, NULL);
         return 0;
 }
+
+EXPORT_SYMBOL(snd_pcm_lib_free_pages);
diff --git a/sound/core/pcm_misc.c b/sound/core/pcm_misc.c
index 593c77f4d181..0019c59a779d 100644
--- a/sound/core/pcm_misc.c
+++ b/sound/core/pcm_misc.c
@@ -207,6 +207,8 @@ int snd_pcm_format_signed(snd_pcm_format_t format)
         return val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_signed);
+
 /**
  * snd_pcm_format_unsigned - Check the PCM format is unsigned linear
  * @format: the format to check
@@ -224,6 +226,8 @@ int snd_pcm_format_unsigned(snd_pcm_format_t format)
         return !val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_unsigned);
+
 /**
  * snd_pcm_format_linear - Check the PCM format is linear
  * @format: the format to check
@@ -235,6 +239,8 @@ int snd_pcm_format_linear(snd_pcm_format_t format)
         return snd_pcm_format_signed(format) >= 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_linear);
+
 /**
  * snd_pcm_format_little_endian - Check the PCM format is little-endian
  * @format: the format to check
@@ -252,6 +258,8 @@ int snd_pcm_format_little_endian(snd_pcm_format_t format)
         return val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_little_endian);
+
 /**
  * snd_pcm_format_big_endian - Check the PCM format is big-endian
  * @format: the format to check
@@ -269,6 +277,8 @@ int snd_pcm_format_big_endian(snd_pcm_format_t format)
         return !val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_big_endian);
+
 /**
  * snd_pcm_format_width - return the bit-width of the format
  * @format: the format to check
@@ -286,6 +296,8 @@ int snd_pcm_format_width(snd_pcm_format_t format)
         return val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_width);
+
 /**
  * snd_pcm_format_physical_width - return the physical bit-width of the format
  * @format: the format to check
@@ -303,6 +315,8 @@ int snd_pcm_format_physical_width(snd_pcm_format_t format)
         return val;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_physical_width);
+
 /**
  * snd_pcm_format_size - return the byte size of samples on the given format
  * @format: the format to check
@@ -318,6 +332,8 @@ ssize_t snd_pcm_format_size(snd_pcm_format_t format, size_t samples)
         return samples * phys_width / 8;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_size);
+
 /**
  * snd_pcm_format_silence_64 - return the silent data in 8 bytes array
  * @format: the format to check
@@ -333,6 +349,8 @@ const unsigned char *snd_pcm_format_silence_64(snd_pcm_format_t format)
         return pcm_formats[format].silence;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_silence_64);
+
 /**
  * snd_pcm_format_set_silence - set the silence data on the buffer
  * @format: the PCM format
@@ -402,6 +420,8 @@ int snd_pcm_format_set_silence(snd_pcm_format_t format, void *data, unsigned int
         return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_format_set_silence);
+
 /* [width][unsigned][bigendian] */
 static int linear_formats[4][2][2] = {
         {{ SNDRV_PCM_FORMAT_S8, SNDRV_PCM_FORMAT_S8},
@@ -432,6 +452,8 @@ snd_pcm_format_t snd_pcm_build_linear_format(int width, int unsignd, int big_end
         return linear_formats[width][!!unsignd][!!big_endian];
 }
 
+EXPORT_SYMBOL(snd_pcm_build_linear_format);
+
 /**
  * snd_pcm_limit_hw_rates - determine rate_min/rate_max fields
  * @runtime: the runtime instance
@@ -463,3 +485,5 @@ int snd_pcm_limit_hw_rates(struct snd_pcm_runtime *runtime)
         }
         return 0;
 }
+
+EXPORT_SYMBOL(snd_pcm_limit_hw_rates);
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 0860c5a84502..439f047929e1 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -71,8 +71,9 @@ static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream);
  */
 
 DEFINE_RWLOCK(snd_pcm_link_rwlock);
-static DECLARE_RWSEM(snd_pcm_link_rwsem);
+EXPORT_SYMBOL(snd_pcm_link_rwlock);
 
+static DECLARE_RWSEM(snd_pcm_link_rwsem);
 
 static inline mm_segment_t snd_enter_user(void)
 {
@@ -319,6 +320,8 @@ int snd_pcm_hw_refine(struct snd_pcm_substream *substream,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_hw_refine);
+
 static int snd_pcm_hw_refine_user(struct snd_pcm_substream *substream,
                                   struct snd_pcm_hw_params __user * _params)
 {
@@ -369,7 +372,7 @@ static int snd_pcm_hw_params(struct snd_pcm_substream *substream,
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
         if (!substream->oss.oss)
 #endif
-                if (atomic_read(&runtime->mmap_count))
+                if (atomic_read(&substream->mmap_count))
                         return -EBADFD;
 
         params->rmask = ~0U;
@@ -482,7 +485,7 @@ static int snd_pcm_hw_free(struct snd_pcm_substream *substream)
                 return -EBADFD;
         }
         snd_pcm_stream_unlock_irq(substream);
-        if (atomic_read(&runtime->mmap_count))
+        if (atomic_read(&substream->mmap_count))
                 return -EBADFD;
         if (substream->ops->hw_free)
                 result = substream->ops->hw_free(substream);
@@ -936,6 +939,8 @@ int snd_pcm_stop(struct snd_pcm_substream *substream, int state)
         return snd_pcm_action(&snd_pcm_action_stop, substream, state);
 }
 
+EXPORT_SYMBOL(snd_pcm_stop);
+
 /**
  * snd_pcm_drain_done
  * @substream: the PCM substream
@@ -1085,6 +1090,8 @@ int snd_pcm_suspend(struct snd_pcm_substream *substream)
         return err;
 }
 
+EXPORT_SYMBOL(snd_pcm_suspend);
+
 /**
  * snd_pcm_suspend_all
  * @pcm: the PCM instance
@@ -1114,6 +1121,8 @@ int snd_pcm_suspend_all(struct snd_pcm *pcm)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_pcm_suspend_all);
+
 /* resume */
 
 static int snd_pcm_pre_resume(struct snd_pcm_substream *substream, int state)
@@ -1275,13 +1284,16 @@ static int snd_pcm_reset(struct snd_pcm_substream *substream)
 /*
  * prepare ioctl
  */
-static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream, int state)
+/* we use the second argument for updating f_flags */
+static int snd_pcm_pre_prepare(struct snd_pcm_substream *substream,
+                               int f_flags)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
                 return -EBADFD;
         if (snd_pcm_running(substream))
                 return -EBUSY;
+        substream->f_flags = f_flags;
         return 0;
 }
 
@@ -1310,17 +1322,26 @@ static struct action_ops snd_pcm_action_prepare = {
 /**
  * snd_pcm_prepare
  * @substream: the PCM substream instance
+ * @file: file to refer f_flags
  *
  * Prepare the PCM substream to be triggerable.
  */
-static int snd_pcm_prepare(struct snd_pcm_substream *substream)
+static int snd_pcm_prepare(struct snd_pcm_substream *substream,
+                           struct file *file)
 {
         int res;
         struct snd_card *card = substream->pcm->card;
+        int f_flags;
+
+        if (file)
+                f_flags = file->f_flags;
+        else
+                f_flags = substream->f_flags;
 
         snd_power_lock(card);
         if ((res = snd_power_wait(card, SNDRV_CTL_POWER_D0)) >= 0)
-                res = snd_pcm_action_nonatomic(&snd_pcm_action_prepare, substream, 0);
+                res = snd_pcm_action_nonatomic(&snd_pcm_action_prepare,
+                                               substream, f_flags);
         snd_power_unlock(card);
         return res;
 }
@@ -1331,7 +1352,7 @@ static int snd_pcm_prepare(struct snd_pcm_substream *substream)
 
 static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state)
 {
-        if (substream->ffile->f_flags & O_NONBLOCK)
+        if (substream->f_flags & O_NONBLOCK)
                 return -EAGAIN;
         substream->runtime->trigger_master = substream;
         return 0;
@@ -1448,8 +1469,6 @@ static int snd_pcm_drain(struct snd_pcm_substream *substream)
                 }
         }
         up_read(&snd_pcm_link_rwsem);
-        if (! num_drecs)
-                goto _error;
 
         snd_pcm_stream_lock_irq(substream);
         /* resume pause */
@@ -2006,6 +2025,10 @@ static void pcm_release_private(struct snd_pcm_substream *substream)
 
 void snd_pcm_release_substream(struct snd_pcm_substream *substream)
 {
+        substream->ref_count--;
+        if (substream->ref_count > 0)
+                return;
+
         snd_pcm_drop(substream);
         if (substream->hw_opened) {
                 if (substream->ops->hw_free != NULL)
@@ -2020,6 +2043,8 @@ void snd_pcm_release_substream(struct snd_pcm_substream *substream)
         snd_pcm_detach_substream(substream);
 }
 
+EXPORT_SYMBOL(snd_pcm_release_substream);
+
 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
                            struct file *file,
                            struct snd_pcm_substream **rsubstream)
@@ -2030,6 +2055,11 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
         err = snd_pcm_attach_substream(pcm, stream, file, &substream);
         if (err < 0)
                 return err;
+        if (substream->ref_count > 1) {
+                *rsubstream = substream;
+                return 0;
+        }
+
         substream->no_mmap_ctrl = 0;
         err = snd_pcm_hw_constraints_init(substream);
         if (err < 0) {
@@ -2056,6 +2086,8 @@ int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
         return err;
 }
 
+EXPORT_SYMBOL(snd_pcm_open_substream);
+
 static int snd_pcm_open_file(struct file *file,
                              struct snd_pcm *pcm,
                              int stream,
@@ -2073,17 +2105,20 @@ static int snd_pcm_open_file(struct file *file,
         if (err < 0)
                 return err;
 
-        pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL);
-        if (pcm_file == NULL) {
-                snd_pcm_release_substream(substream);
-                return -ENOMEM;
+        if (substream->ref_count > 1)
+                pcm_file = substream->file;
+        else {
+                pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL);
+                if (pcm_file == NULL) {
+                        snd_pcm_release_substream(substream);
+                        return -ENOMEM;
+                }
+                str = substream->pstr;
+                substream->file = pcm_file;
+                substream->pcm_release = pcm_release_private;
+                pcm_file->substream = substream;
+                snd_pcm_add_file(str, pcm_file);
         }
-        str = substream->pstr;
-        substream->file = pcm_file;
-        substream->pcm_release = pcm_release_private;
-        pcm_file->substream = substream;
-        snd_pcm_add_file(str, pcm_file);
-
         file->private_data = pcm_file;
         *rpcm_file = pcm_file;
         return 0;
@@ -2170,7 +2205,6 @@ static int snd_pcm_release(struct inode *inode, struct file *file)
         pcm_file = file->private_data;
         substream = pcm_file->substream;
         snd_assert(substream != NULL, return -ENXIO);
-        snd_assert(!atomic_read(&substream->runtime->mmap_count), );
         pcm = substream->pcm;
         fasync_helper(-1, file, 0, &substream->runtime->fasync);
         mutex_lock(&pcm->open_mutex);
@@ -2493,7 +2527,8 @@ static int snd_pcm_sync_ptr(struct snd_pcm_substream *substream,
         return 0;
 }
                 
-static int snd_pcm_common_ioctl1(struct snd_pcm_substream *substream,
+static int snd_pcm_common_ioctl1(struct file *file,
+                                 struct snd_pcm_substream *substream,
                                  unsigned int cmd, void __user *arg)
 {
         snd_assert(substream != NULL, return -ENXIO);
@@ -2518,7 +2553,7 @@ static int snd_pcm_common_ioctl1(struct snd_pcm_substream *substream,
         case SNDRV_PCM_IOCTL_CHANNEL_INFO:
                 return snd_pcm_channel_info_user(substream, arg);
         case SNDRV_PCM_IOCTL_PREPARE:
-                return snd_pcm_prepare(substream);
+                return snd_pcm_prepare(substream, file);
         case SNDRV_PCM_IOCTL_RESET:
                 return snd_pcm_reset(substream);
         case SNDRV_PCM_IOCTL_START:
@@ -2560,7 +2595,8 @@ static int snd_pcm_common_ioctl1(struct snd_pcm_substream *substream,
         return -ENOTTY;
 }
 
-static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream,
+static int snd_pcm_playback_ioctl1(struct file *file,
+                                   struct snd_pcm_substream *substream,
                                    unsigned int cmd, void __user *arg)
 {
         snd_assert(substream != NULL, return -ENXIO);
@@ -2636,10 +2672,11 @@ static int snd_pcm_playback_ioctl1(struct snd_pcm_substream *substream,
                 return result < 0 ? result : 0;
         }
         }
-        return snd_pcm_common_ioctl1(substream, cmd, arg);
+        return snd_pcm_common_ioctl1(file, substream, cmd, arg);
 }
 
-static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream,
+static int snd_pcm_capture_ioctl1(struct file *file,
+                                  struct snd_pcm_substream *substream,
                                   unsigned int cmd, void __user *arg)
 {
         snd_assert(substream != NULL, return -ENXIO);
@@ -2715,7 +2752,7 @@ static int snd_pcm_capture_ioctl1(struct snd_pcm_substream *substream,
                 return result < 0 ? result : 0;
         }
         }
-        return snd_pcm_common_ioctl1(substream, cmd, arg);
+        return snd_pcm_common_ioctl1(file, substream, cmd, arg);
 }
 
 static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd,
@@ -2728,7 +2765,8 @@ static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd,
         if (((cmd >> 8) & 0xff) != 'A')
                 return -ENOTTY;
 
-        return snd_pcm_playback_ioctl1(pcm_file->substream, cmd, (void __user *)arg);
+        return snd_pcm_playback_ioctl1(file, pcm_file->substream, cmd,
+                                       (void __user *)arg);
 }
 
 static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd,
@@ -2741,7 +2779,8 @@ static long snd_pcm_capture_ioctl(struct file *file, unsigned int cmd,
         if (((cmd >> 8) & 0xff) != 'A')
                 return -ENOTTY;
 
-        return snd_pcm_capture_ioctl1(pcm_file->substream, cmd, (void __user *)arg);
+        return snd_pcm_capture_ioctl1(file, pcm_file->substream, cmd,
+                                      (void __user *)arg);
 }
 
 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
@@ -2753,12 +2792,12 @@ int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
         fs = snd_enter_user();
         switch (substream->stream) {
         case SNDRV_PCM_STREAM_PLAYBACK:
-                result = snd_pcm_playback_ioctl1(substream,
-                                                 cmd, (void __user *)arg);
+                result = snd_pcm_playback_ioctl1(NULL, substream, cmd,
+                                                 (void __user *)arg);
                 break;
         case SNDRV_PCM_STREAM_CAPTURE:
-                result = snd_pcm_capture_ioctl1(substream,
-                                                cmd, (void __user *)arg);
+                result = snd_pcm_capture_ioctl1(NULL, substream, cmd,
+                                                (void __user *)arg);
                 break;
         default:
                 result = -EINVAL;
@@ -2768,6 +2807,8 @@ int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
         return result;
 }
 
+EXPORT_SYMBOL(snd_pcm_kernel_ioctl);
+
 static ssize_t snd_pcm_read(struct file *file, char __user *buf, size_t count,
                             loff_t * offset)
 {
@@ -3134,7 +3175,7 @@ static int snd_pcm_default_mmap(struct snd_pcm_substream *substream,
         area->vm_ops = &snd_pcm_vm_ops_data;
         area->vm_private_data = substream;
         area->vm_flags |= VM_RESERVED;
-        atomic_inc(&substream->runtime->mmap_count);
+        atomic_inc(&substream->mmap_count);
         return 0;
 }
 
@@ -3166,9 +3207,11 @@ int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,
                                 (substream->runtime->dma_addr + offset) >> PAGE_SHIFT,
                                 size, area->vm_page_prot))
                 return -EAGAIN;
-        atomic_inc(&substream->runtime->mmap_count);
+        atomic_inc(&substream->mmap_count);
         return 0;
 }
+
+EXPORT_SYMBOL(snd_pcm_lib_mmap_iomem);
 #endif /* SNDRV_PCM_INFO_MMAP */
 
 /*
@@ -3212,6 +3255,8 @@ int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file,
                 return snd_pcm_default_mmap(substream, area);
 }
 
+EXPORT_SYMBOL(snd_pcm_mmap_data);
+
 static int snd_pcm_mmap(struct file *file, struct vm_area_struct *area)
 {
         struct snd_pcm_file * pcm_file;
diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c
index 87b47c9564f7..8c15c66eb4aa 100644
--- a/sound/core/rawmidi.c
+++ b/sound/core/rawmidi.c
@@ -43,7 +43,7 @@ MODULE_DESCRIPTION("Midlevel RawMidi code for ALSA.");
 MODULE_LICENSE("GPL");
 
 #ifdef CONFIG_SND_OSSEMUL
-static int midi_map[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 0};
+static int midi_map[SNDRV_CARDS];
 static int amidi_map[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 1};
 module_param_array(midi_map, int, NULL, 0444);
 MODULE_PARM_DESC(midi_map, "Raw MIDI device number assigned to 1st OSS device.");
@@ -1561,7 +1561,6 @@ static int snd_rawmidi_dev_register(struct snd_device *device)
         entry = snd_info_create_card_entry(rmidi->card, name, rmidi->card->proc_root);
         if (entry) {
                 entry->private_data = rmidi;
-                entry->c.text.read_size = 1024;
                 entry->c.text.read = snd_rawmidi_proc_info_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
diff --git a/sound/core/seq/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c
index b9919785180b..e7234135641c 100644
--- a/sound/core/seq/oss/seq_oss.c
+++ b/sound/core/seq/oss/seq_oss.c
@@ -291,7 +291,6 @@ register_proc(void)
 
         entry->content = SNDRV_INFO_CONTENT_TEXT;
         entry->private_data = NULL;
-        entry->c.text.read_size = 1024;
         entry->c.text.read = info_read;
         if (snd_info_register(entry) < 0) {
                 snd_info_free_entry(entry);
diff --git a/sound/core/seq/seq.c b/sound/core/seq/seq.c
index 20f954bc7aa0..2f0d8773ac6b 100644
--- a/sound/core/seq/seq.c
+++ b/sound/core/seq/seq.c
@@ -129,25 +129,3 @@ static void __exit alsa_seq_exit(void)
 
 module_init(alsa_seq_init)
 module_exit(alsa_seq_exit)
-
-  /* seq_clientmgr.c */
-EXPORT_SYMBOL(snd_seq_create_kernel_client);
-EXPORT_SYMBOL(snd_seq_delete_kernel_client);
-EXPORT_SYMBOL(snd_seq_kernel_client_enqueue);
-EXPORT_SYMBOL(snd_seq_kernel_client_enqueue_blocking);
-EXPORT_SYMBOL(snd_seq_kernel_client_dispatch);
-EXPORT_SYMBOL(snd_seq_kernel_client_ctl);
-EXPORT_SYMBOL(snd_seq_kernel_client_write_poll);
-EXPORT_SYMBOL(snd_seq_set_queue_tempo);
-  /* seq_memory.c */
-EXPORT_SYMBOL(snd_seq_expand_var_event);
-EXPORT_SYMBOL(snd_seq_dump_var_event);
-  /* seq_ports.c */
-EXPORT_SYMBOL(snd_seq_event_port_attach);
-EXPORT_SYMBOL(snd_seq_event_port_detach);
-  /* seq_lock.c */
-#if defined(CONFIG_SMP) || defined(CONFIG_SND_DEBUG)
-/*EXPORT_SYMBOL(snd_seq_sleep_in_lock);*/
-/*EXPORT_SYMBOL(snd_seq_sleep_timeout_in_lock);*/
-EXPORT_SYMBOL(snd_use_lock_sync_helper);
-#endif
diff --git a/sound/core/seq/seq_clientmgr.c b/sound/core/seq/seq_clientmgr.c
index bb15d9ee8842..532a660df51d 100644
--- a/sound/core/seq/seq_clientmgr.c
+++ b/sound/core/seq/seq_clientmgr.c
@@ -1714,6 +1714,8 @@ int snd_seq_set_queue_tempo(int client, struct snd_seq_queue_tempo *tempo)
         return snd_seq_queue_timer_set_tempo(tempo->queue, client, tempo);
 }
 
+EXPORT_SYMBOL(snd_seq_set_queue_tempo);
+
 static int snd_seq_ioctl_set_queue_tempo(struct snd_seq_client *client,
                                          void __user *arg)
 {
@@ -2264,6 +2266,8 @@ int snd_seq_create_kernel_client(struct snd_card *card, int client_index,
         return client->number;
 }
 
+EXPORT_SYMBOL(snd_seq_create_kernel_client);
+
 /* exported to kernel modules */
 int snd_seq_delete_kernel_client(int client)
 {
@@ -2280,6 +2284,7 @@ int snd_seq_delete_kernel_client(int client)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_seq_delete_kernel_client);
 
 /* skeleton to enqueue event, called from snd_seq_kernel_client_enqueue
  * and snd_seq_kernel_client_enqueue_blocking
@@ -2328,6 +2333,8 @@ int snd_seq_kernel_client_enqueue(int client, struct snd_seq_event * ev,
         return kernel_client_enqueue(client, ev, NULL, 0, atomic, hop);
 }
 
+EXPORT_SYMBOL(snd_seq_kernel_client_enqueue);
+
 /*
  * exported, called by kernel clients to enqueue events (with blocking)
  *
@@ -2340,6 +2347,7 @@ int snd_seq_kernel_client_enqueue_blocking(int client, struct snd_seq_event * ev
         return kernel_client_enqueue(client, ev, file, 1, atomic, hop);
 }
 
+EXPORT_SYMBOL(snd_seq_kernel_client_enqueue_blocking);
 
 /* 
  * exported, called by kernel clients to dispatch events directly to other
@@ -2376,6 +2384,7 @@ int snd_seq_kernel_client_dispatch(int client, struct snd_seq_event * ev,
         return result;
 }
 
+EXPORT_SYMBOL(snd_seq_kernel_client_dispatch);
 
 /*
  * exported, called by kernel clients to perform same functions as with
@@ -2396,6 +2405,7 @@ int snd_seq_kernel_client_ctl(int clientid, unsigned int cmd, void *arg)
         return result;
 }
 
+EXPORT_SYMBOL(snd_seq_kernel_client_ctl);
 
 /* exported (for OSS emulator) */
 int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table *wait)
@@ -2413,6 +2423,8 @@ int snd_seq_kernel_client_write_poll(int clientid, struct file *file, poll_table
         return 0;
 }
 
+EXPORT_SYMBOL(snd_seq_kernel_client_write_poll);
+
 /*---------------------------------------------------------------------------*/
 
 #ifdef CONFIG_PROC_FS
diff --git a/sound/core/seq/seq_device.c b/sound/core/seq/seq_device.c
index d9a3e5a18d6a..d812dc886360 100644
--- a/sound/core/seq/seq_device.c
+++ b/sound/core/seq/seq_device.c
@@ -80,7 +80,7 @@ static LIST_HEAD(opslist);
 static int num_ops;
 static DEFINE_MUTEX(ops_mutex);
 #ifdef CONFIG_PROC_FS
-static struct snd_info_entry *info_entry = NULL;
+static struct snd_info_entry *info_entry;
 #endif
 
 /*
@@ -555,7 +555,6 @@ static int __init alsa_seq_device_init(void)
         if (info_entry == NULL)
                 return -ENOMEM;
         info_entry->content = SNDRV_INFO_CONTENT_TEXT;
-        info_entry->c.text.read_size = 2048;
         info_entry->c.text.read = snd_seq_device_info;
         if (snd_info_register(info_entry) < 0) {
                 snd_info_free_entry(info_entry);
diff --git a/sound/core/seq/seq_dummy.c b/sound/core/seq/seq_dummy.c
index 2a283a59ea4d..e55488d1237c 100644
--- a/sound/core/seq/seq_dummy.c
+++ b/sound/core/seq/seq_dummy.c
@@ -66,7 +66,7 @@ MODULE_LICENSE("GPL");
 MODULE_ALIAS("snd-seq-client-" __stringify(SNDRV_SEQ_CLIENT_DUMMY));
 
 static int ports = 1;
-static int duplex = 0;
+static int duplex;
 
 module_param(ports, int, 0444);
 MODULE_PARM_DESC(ports, "number of ports to be created");
@@ -171,7 +171,9 @@ create_port(int idx, int type)
         pinfo.capability |= SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE;
         if (duplex)
                 pinfo.capability |= SNDRV_SEQ_PORT_CAP_DUPLEX;
-        pinfo.type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC;
+        pinfo.type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
+                | SNDRV_SEQ_PORT_TYPE_SOFTWARE
+                | SNDRV_SEQ_PORT_TYPE_PORT;
         memset(&pcb, 0, sizeof(pcb));
         pcb.owner = THIS_MODULE;
         pcb.unuse = dummy_unuse;
diff --git a/sound/core/seq/seq_info.c b/sound/core/seq/seq_info.c
index acce21afdaa4..142e9e6882c9 100644
--- a/sound/core/seq/seq_info.c
+++ b/sound/core/seq/seq_info.c
@@ -34,8 +34,8 @@ static struct snd_info_entry *timer_entry;
 
 
 static struct snd_info_entry * __init
-create_info_entry(char *name, int size, void (*read)(struct snd_info_entry *,
-                                                     struct snd_info_buffer *))
+create_info_entry(char *name, void (*read)(struct snd_info_entry *,
+                                           struct snd_info_buffer *))
 {
         struct snd_info_entry *entry;
 
@@ -43,7 +43,6 @@ create_info_entry(char *name, int size, void (*read)(struct snd_info_entry *,
         if (entry == NULL)
                 return NULL;
         entry->content = SNDRV_INFO_CONTENT_TEXT;
-        entry->c.text.read_size = size;
         entry->c.text.read = read;
         if (snd_info_register(entry) < 0) {
                 snd_info_free_entry(entry);
@@ -55,11 +54,11 @@ create_info_entry(char *name, int size, void (*read)(struct snd_info_entry *,
 /* create all our /proc entries */
 int __init snd_seq_info_init(void)
 {
-        queues_entry = create_info_entry("queues", 512 + (256 * SNDRV_SEQ_MAX_QUEUES),
+        queues_entry = create_info_entry("queues",
                                          snd_seq_info_queues_read);
-        clients_entry = create_info_entry("clients", 512 + (256 * SNDRV_SEQ_MAX_CLIENTS),
+        clients_entry = create_info_entry("clients",
                                           snd_seq_info_clients_read);
-        timer_entry = create_info_entry("timer", 1024, snd_seq_info_timer_read);
+        timer_entry = create_info_entry("timer", snd_seq_info_timer_read);
         return 0;
 }
 
diff --git a/sound/core/seq/seq_lock.c b/sound/core/seq/seq_lock.c
index a837a94b2d2a..1a34941d4217 100644
--- a/sound/core/seq/seq_lock.c
+++ b/sound/core/seq/seq_lock.c
@@ -44,4 +44,6 @@ void snd_use_lock_sync_helper(snd_use_lock_t *lockp, const char *file, int line)
         }
 }
 
+EXPORT_SYMBOL(snd_use_lock_sync_helper);
+
 #endif
diff --git a/sound/core/seq/seq_memory.c b/sound/core/seq/seq_memory.c
index 40b4f679c80e..4bffe509f719 100644
--- a/sound/core/seq/seq_memory.c
+++ b/sound/core/seq/seq_memory.c
@@ -118,6 +118,8 @@ int snd_seq_dump_var_event(const struct snd_seq_event *event,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_seq_dump_var_event);
+
 
 /*
  * exported:
@@ -167,6 +169,7 @@ int snd_seq_expand_var_event(const struct snd_seq_event *event, int count, char
         return err < 0 ? err : newlen;
 }
 
+EXPORT_SYMBOL(snd_seq_expand_var_event);
 
 /*
  * release this cell, free extended data if available
diff --git a/sound/core/seq/seq_midi.c b/sound/core/seq/seq_midi.c
index 9caa1372bece..1daa5b069c79 100644
--- a/sound/core/seq/seq_midi.c
+++ b/sound/core/seq/seq_midi.c
@@ -278,6 +278,7 @@ snd_seq_midisynth_register_port(struct snd_seq_device *dev)
         struct seq_midisynth *msynth, *ms;
         struct snd_seq_port_info *port;
         struct snd_rawmidi_info *info;
+        struct snd_rawmidi *rmidi = dev->private_data;
         int newclient = 0;
         unsigned int p, ports;
         struct snd_seq_port_callback pcallbacks;
@@ -320,8 +321,8 @@ snd_seq_midisynth_register_port(struct snd_seq_device *dev)
                 }
                 client->seq_client =
                         snd_seq_create_kernel_client(
-                                card, 0, "%s", info->name[0] ?
-                                (const char *)info->name : "External MIDI");
+                                card, 0, "%s", card->shortname[0] ?
+                                (const char *)card->shortname : "External MIDI");
                 if (client->seq_client < 0) {
                         kfree(client);
                         mutex_unlock(&register_mutex);
@@ -376,7 +377,9 @@ snd_seq_midisynth_register_port(struct snd_seq_device *dev)
                 if ((port->capability & (SNDRV_SEQ_PORT_CAP_WRITE|SNDRV_SEQ_PORT_CAP_READ)) == (SNDRV_SEQ_PORT_CAP_WRITE|SNDRV_SEQ_PORT_CAP_READ) &&
                     info->flags & SNDRV_RAWMIDI_INFO_DUPLEX)
                         port->capability |= SNDRV_SEQ_PORT_CAP_DUPLEX;
-                port->type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC;
+                port->type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
+                        | SNDRV_SEQ_PORT_TYPE_HARDWARE
+                        | SNDRV_SEQ_PORT_TYPE_PORT;
                 port->midi_channels = 16;
                 memset(&pcallbacks, 0, sizeof(pcallbacks));
                 pcallbacks.owner = THIS_MODULE;
@@ -387,6 +390,8 @@ snd_seq_midisynth_register_port(struct snd_seq_device *dev)
                 pcallbacks.unuse = midisynth_unuse;
                 pcallbacks.event_input = event_process_midi;
                 port->kernel = &pcallbacks;
+                if (rmidi->ops && rmidi->ops->get_port_info)
+                        rmidi->ops->get_port_info(rmidi, p, port);
                 if (snd_seq_kernel_client_ctl(client->seq_client, SNDRV_SEQ_IOCTL_CREATE_PORT, port)<0)
                         goto __nomem;
                 ms->seq_client = client->seq_client;
diff --git a/sound/core/seq/seq_ports.c b/sound/core/seq/seq_ports.c
index 41e078c938cd..334579a9f268 100644
--- a/sound/core/seq/seq_ports.c
+++ b/sound/core/seq/seq_ports.c
@@ -221,7 +221,6 @@ static void clear_subscriber_list(struct snd_seq_client *client,
 {
         struct list_head *p, *n;
 
-        down_write(&grp->list_mutex);
         list_for_each_safe(p, n, &grp->list_head) {
                 struct snd_seq_subscribers *subs;
                 struct snd_seq_client *c;
@@ -259,7 +258,6 @@ static void clear_subscriber_list(struct snd_seq_client *client,
                         snd_seq_client_unlock(c);
                 }
         }
-        up_write(&grp->list_mutex);
 }
 
 /* delete port data */
@@ -677,6 +675,7 @@ int snd_seq_event_port_attach(int client,
         return ret;
 }
 
+EXPORT_SYMBOL(snd_seq_event_port_attach);
 
 /*
  * Detach the driver from a port.
@@ -696,3 +695,5 @@ int snd_seq_event_port_detach(int client, int port)
 
         return err;
 }
+
+EXPORT_SYMBOL(snd_seq_event_port_detach);
diff --git a/sound/core/seq/seq_virmidi.c b/sound/core/seq/seq_virmidi.c
index f4edec603b8f..0cfa06c6b81f 100644
--- a/sound/core/seq/seq_virmidi.c
+++ b/sound/core/seq/seq_virmidi.c
@@ -390,7 +390,9 @@ static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev *rdev)
         pinfo->capability |= SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SYNC_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE;
         pinfo->capability |= SNDRV_SEQ_PORT_CAP_READ | SNDRV_SEQ_PORT_CAP_SYNC_READ | SNDRV_SEQ_PORT_CAP_SUBS_READ;
         pinfo->capability |= SNDRV_SEQ_PORT_CAP_DUPLEX;
-        pinfo->type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC;
+        pinfo->type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
+                | SNDRV_SEQ_PORT_TYPE_SOFTWARE
+                | SNDRV_SEQ_PORT_TYPE_PORT;
         pinfo->midi_channels = 16;
         memset(&pcallbacks, 0, sizeof(pcallbacks));
         pcallbacks.owner = THIS_MODULE;
diff --git a/sound/core/sound.c b/sound/core/sound.c
index 108e430b5036..cd862728346c 100644
--- a/sound/core/sound.c
+++ b/sound/core/sound.c
@@ -39,6 +39,8 @@
 
 static int major = CONFIG_SND_MAJOR;
 int snd_major;
+EXPORT_SYMBOL(snd_major);
+
 static int cards_limit = 1;
 static int device_mode = S_IFCHR | S_IRUGO | S_IWUGO;
 
@@ -60,6 +62,7 @@ MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR);
  * modules are loaded manually, this limit number increases, too.
  */
 int snd_ecards_limit;
+EXPORT_SYMBOL(snd_ecards_limit);
 
 static struct snd_minor *snd_minors[SNDRV_OS_MINORS];
 static DEFINE_MUTEX(sound_mutex);
@@ -78,20 +81,17 @@ extern struct class *sound_class;
  */
 void snd_request_card(int card)
 {
-        int locked;
-
         if (! current->fs->root)
                 return;
-        read_lock(&snd_card_rwlock);
-        locked = snd_cards_lock & (1 << card);
-        read_unlock(&snd_card_rwlock);
-        if (locked)
+        if (snd_card_locked(card))
                 return;
         if (card < 0 || card >= cards_limit)
                 return;
         request_module("snd-card-%i", card);
 }
 
+EXPORT_SYMBOL(snd_request_card);
+
 static void snd_request_other(int minor)
 {
         char *str;
@@ -133,6 +133,8 @@ void *snd_lookup_minor_data(unsigned int minor, int type)
         return private_data;
 }
 
+EXPORT_SYMBOL(snd_lookup_minor_data);
+
 static int snd_open(struct inode *inode, struct file *file)
 {
         unsigned int minor = iminor(inode);
@@ -281,6 +283,8 @@ int snd_register_device(int type, struct snd_card *card, int dev,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_register_device);
+
 /**
  * snd_unregister_device - unregister the device on the given card
  * @type: the device type, SNDRV_DEVICE_TYPE_XXX
@@ -321,12 +325,14 @@ int snd_unregister_device(int type, struct snd_card *card, int dev)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_unregister_device);
+
 #ifdef CONFIG_PROC_FS
 /*
  *  INFO PART
  */
 
-static struct snd_info_entry *snd_minor_info_entry = NULL;
+static struct snd_info_entry *snd_minor_info_entry;
 
 static const char *snd_device_type_name(int type)
 {
@@ -381,7 +387,6 @@ int __init snd_minor_info_init(void)
 
         entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL);
         if (entry) {
-                entry->c.text.read_size = PAGE_SIZE;
                 entry->c.text.read = snd_minor_info_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
@@ -446,91 +451,3 @@ static void __exit alsa_sound_exit(void)
 
 module_init(alsa_sound_init)
 module_exit(alsa_sound_exit)
-
-  /* sound.c */
-EXPORT_SYMBOL(snd_major);
-EXPORT_SYMBOL(snd_ecards_limit);
-#if defined(CONFIG_KMOD)
-EXPORT_SYMBOL(snd_request_card);
-#endif
-EXPORT_SYMBOL(snd_register_device);
-EXPORT_SYMBOL(snd_unregister_device);
-EXPORT_SYMBOL(snd_lookup_minor_data);
-#if defined(CONFIG_SND_OSSEMUL)
-EXPORT_SYMBOL(snd_register_oss_device);
-EXPORT_SYMBOL(snd_unregister_oss_device);
-EXPORT_SYMBOL(snd_lookup_oss_minor_data);
-#endif
-  /* memory.c */
-EXPORT_SYMBOL(copy_to_user_fromio);
-EXPORT_SYMBOL(copy_from_user_toio);
-  /* init.c */
-EXPORT_SYMBOL(snd_cards);
-#if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
-EXPORT_SYMBOL(snd_mixer_oss_notify_callback);
-#endif
-EXPORT_SYMBOL(snd_card_new);
-EXPORT_SYMBOL(snd_card_disconnect);
-EXPORT_SYMBOL(snd_card_free);
-EXPORT_SYMBOL(snd_card_free_in_thread);
-EXPORT_SYMBOL(snd_card_register);
-EXPORT_SYMBOL(snd_component_add);
-EXPORT_SYMBOL(snd_card_file_add);
-EXPORT_SYMBOL(snd_card_file_remove);
-#ifdef CONFIG_PM
-EXPORT_SYMBOL(snd_power_wait);
-#endif
-  /* device.c */
-EXPORT_SYMBOL(snd_device_new);
-EXPORT_SYMBOL(snd_device_register);
-EXPORT_SYMBOL(snd_device_free);
-  /* isadma.c */
-#ifdef CONFIG_ISA_DMA_API
-EXPORT_SYMBOL(snd_dma_program);
-EXPORT_SYMBOL(snd_dma_disable);
-EXPORT_SYMBOL(snd_dma_pointer);
-#endif
-  /* info.c */
-#ifdef CONFIG_PROC_FS
-EXPORT_SYMBOL(snd_seq_root);
-EXPORT_SYMBOL(snd_iprintf);
-EXPORT_SYMBOL(snd_info_get_line);
-EXPORT_SYMBOL(snd_info_get_str);
-EXPORT_SYMBOL(snd_info_create_module_entry);
-EXPORT_SYMBOL(snd_info_create_card_entry);
-EXPORT_SYMBOL(snd_info_free_entry);
-EXPORT_SYMBOL(snd_info_register);
-EXPORT_SYMBOL(snd_info_unregister);
-EXPORT_SYMBOL(snd_card_proc_new);
-#endif
-  /* info_oss.c */
-#if defined(CONFIG_SND_OSSEMUL) && defined(CONFIG_PROC_FS)
-EXPORT_SYMBOL(snd_oss_info_register);
-#endif
-  /* control.c */
-EXPORT_SYMBOL(snd_ctl_new);
-EXPORT_SYMBOL(snd_ctl_new1);
-EXPORT_SYMBOL(snd_ctl_free_one);
-EXPORT_SYMBOL(snd_ctl_add);
-EXPORT_SYMBOL(snd_ctl_remove);
-EXPORT_SYMBOL(snd_ctl_remove_id);
-EXPORT_SYMBOL(snd_ctl_rename_id);
-EXPORT_SYMBOL(snd_ctl_find_numid);
-EXPORT_SYMBOL(snd_ctl_find_id);
-EXPORT_SYMBOL(snd_ctl_notify);
-EXPORT_SYMBOL(snd_ctl_register_ioctl);
-EXPORT_SYMBOL(snd_ctl_unregister_ioctl);
-#ifdef CONFIG_COMPAT
-EXPORT_SYMBOL(snd_ctl_register_ioctl_compat);
-EXPORT_SYMBOL(snd_ctl_unregister_ioctl_compat);
-#endif
-EXPORT_SYMBOL(snd_ctl_elem_read);
-EXPORT_SYMBOL(snd_ctl_elem_write);
-  /* misc.c */
-EXPORT_SYMBOL(release_and_free_resource);
-#ifdef CONFIG_SND_VERBOSE_PRINTK
-EXPORT_SYMBOL(snd_verbose_printk);
-#endif
-#if defined(CONFIG_SND_DEBUG) && defined(CONFIG_SND_VERBOSE_PRINTK)
-EXPORT_SYMBOL(snd_verbose_printd);
-#endif
diff --git a/sound/core/sound_oss.c b/sound/core/sound_oss.c
index 9055c6de9587..74f0fe5a1ba0 100644
--- a/sound/core/sound_oss.c
+++ b/sound/core/sound_oss.c
@@ -58,6 +58,8 @@ void *snd_lookup_oss_minor_data(unsigned int minor, int type)
         return private_data;
 }
 
+EXPORT_SYMBOL(snd_lookup_oss_minor_data);
+
 static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev)
 {
         int minor;
@@ -158,6 +160,8 @@ int snd_register_oss_device(int type, struct snd_card *card, int dev,
         return -EBUSY;
 }
 
+EXPORT_SYMBOL(snd_register_oss_device);
+
 int snd_unregister_oss_device(int type, struct snd_card *card, int dev)
 {
         int minor = snd_oss_kernel_minor(type, card, dev);
@@ -197,13 +201,15 @@ int snd_unregister_oss_device(int type, struct snd_card *card, int dev)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_unregister_oss_device);
+
 /*
  *  INFO PART
  */
 
 #ifdef CONFIG_PROC_FS
 
-static struct snd_info_entry *snd_minor_info_oss_entry = NULL;
+static struct snd_info_entry *snd_minor_info_oss_entry;
 
 static const char *snd_oss_device_type_name(int type)
 {
@@ -252,7 +258,6 @@ int __init snd_minor_info_oss_init(void)
 
         entry = snd_info_create_module_entry(THIS_MODULE, "devices", snd_oss_root);
         if (entry) {
-                entry->c.text.read_size = PAGE_SIZE;
                 entry->c.text.read = snd_minor_info_oss_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
diff --git a/sound/core/timer.c b/sound/core/timer.c
index cdeeb639b675..78199f58b93a 100644
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -1061,7 +1061,6 @@ static int snd_timer_register_system(void)
 static void snd_timer_proc_read(struct snd_info_entry *entry,
                                 struct snd_info_buffer *buffer)
 {
-        unsigned long flags;
         struct snd_timer *timer;
         struct snd_timer_instance *ti;
         struct list_head *p, *q;
@@ -1095,7 +1094,6 @@ static void snd_timer_proc_read(struct snd_info_entry *entry,
                 if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
                         snd_iprintf(buffer, " SLAVE");
                 snd_iprintf(buffer, "\n");
-                spin_lock_irqsave(&timer->lock, flags);
                 list_for_each(q, &timer->open_list_head) {
                         ti = list_entry(q, struct snd_timer_instance, open_list);
                         snd_iprintf(buffer, "  Client %s : %s\n",
@@ -1104,12 +1102,11 @@ static void snd_timer_proc_read(struct snd_info_entry *entry,
                                                  SNDRV_TIMER_IFLG_RUNNING)
                                     ? "running" : "stopped");
                 }
-                spin_unlock_irqrestore(&timer->lock, flags);
         }
         mutex_unlock(&register_mutex);
 }
 
-static struct snd_info_entry *snd_timer_proc_entry = NULL;
+static struct snd_info_entry *snd_timer_proc_entry;
 
 static void __init snd_timer_proc_init(void)
 {
@@ -1117,7 +1114,6 @@ static void __init snd_timer_proc_init(void)
 
         entry = snd_info_create_module_entry(THIS_MODULE, "timers", NULL);
         if (entry != NULL) {
-                entry->c.text.read_size = SNDRV_TIMER_DEVICES * 128;
                 entry->c.text.read = snd_timer_proc_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
diff --git a/sound/drivers/dummy.c b/sound/drivers/dummy.c
index ae0df549fac7..ffeafaf2ecca 100644
--- a/sound/drivers/dummy.c
+++ b/sound/drivers/dummy.c
@@ -677,6 +677,10 @@ static int __init alsa_card_dummy_init(void)
                                                          i, NULL, 0);
                 if (IS_ERR(device))
                         continue;
+                if (!platform_get_drvdata(device)) {
+                        platform_device_unregister(device);
+                        continue;
+                }
                 devices[i] = device;
                 cards++;
         }
diff --git a/sound/drivers/mpu401/mpu401.c b/sound/drivers/mpu401/mpu401.c
index 77b06009735d..d3cbbb047582 100644
--- a/sound/drivers/mpu401/mpu401.c
+++ b/sound/drivers/mpu401/mpu401.c
@@ -253,6 +253,10 @@ static int __init alsa_card_mpu401_init(void)
                                                          i, NULL, 0);
                 if (IS_ERR(device))
                         continue;
+                if (!platform_get_drvdata(device)) {
+                        platform_device_unregister(device);
+                        continue;
+                }
                 platform_devices[i] = device;
                 snd_mpu401_devices++;
         }
diff --git a/sound/drivers/mpu401/mpu401_uart.c b/sound/drivers/mpu401/mpu401_uart.c
index b49a45cbf67a..4bf07ca9b17d 100644
--- a/sound/drivers/mpu401/mpu401_uart.c
+++ b/sound/drivers/mpu401/mpu401_uart.c
@@ -58,22 +58,26 @@ static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu);
 #define MPU401_ACK              0xfe
 
 /* Build in lowlevel io */
-static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data, unsigned long addr)
+static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data,
+                              unsigned long addr)
 {
         outb(data, addr);
 }
 
-static unsigned char mpu401_read_port(struct snd_mpu401 *mpu, unsigned long addr)
+static unsigned char mpu401_read_port(struct snd_mpu401 *mpu,
+                                      unsigned long addr)
 {
         return inb(addr);
 }
 
-static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data, unsigned long addr)
+static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data,
+                              unsigned long addr)
 {
         writeb(data, (void __iomem *)addr);
 }
 
-static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu, unsigned long addr)
+static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu,
+                                      unsigned long addr)
 {
         return readb((void __iomem *)addr);
 }
@@ -86,20 +90,13 @@ static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu)
                 mpu->read(mpu, MPU401D(mpu));
 #ifdef CONFIG_SND_DEBUG
         if (timeout <= 0)
-                snd_printk("cmd: clear rx timeout (status = 0x%x)\n", mpu->read(mpu, MPU401C(mpu)));
+                snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n",
+                           mpu->read(mpu, MPU401C(mpu)));
 #endif
 }
 
-static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
+static void uart_interrupt_tx(struct snd_mpu401 *mpu)
 {
-        spin_lock(&mpu->input_lock);
-        if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
-                snd_mpu401_uart_input_read(mpu);
-        } else {
-                snd_mpu401_uart_clear_rx(mpu);
-        }
-        spin_unlock(&mpu->input_lock);
-        /* ok. for better Tx performance try do some output when input is done */
         if (test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode) &&
             test_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode)) {
                 spin_lock(&mpu->output_lock);
@@ -108,6 +105,22 @@ static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
         }
 }
 
+static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
+{
+        if (mpu->info_flags & MPU401_INFO_INPUT) {
+                spin_lock(&mpu->input_lock);
+                if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
+                        snd_mpu401_uart_input_read(mpu);
+                else
+                        snd_mpu401_uart_clear_rx(mpu);
+                spin_unlock(&mpu->input_lock);
+        }
+        if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
+                /* ok. for better Tx performance try do some output
+                   when input is done */
+                uart_interrupt_tx(mpu);
+}
+
 /**
  * snd_mpu401_uart_interrupt - generic MPU401-UART interrupt handler
  * @irq: the irq number
@@ -116,7 +129,8 @@ static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
  *
  * Processes the interrupt for MPU401-UART i/o.
  */
-irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id,
+                                      struct pt_regs *regs)
 {
         struct snd_mpu401 *mpu = dev_id;
         
@@ -126,6 +140,29 @@ irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id, struct pt_regs *reg
         return IRQ_HANDLED;
 }
 
+EXPORT_SYMBOL(snd_mpu401_uart_interrupt);
+
+/**
+ * snd_mpu401_uart_interrupt_tx - generic MPU401-UART transmit irq handler
+ * @irq: the irq number
+ * @dev_id: mpu401 instance
+ * @regs: the reigster
+ *
+ * Processes the interrupt for MPU401-UART output.
+ */
+irqreturn_t snd_mpu401_uart_interrupt_tx(int irq, void *dev_id,
+                                         struct pt_regs *regs)
+{
+        struct snd_mpu401 *mpu = dev_id;
+        
+        if (mpu == NULL)
+                return IRQ_NONE;
+        uart_interrupt_tx(mpu);
+        return IRQ_HANDLED;
+}
+
+EXPORT_SYMBOL(snd_mpu401_uart_interrupt_tx);
+
 /*
  * timer callback
  * reprogram the timer and call the interrupt job
@@ -159,7 +196,8 @@ static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input)
                 mpu->timer.expires = 1 + jiffies;
                 add_timer(&mpu->timer);
         } 
-        mpu->timer_invoked |= input ? MPU401_MODE_INPUT_TIMER : MPU401_MODE_OUTPUT_TIMER;
+        mpu->timer_invoked |= input ? MPU401_MODE_INPUT_TIMER :
+                MPU401_MODE_OUTPUT_TIMER;
         spin_unlock_irqrestore (&mpu->timer_lock, flags);
 }
 
@@ -172,7 +210,8 @@ static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input)
 
         spin_lock_irqsave (&mpu->timer_lock, flags);
         if (mpu->timer_invoked) {
-                mpu->timer_invoked &= input ? ~MPU401_MODE_INPUT_TIMER : ~MPU401_MODE_OUTPUT_TIMER;
+                mpu->timer_invoked &= input ? ~MPU401_MODE_INPUT_TIMER :
+                        ~MPU401_MODE_OUTPUT_TIMER;
                 if (! mpu->timer_invoked)
                         del_timer(&mpu->timer);
         }
@@ -180,11 +219,12 @@ static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input)
 }
 
 /*
-
+ * send a UART command
+ * return zero if successful, non-zero for some errors
  */
 
 static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
-                int ack)
+                               int ack)
 {
         unsigned long flags;
         int timeout, ok;
@@ -196,11 +236,13 @@ static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
         }
         /* ok. standard MPU-401 initialization */
         if (mpu->hardware != MPU401_HW_SB) {
-                for (timeout = 1000; timeout > 0 && !snd_mpu401_output_ready(mpu); timeout--)
+                for (timeout = 1000; timeout > 0 &&
+                             !snd_mpu401_output_ready(mpu); timeout--)
                         udelay(10);
 #ifdef CONFIG_SND_DEBUG
                 if (!timeout)
-                        snd_printk("cmd: tx timeout (status = 0x%x)\n", mpu->read(mpu, MPU401C(mpu)));
+                        snd_printk(KERN_ERR "cmd: tx timeout (status = 0x%x)\n",
+                                   mpu->read(mpu, MPU401C(mpu)));
 #endif
         }
         mpu->write(mpu, cmd, MPU401C(mpu));
@@ -215,12 +257,14 @@ static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
                 }
                 if (!ok && mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
                         ok = 1;
-        } else {
+        } else
                 ok = 1;
-        }
         spin_unlock_irqrestore(&mpu->input_lock, flags);
         if (!ok) {
-                snd_printk("cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)\n", cmd, mpu->port, mpu->read(mpu, MPU401C(mpu)), mpu->read(mpu, MPU401D(mpu)));
+                snd_printk(KERN_ERR "cmd: 0x%x failed at 0x%lx "
+                           "(status = 0x%x, data = 0x%x)\n", cmd, mpu->port,
+                           mpu->read(mpu, MPU401C(mpu)),
+                           mpu->read(mpu, MPU401D(mpu)));
                 return 1;
         }
         return 0;
@@ -314,7 +358,8 @@ static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream)
 /*
  * trigger input callback
  */
-static void snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
+static void
+snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
 {
         unsigned long flags;
         struct snd_mpu401 *mpu;
@@ -322,7 +367,8 @@ static void snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substrea
 
         mpu = substream->rmidi->private_data;
         if (up) {
-                if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode)) {
+                if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER,
+                                       &mpu->mode)) {
                         /* first time - flush FIFO */
                         while (max-- > 0)
                                 mpu->read(mpu, MPU401D(mpu));
@@ -352,13 +398,11 @@ static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
         unsigned char byte;
 
         while (max-- > 0) {
-                if (snd_mpu401_input_avail(mpu)) {
-                        byte = mpu->read(mpu, MPU401D(mpu));
-                        if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
-                                snd_rawmidi_receive(mpu->substream_input, &byte, 1);
-                } else {
+                if (! snd_mpu401_input_avail(mpu))
                         break; /* input not available */
-                }
+                byte = mpu->read(mpu, MPU401D(mpu));
+                if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
+                        snd_rawmidi_receive(mpu->substream_input, &byte, 1);
         }
 }
 
@@ -380,16 +424,16 @@ static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
         int max = 256, timeout;
 
         do {
-                if (snd_rawmidi_transmit_peek(mpu->substream_output, &byte, 1) == 1) {
+                if (snd_rawmidi_transmit_peek(mpu->substream_output,
+                                              &byte, 1) == 1) {
                         for (timeout = 100; timeout > 0; timeout--) {
-                                if (snd_mpu401_output_ready(mpu)) {
-                                        mpu->write(mpu, byte, MPU401D(mpu));
-                                        snd_rawmidi_transmit_ack(mpu->substream_output, 1);
+                                if (snd_mpu401_output_ready(mpu))
                                         break;
-                                }
                         }
                         if (timeout == 0)
                                 break;  /* Tx FIFO full - try again later */
+                        mpu->write(mpu, byte, MPU401D(mpu));
+                        snd_rawmidi_transmit_ack(mpu->substream_output, 1);
                 } else {
                         snd_mpu401_uart_remove_timer (mpu, 0);
                         break;  /* no other data - leave the tx loop */
@@ -400,7 +444,8 @@ static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
 /*
  * output trigger callback
  */
-static void snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
+static void
+snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
 {
         unsigned long flags;
         struct snd_mpu401 *mpu;
@@ -413,14 +458,16 @@ static void snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substre
                  * since the output timer might have been removed in
                  * snd_mpu401_uart_output_write().
                  */
-                snd_mpu401_uart_add_timer(mpu, 0);
+                if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
+                        snd_mpu401_uart_add_timer(mpu, 0);
 
                 /* output pending data */
                 spin_lock_irqsave(&mpu->output_lock, flags);
                 snd_mpu401_uart_output_write(mpu);
                 spin_unlock_irqrestore(&mpu->output_lock, flags);
         } else {
-                snd_mpu401_uart_remove_timer(mpu, 0);
+                if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
+                        snd_mpu401_uart_remove_timer(mpu, 0);
                 clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
         }
 }
@@ -458,7 +505,7 @@ static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
  * @device: the device index, zero-based
  * @hardware: the hardware type, MPU401_HW_XXXX
  * @port: the base address of MPU401 port
- * @integrated: non-zero if the port was already reserved by the chip
+ * @info_flags: bitflags MPU401_INFO_XXX
  * @irq: the irq number, -1 if no interrupt for mpu
  * @irq_flags: the irq request flags (SA_XXX), 0 if irq was already reserved.
  * @rrawmidi: the pointer to store the new rawmidi instance
@@ -473,17 +520,24 @@ static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
  */
 int snd_mpu401_uart_new(struct snd_card *card, int device,
                         unsigned short hardware,
-                        unsigned long port, int integrated,
+                        unsigned long port,
+                        unsigned int info_flags,
                         int irq, int irq_flags,
                         struct snd_rawmidi ** rrawmidi)
 {
         struct snd_mpu401 *mpu;
         struct snd_rawmidi *rmidi;
+        int in_enable, out_enable;
         int err;
 
         if (rrawmidi)
                 *rrawmidi = NULL;
-        if ((err = snd_rawmidi_new(card, "MPU-401U", device, 1, 1, &rmidi)) < 0)
+        if (! (info_flags & (MPU401_INFO_INPUT | MPU401_INFO_OUTPUT)))
+                info_flags |= MPU401_INFO_INPUT | MPU401_INFO_OUTPUT;
+        in_enable = (info_flags & MPU401_INFO_INPUT) ? 1 : 0;
+        out_enable = (info_flags & MPU401_INFO_OUTPUT) ? 1 : 0;
+        if ((err = snd_rawmidi_new(card, "MPU-401U", device,
+                                   out_enable, in_enable, &rmidi)) < 0)
                 return err;
         mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
         if (mpu == NULL) {
@@ -497,23 +551,23 @@ int snd_mpu401_uart_new(struct snd_card *card, int device,
         spin_lock_init(&mpu->output_lock);
         spin_lock_init(&mpu->timer_lock);
         mpu->hardware = hardware;
-        if (!integrated) {
+        if (! (info_flags & MPU401_INFO_INTEGRATED)) {
                 int res_size = hardware == MPU401_HW_PC98II ? 4 : 2;
-                if ((mpu->res = request_region(port, res_size, "MPU401 UART")) == NULL) {
-                        snd_printk(KERN_ERR "mpu401_uart: unable to grab port 0x%lx size %d\n", port, res_size);
+                mpu->res = request_region(port, res_size, "MPU401 UART");
+                if (mpu->res == NULL) {
+                        snd_printk(KERN_ERR "mpu401_uart: "
+                                   "unable to grab port 0x%lx size %d\n",
+                                   port, res_size);
                         snd_device_free(card, rmidi);
                         return -EBUSY;
                 }
         }
-        switch (hardware) {
-        case MPU401_HW_AUREAL:
+        if (info_flags & MPU401_INFO_MMIO) {
                 mpu->write = mpu401_write_mmio;
                 mpu->read = mpu401_read_mmio;
-                break;
-        default:
+        } else {
                 mpu->write = mpu401_write_port;
                 mpu->read = mpu401_read_port;
-                break;
         }
         mpu->port = port;
         if (hardware == MPU401_HW_PC98II)
@@ -521,30 +575,40 @@ int snd_mpu401_uart_new(struct snd_card *card, int device,
         else
                 mpu->cport = port + 1;
         if (irq >= 0 && irq_flags) {
-                if (request_irq(irq, snd_mpu401_uart_interrupt, irq_flags, "MPU401 UART", (void *) mpu)) {
-                        snd_printk(KERN_ERR "mpu401_uart: unable to grab IRQ %d\n", irq);
+                if (request_irq(irq, snd_mpu401_uart_interrupt, irq_flags,
+                                "MPU401 UART", (void *) mpu)) {
+                        snd_printk(KERN_ERR "mpu401_uart: "
+                                   "unable to grab IRQ %d\n", irq);
                         snd_device_free(card, rmidi);
                         return -EBUSY;
                 }
         }
+        mpu->info_flags = info_flags;
         mpu->irq = irq;
         mpu->irq_flags = irq_flags;
         if (card->shortname[0])
-                snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI", card->shortname);
+                snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI",
+                         card->shortname);
         else
-                sprintf(rmidi->name, "MPU-401 MIDI %d-%d", card->number, device);
-        snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_mpu401_uart_output);
-        snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_mpu401_uart_input);
-        rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
-                             SNDRV_RAWMIDI_INFO_INPUT |
-                             SNDRV_RAWMIDI_INFO_DUPLEX;
+                sprintf(rmidi->name, "MPU-401 MIDI %d-%d",card->number, device);
+        if (out_enable) {
+                snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
+                                    &snd_mpu401_uart_output);
+                rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT;
+        }
+        if (in_enable) {
+                snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
+                                    &snd_mpu401_uart_input);
+                rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
+                if (out_enable)
+                        rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
+        }
         mpu->rmidi = rmidi;
         if (rrawmidi)
                 *rrawmidi = rmidi;
         return 0;
 }
 
-EXPORT_SYMBOL(snd_mpu401_uart_interrupt);
 EXPORT_SYMBOL(snd_mpu401_uart_new);
 
 /*
diff --git a/sound/drivers/mtpav.c b/sound/drivers/mtpav.c
index b7a0b42813e1..474eed06e70f 100644
--- a/sound/drivers/mtpav.c
+++ b/sound/drivers/mtpav.c
@@ -770,11 +770,15 @@ static int __init alsa_card_mtpav_init(void)
                 return err;
 
         device = platform_device_register_simple(SND_MTPAV_DRIVER, -1, NULL, 0);
-        if (IS_ERR(device)) {
-                platform_driver_unregister(&snd_mtpav_driver);
-                return PTR_ERR(device);
-        }
-        return 0;
+        if (!IS_ERR(device)) {
+                if (platform_get_drvdata(device))
+                        return 0;
+                platform_device_unregister(device);
+                err = -ENODEV;
+        } else
+                err = PTR_ERR(device);
+        platform_driver_unregister(&snd_mtpav_driver);
+        return err;
 }
 
 static void __exit alsa_card_mtpav_exit(void)
diff --git a/sound/drivers/opl3/opl3_lib.c b/sound/drivers/opl3/opl3_lib.c
index 4f8556976774..87fe376f38f0 100644
--- a/sound/drivers/opl3/opl3_lib.c
+++ b/sound/drivers/opl3/opl3_lib.c
@@ -316,6 +316,8 @@ void snd_opl3_interrupt(struct snd_hwdep * hw)
         }
 }
 
+EXPORT_SYMBOL(snd_opl3_interrupt);
+
 /*
 
  */
@@ -369,6 +371,8 @@ int snd_opl3_new(struct snd_card *card,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_opl3_new);
+
 int snd_opl3_init(struct snd_opl3 *opl3)
 {
         if (! opl3->command) {
@@ -393,6 +397,8 @@ int snd_opl3_init(struct snd_opl3 *opl3)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_opl3_init);
+
 int snd_opl3_create(struct snd_card *card,
                     unsigned long l_port,
                     unsigned long r_port,
@@ -451,6 +457,8 @@ int snd_opl3_create(struct snd_card *card,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_opl3_create);
+
 int snd_opl3_timer_new(struct snd_opl3 * opl3, int timer1_dev, int timer2_dev)
 {
         int err;
@@ -468,6 +476,8 @@ int snd_opl3_timer_new(struct snd_opl3 * opl3, int timer1_dev, int timer2_dev)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_opl3_timer_new);
+
 int snd_opl3_hwdep_new(struct snd_opl3 * opl3,
                        int device, int seq_device,
                        struct snd_hwdep ** rhwdep)
@@ -526,17 +536,8 @@ int snd_opl3_hwdep_new(struct snd_opl3 * opl3,
         return 0;
 }
 
-EXPORT_SYMBOL(snd_opl3_interrupt);
-EXPORT_SYMBOL(snd_opl3_new);
-EXPORT_SYMBOL(snd_opl3_init);
-EXPORT_SYMBOL(snd_opl3_create);
-EXPORT_SYMBOL(snd_opl3_timer_new);
 EXPORT_SYMBOL(snd_opl3_hwdep_new);
 
-/* opl3_synth.c */
-EXPORT_SYMBOL(snd_opl3_regmap);
-EXPORT_SYMBOL(snd_opl3_reset);
-
 /*
  *  INIT part
  */
diff --git a/sound/drivers/opl3/opl3_oss.c b/sound/drivers/opl3/opl3_oss.c
index fccf019a6d85..5fd3a4c95626 100644
--- a/sound/drivers/opl3/opl3_oss.c
+++ b/sound/drivers/opl3/opl3_oss.c
@@ -100,7 +100,8 @@ static int snd_opl3_oss_create_port(struct snd_opl3 * opl3)
                                                           SNDRV_SEQ_PORT_CAP_WRITE,
                                                           SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
                                                           SNDRV_SEQ_PORT_TYPE_MIDI_GM |
-                                                          SNDRV_SEQ_PORT_TYPE_SYNTH,
+                                                          SNDRV_SEQ_PORT_TYPE_HARDWARE |
+                                                          SNDRV_SEQ_PORT_TYPE_SYNTHESIZER,
                                                           voices, voices,
                                                           name);
         if (opl3->oss_chset->port < 0) {
diff --git a/sound/drivers/opl3/opl3_seq.c b/sound/drivers/opl3/opl3_seq.c
index 57becf34f43e..96762c9d4855 100644
--- a/sound/drivers/opl3/opl3_seq.c
+++ b/sound/drivers/opl3/opl3_seq.c
@@ -203,7 +203,9 @@ static int snd_opl3_synth_create_port(struct snd_opl3 * opl3)
                                                       SNDRV_SEQ_PORT_CAP_SUBS_WRITE,
                                                       SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
                                                       SNDRV_SEQ_PORT_TYPE_MIDI_GM |
-                                                      SNDRV_SEQ_PORT_TYPE_SYNTH,
+                                                      SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE |
+                                                      SNDRV_SEQ_PORT_TYPE_HARDWARE |
+                                                      SNDRV_SEQ_PORT_TYPE_SYNTHESIZER,
                                                       16, voices,
                                                       name);
         if (opl3->chset->port < 0) {
diff --git a/sound/drivers/opl3/opl3_synth.c b/sound/drivers/opl3/opl3_synth.c
index 6db503f025b3..a4b3543a7118 100644
--- a/sound/drivers/opl3/opl3_synth.c
+++ b/sound/drivers/opl3/opl3_synth.c
@@ -58,6 +58,8 @@ char snd_opl3_regmap[MAX_OPL2_VOICES][4] =
         { 0x12, 0x15, 0x00, 0x00 }      /* is selected (only left reg block) */
 };
 
+EXPORT_SYMBOL(snd_opl3_regmap);
+
 /*
  * prototypes
  */
@@ -228,6 +230,7 @@ void snd_opl3_reset(struct snd_opl3 * opl3)
         opl3->rhythm = 0;
 }
 
+EXPORT_SYMBOL(snd_opl3_reset);
 
 static int snd_opl3_play_note(struct snd_opl3 * opl3, struct snd_dm_fm_note * note)
 {
@@ -445,3 +448,4 @@ static int snd_opl3_set_connection(struct snd_opl3 * opl3, int connection)
 
         return 0;
 }
+
diff --git a/sound/drivers/opl4/opl4_lib.c b/sound/drivers/opl4/opl4_lib.c
index 4bc860ae02de..01997f24c895 100644
--- a/sound/drivers/opl4/opl4_lib.c
+++ b/sound/drivers/opl4/opl4_lib.c
@@ -43,6 +43,8 @@ void snd_opl4_write(struct snd_opl4 *opl4, u8 reg, u8 value)
         outb(value, opl4->pcm_port + 1);
 }
 
+EXPORT_SYMBOL(snd_opl4_write);
+
 u8 snd_opl4_read(struct snd_opl4 *opl4, u8 reg)
 {
         snd_opl4_wait(opl4);
@@ -52,6 +54,8 @@ u8 snd_opl4_read(struct snd_opl4 *opl4, u8 reg)
         return inb(opl4->pcm_port + 1);
 }
 
+EXPORT_SYMBOL(snd_opl4_read);
+
 void snd_opl4_read_memory(struct snd_opl4 *opl4, char *buf, int offset, int size)
 {
         unsigned long flags;
@@ -76,6 +80,8 @@ void snd_opl4_read_memory(struct snd_opl4 *opl4, char *buf, int offset, int size
         spin_unlock_irqrestore(&opl4->reg_lock, flags);
 }
 
+EXPORT_SYMBOL(snd_opl4_read_memory);
+
 void snd_opl4_write_memory(struct snd_opl4 *opl4, const char *buf, int offset, int size)
 {
         unsigned long flags;
@@ -100,6 +106,8 @@ void snd_opl4_write_memory(struct snd_opl4 *opl4, const char *buf, int offset, i
         spin_unlock_irqrestore(&opl4->reg_lock, flags);
 }
 
+EXPORT_SYMBOL(snd_opl4_write_memory);
+
 static void snd_opl4_enable_opl4(struct snd_opl4 *opl4)
 {
         outb(OPL3_REG_MODE, opl4->fm_port + 2);
@@ -256,10 +264,6 @@ int snd_opl4_create(struct snd_card *card,
         return 0;
 }
 
-EXPORT_SYMBOL(snd_opl4_write);
-EXPORT_SYMBOL(snd_opl4_read);
-EXPORT_SYMBOL(snd_opl4_write_memory);
-EXPORT_SYMBOL(snd_opl4_read_memory);
 EXPORT_SYMBOL(snd_opl4_create);
 
 static int __init alsa_opl4_init(void)
diff --git a/sound/drivers/opl4/opl4_seq.c b/sound/drivers/opl4/opl4_seq.c
index dc0dcdc6c313..43d8a2bdd280 100644
--- a/sound/drivers/opl4/opl4_seq.c
+++ b/sound/drivers/opl4/opl4_seq.c
@@ -164,7 +164,9 @@ static int snd_opl4_seq_new_device(struct snd_seq_device *dev)
                                                       SNDRV_SEQ_PORT_CAP_WRITE |
                                                       SNDRV_SEQ_PORT_CAP_SUBS_WRITE,
                                                       SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
-                                                      SNDRV_SEQ_PORT_TYPE_MIDI_GM,
+                                                      SNDRV_SEQ_PORT_TYPE_MIDI_GM |
+                                                      SNDRV_SEQ_PORT_TYPE_HARDWARE |
+                                                      SNDRV_SEQ_PORT_TYPE_SYNTHESIZER,
                                                       16, 24,
                                                       "OPL4 Wavetable Port");
         if (opl4->chset->port < 0) {
diff --git a/sound/drivers/serial-u16550.c b/sound/drivers/serial-u16550.c
index c01b4c5118b9..2330fec505da 100644
--- a/sound/drivers/serial-u16550.c
+++ b/sound/drivers/serial-u16550.c
@@ -998,6 +998,10 @@ static int __init alsa_card_serial_init(void)
                                                          i, NULL, 0);
                 if (IS_ERR(device))
                         continue;
+                if (!platform_get_drvdata(device)) {
+                        platform_device_unregister(device);
+                        continue;
+                }
                 devices[i] = device;
                 cards++;
         }
diff --git a/sound/drivers/virmidi.c b/sound/drivers/virmidi.c
index 26eb2499d442..59171f8200df 100644
--- a/sound/drivers/virmidi.c
+++ b/sound/drivers/virmidi.c
@@ -171,6 +171,10 @@ static int __init alsa_card_virmidi_init(void)
                                                          i, NULL, 0);
                 if (IS_ERR(device))
                         continue;
+                if (!platform_get_drvdata(device)) {
+                        platform_device_unregister(device);
+                        continue;
+                }
                 devices[i] = device;
                 cards++;
         }
diff --git a/sound/drivers/vx/vx_core.c b/sound/drivers/vx/vx_core.c
index fa4a2b5c2d8d..a60168268ddd 100644
--- a/sound/drivers/vx/vx_core.c
+++ b/sound/drivers/vx/vx_core.c
@@ -70,6 +70,8 @@ int snd_vx_check_reg_bit(struct vx_core *chip, int reg, int mask, int bit, int t
         return -EIO;
 }
 
+EXPORT_SYMBOL(snd_vx_check_reg_bit);
+
 /*
  * vx_send_irq_dsp - set command irq bit
  * @num: the requested IRQ type, IRQ_XXX
@@ -465,6 +467,8 @@ int snd_vx_load_boot_image(struct vx_core *chip, const struct firmware *boot)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_vx_load_boot_image);
+
 /*
  * vx_test_irq_src - query the source of interrupts
  *
@@ -545,6 +549,7 @@ irqreturn_t snd_vx_irq_handler(int irq, void *dev, struct pt_regs *regs)
         return IRQ_HANDLED;
 }
 
+EXPORT_SYMBOL(snd_vx_irq_handler);
 
 /*
  */
@@ -635,7 +640,7 @@ static void vx_proc_init(struct vx_core *chip)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(chip->card, "vx-status", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, vx_proc_read);
+                snd_info_set_text_ops(entry, chip, vx_proc_read);
 }
 
 
@@ -657,6 +662,8 @@ int snd_vx_dsp_boot(struct vx_core *chip, const struct firmware *boot)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_vx_dsp_boot);
+
 /**
  * snd_vx_dsp_load - load the DSP image
  */
@@ -705,6 +712,8 @@ int snd_vx_dsp_load(struct vx_core *chip, const struct firmware *dsp)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_vx_dsp_load);
+
 #ifdef CONFIG_PM
 /*
  * suspend
@@ -721,6 +730,8 @@ int snd_vx_suspend(struct vx_core *chip, pm_message_t state)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_vx_suspend);
+
 /*
  * resume
  */
@@ -747,6 +758,7 @@ int snd_vx_resume(struct vx_core *chip)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_vx_resume);
 #endif
 
 /**
@@ -790,6 +802,8 @@ struct vx_core *snd_vx_create(struct snd_card *card, struct snd_vx_hardware *hw,
         return chip;
 }
 
+EXPORT_SYMBOL(snd_vx_create);
+
 /*
  * module entries
  */
@@ -804,19 +818,3 @@ static void __exit alsa_vx_core_exit(void)
 
 module_init(alsa_vx_core_init)
 module_exit(alsa_vx_core_exit)
-
-/*
- * exports
- */
-EXPORT_SYMBOL(snd_vx_check_reg_bit);
-EXPORT_SYMBOL(snd_vx_create);
-EXPORT_SYMBOL(snd_vx_setup_firmware);
-EXPORT_SYMBOL(snd_vx_free_firmware);
-EXPORT_SYMBOL(snd_vx_irq_handler);
-EXPORT_SYMBOL(snd_vx_dsp_boot);
-EXPORT_SYMBOL(snd_vx_dsp_load);
-EXPORT_SYMBOL(snd_vx_load_boot_image);
-#ifdef CONFIG_PM
-EXPORT_SYMBOL(snd_vx_suspend);
-EXPORT_SYMBOL(snd_vx_resume);
-#endif
diff --git a/sound/drivers/vx/vx_hwdep.c b/sound/drivers/vx/vx_hwdep.c
index d837783fb538..e1920af4501d 100644
--- a/sound/drivers/vx/vx_hwdep.c
+++ b/sound/drivers/vx/vx_hwdep.c
@@ -250,3 +250,6 @@ void snd_vx_free_firmware(struct vx_core *chip)
 }
 
 #endif /* SND_VX_FW_LOADER */
+
+EXPORT_SYMBOL(snd_vx_setup_firmware);
+EXPORT_SYMBOL(snd_vx_free_firmware);
diff --git a/sound/i2c/i2c.c b/sound/i2c/i2c.c
index edfe76fb0074..b60fb1892828 100644
--- a/sound/i2c/i2c.c
+++ b/sound/i2c/i2c.c
@@ -106,6 +106,8 @@ int snd_i2c_bus_create(struct snd_card *card, const char *name,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_i2c_bus_create);
+
 int snd_i2c_device_create(struct snd_i2c_bus *bus, const char *name,
                           unsigned char addr, struct snd_i2c_device **rdevice)
 {
@@ -124,6 +126,8 @@ int snd_i2c_device_create(struct snd_i2c_bus *bus, const char *name,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_i2c_device_create);
+
 int snd_i2c_device_free(struct snd_i2c_device *device)
 {
         if (device->bus)
@@ -134,22 +138,29 @@ int snd_i2c_device_free(struct snd_i2c_device *device)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_i2c_device_free);
+
 int snd_i2c_sendbytes(struct snd_i2c_device *device, unsigned char *bytes, int count)
 {
         return device->bus->ops->sendbytes(device, bytes, count);
 }
 
+EXPORT_SYMBOL(snd_i2c_sendbytes);
 
 int snd_i2c_readbytes(struct snd_i2c_device *device, unsigned char *bytes, int count)
 {
         return device->bus->ops->readbytes(device, bytes, count);
 }
 
+EXPORT_SYMBOL(snd_i2c_readbytes);
+
 int snd_i2c_probeaddr(struct snd_i2c_bus *bus, unsigned short addr)
 {
         return bus->ops->probeaddr(bus, addr);
 }
 
+EXPORT_SYMBOL(snd_i2c_probeaddr);
+
 /*
  *  bit-operations
  */
@@ -320,12 +331,6 @@ static int snd_i2c_bit_probeaddr(struct snd_i2c_bus *bus, unsigned short addr)
         return err;
 }
 
-EXPORT_SYMBOL(snd_i2c_bus_create);
-EXPORT_SYMBOL(snd_i2c_device_create);
-EXPORT_SYMBOL(snd_i2c_device_free);
-EXPORT_SYMBOL(snd_i2c_sendbytes);
-EXPORT_SYMBOL(snd_i2c_readbytes);
-EXPORT_SYMBOL(snd_i2c_probeaddr);
 
 static int __init alsa_i2c_init(void)
 {
diff --git a/sound/i2c/l3/uda1341.c b/sound/i2c/l3/uda1341.c
index 746500e06950..b074fdddea55 100644
--- a/sound/i2c/l3/uda1341.c
+++ b/sound/i2c/l3/uda1341.c
@@ -517,9 +517,9 @@ static void __devinit snd_uda1341_proc_init(struct snd_card *card, struct l3_cli
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(card, "uda1341", &entry))
-                snd_info_set_text_ops(entry, clnt, 1024, snd_uda1341_proc_read);
+                snd_info_set_text_ops(entry, clnt, snd_uda1341_proc_read);
         if (! snd_card_proc_new(card, "uda1341-regs", &entry))
-                snd_info_set_text_ops(entry, clnt, 1024, snd_uda1341_proc_regs_read);
+                snd_info_set_text_ops(entry, clnt, snd_uda1341_proc_regs_read);
 }
 
 /* }}} */
diff --git a/sound/isa/gus/gus_irq.c b/sound/isa/gus/gus_irq.c
index c19ba2910b72..42db37552efb 100644
--- a/sound/isa/gus/gus_irq.c
+++ b/sound/isa/gus/gus_irq.c
@@ -136,7 +136,7 @@ void snd_gus_irq_profile_init(struct snd_gus_card *gus)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(gus->card, "gusirq", &entry))
-                snd_info_set_text_ops(entry, gus, 1024, snd_gus_irq_info_read);
+                snd_info_set_text_ops(entry, gus, snd_gus_irq_info_read);
 }
 
 #endif
diff --git a/sound/isa/gus/gus_mem.c b/sound/isa/gus/gus_mem.c
index 3c0d27aa08b3..f50c276caee8 100644
--- a/sound/isa/gus/gus_mem.c
+++ b/sound/isa/gus/gus_mem.c
@@ -264,10 +264,8 @@ int snd_gf1_mem_init(struct snd_gus_card * gus)
         if (snd_gf1_mem_xalloc(alloc, &block) == NULL)
                 return -ENOMEM;
 #ifdef CONFIG_SND_DEBUG
-        if (! snd_card_proc_new(gus->card, "gusmem", &entry)) {
-                snd_info_set_text_ops(entry, gus, 1024, snd_gf1_mem_info_read);
-                entry->c.text.read_size = 256 * 1024;
-        }
+        if (! snd_card_proc_new(gus->card, "gusmem", &entry))
+                snd_info_set_text_ops(entry, gus, snd_gf1_mem_info_read);
 #endif
         return 0;
 }
diff --git a/sound/isa/gus/gus_synth.c b/sound/isa/gus/gus_synth.c
index 2767cc187ae3..3e4d4d6edd8b 100644
--- a/sound/isa/gus/gus_synth.c
+++ b/sound/isa/gus/gus_synth.c
@@ -194,7 +194,9 @@ static int snd_gus_synth_create_port(struct snd_gus_card * gus, int idx)
                                                    &callbacks,
                                                    SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE,
                                                    SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE |
-                                                   SNDRV_SEQ_PORT_TYPE_SYNTH,
+                                                   SNDRV_SEQ_PORT_TYPE_SYNTH |
+                                                   SNDRV_SEQ_PORT_TYPE_HARDWARE |
+                                                   SNDRV_SEQ_PORT_TYPE_SYNTHESIZER,
                                                    16, 0,
                                                    name);
         if (p->chset->port < 0) {
diff --git a/sound/isa/gus/interwave.c b/sound/isa/gus/interwave.c
index 4298d339e786..866300f2acbb 100644
--- a/sound/isa/gus/interwave.c
+++ b/sound/isa/gus/interwave.c
@@ -70,9 +70,9 @@ static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;	/* 0,1,3,5,6,7 */
 static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;       /* 0,1,3,5,6,7 */
 static int joystick_dac[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 29};
                                 /* 0 to 31, (0.59V-4.52V or 0.389V-2.98V) */
-static int midi[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0};
+static int midi[SNDRV_CARDS];
 static int pcm_channels[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
-static int effect[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0};
+static int effect[SNDRV_CARDS];
 
 #ifdef SNDRV_STB
 #define PFX "interwave-stb: "
diff --git a/sound/isa/opl3sa2.c b/sound/isa/opl3sa2.c
index 6d889052c32c..647a996791e9 100644
--- a/sound/isa/opl3sa2.c
+++ b/sound/isa/opl3sa2.c
@@ -59,7 +59,7 @@ static long midi_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;/* 0x330,0x300 */
 static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;        /* 0,1,3,5,9,11,12,15 */
 static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;       /* 1,3,5,6,7 */
 static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;       /* 1,3,5,6,7 */
-static int opl3sa3_ymode[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0 };   /* 0,1,2,3 */ /*SL Added*/
+static int opl3sa3_ymode[SNDRV_CARDS];   /* 0,1,2,3 */ /*SL Added*/
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for OPL3-SA soundcard.");
@@ -221,7 +221,7 @@ static void snd_opl3sa2_write(struct snd_opl3sa2 *chip, unsigned char reg, unsig
         spin_unlock_irqrestore(&chip->reg_lock, flags);
 }
 
-static int __init snd_opl3sa2_detect(struct snd_opl3sa2 *chip)
+static int __devinit snd_opl3sa2_detect(struct snd_opl3sa2 *chip)
 {
         struct snd_card *card;
         unsigned long port;
@@ -489,7 +489,7 @@ static void snd_opl3sa2_master_free(struct snd_kcontrol *kcontrol)
         chip->master_volume = NULL;
 }
 
-static int __init snd_opl3sa2_mixer(struct snd_opl3sa2 *chip)
+static int __devinit snd_opl3sa2_mixer(struct snd_opl3sa2 *chip)
 {
         struct snd_card *card = chip->card;
         struct snd_ctl_elem_id id1, id2;
@@ -583,8 +583,8 @@ static int snd_opl3sa2_resume(struct snd_card *card)
 #endif /* CONFIG_PM */
 
 #ifdef CONFIG_PNP
-static int __init snd_opl3sa2_pnp(int dev, struct snd_opl3sa2 *chip,
-                                  struct pnp_dev *pdev)
+static int __devinit snd_opl3sa2_pnp(int dev, struct snd_opl3sa2 *chip,
+                                     struct pnp_dev *pdev)
 {
         struct pnp_resource_table * cfg;
         int err;
@@ -862,7 +862,7 @@ static struct pnp_card_driver opl3sa2_pnpc_driver = {
 };
 #endif /* CONFIG_PNP */
 
-static int __init snd_opl3sa2_nonpnp_probe(struct platform_device *pdev)
+static int __devinit snd_opl3sa2_nonpnp_probe(struct platform_device *pdev)
 {
         struct snd_card *card;
         int err;
diff --git a/sound/isa/opti9xx/miro.c b/sound/isa/opti9xx/miro.c
index e6bfcf74c1c1..283817f2de75 100644
--- a/sound/isa/opti9xx/miro.c
+++ b/sound/isa/opti9xx/miro.c
@@ -967,7 +967,7 @@ static void __init snd_miro_proc_init(struct snd_miro * miro)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(miro->card, "miro", &entry))
-                snd_info_set_text_ops(entry, miro, 1024, snd_miro_proc_read);
+                snd_info_set_text_ops(entry, miro, snd_miro_proc_read);
 }
 
 /*
diff --git a/sound/isa/sb/emu8000.c b/sound/isa/sb/emu8000.c
index c0b8d61b75e7..658179e86142 100644
--- a/sound/isa/sb/emu8000.c
+++ b/sound/isa/sb/emu8000.c
@@ -131,7 +131,7 @@ snd_emu8000_dma_chan(struct snd_emu8000 *emu, int ch, int mode)
 
 /*
  */
-static void __init
+static void __devinit
 snd_emu8000_read_wait(struct snd_emu8000 *emu)
 {
         while ((EMU8000_SMALR_READ(emu) & 0x80000000) != 0) {
@@ -143,7 +143,7 @@ snd_emu8000_read_wait(struct snd_emu8000 *emu)
 
 /*
  */
-static void __init
+static void __devinit
 snd_emu8000_write_wait(struct snd_emu8000 *emu)
 {
         while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) {
@@ -156,7 +156,7 @@ snd_emu8000_write_wait(struct snd_emu8000 *emu)
 /*
  * detect a card at the given port
  */
-static int __init
+static int __devinit
 snd_emu8000_detect(struct snd_emu8000 *emu)
 {
         /* Initialise */
@@ -182,7 +182,7 @@ snd_emu8000_detect(struct snd_emu8000 *emu)
 /*
  * intiailize audio channels
  */
-static void __init
+static void __devinit
 init_audio(struct snd_emu8000 *emu)
 {
         int ch;
@@ -223,7 +223,7 @@ init_audio(struct snd_emu8000 *emu)
 /*
  * initialize DMA address
  */
-static void __init
+static void __devinit
 init_dma(struct snd_emu8000 *emu)
 {
         EMU8000_SMALR_WRITE(emu, 0);
@@ -327,7 +327,7 @@ static unsigned short init4[128] /*__devinitdata*/ = {
  * Taken from the oss driver, not obvious from the doc how this
  * is meant to work
  */
-static void __init
+static void __devinit
 send_array(struct snd_emu8000 *emu, unsigned short *data, int size)
 {
         int i;
@@ -349,7 +349,7 @@ send_array(struct snd_emu8000 *emu, unsigned short *data, int size)
  * Send initialization arrays to start up, this just follows the
  * initialisation sequence in the adip.
  */
-static void __init
+static void __devinit
 init_arrays(struct snd_emu8000 *emu)
 {
         send_array(emu, init1, ARRAY_SIZE(init1)/4);
@@ -375,7 +375,7 @@ init_arrays(struct snd_emu8000 *emu)
  * seems that the only way to do this is to use the one channel and keep
  * reallocating between read and write.
  */
-static void __init
+static void __devinit
 size_dram(struct snd_emu8000 *emu)
 {
         int i, size;
@@ -500,7 +500,7 @@ snd_emu8000_init_fm(struct snd_emu8000 *emu)
 /*
  * The main initialization routine.
  */
-static void __init
+static void __devinit
 snd_emu8000_init_hw(struct snd_emu8000 *emu)
 {
         int i;
@@ -1019,7 +1019,7 @@ static struct snd_kcontrol_new *mixer_defs[EMU8000_NUM_CONTROLS] = {
 /*
  * create and attach mixer elements for WaveTable treble/bass controls
  */
-static int __init
+static int __devinit
 snd_emu8000_create_mixer(struct snd_card *card, struct snd_emu8000 *emu)
 {
         int i, err = 0;
@@ -1069,7 +1069,7 @@ static int snd_emu8000_dev_free(struct snd_device *device)
 /*
  * initialize and register emu8000 synth device.
  */
-int __init
+int __devinit
 snd_emu8000_new(struct snd_card *card, int index, long port, int seq_ports,
                 struct snd_seq_device **awe_ret)
 {
diff --git a/sound/isa/sb/emu8000_patch.c b/sound/isa/sb/emu8000_patch.c
index 80b1cf84a1ae..1be16c9700f0 100644
--- a/sound/isa/sb/emu8000_patch.c
+++ b/sound/isa/sb/emu8000_patch.c
@@ -23,7 +23,7 @@
 #include <asm/uaccess.h>
 #include <linux/moduleparam.h>
 
-static int emu8000_reset_addr = 0;
+static int emu8000_reset_addr;
 module_param(emu8000_reset_addr, int, 0444);
 MODULE_PARM_DESC(emu8000_reset_addr, "reset write address at each time (makes slowdown)");
 
diff --git a/sound/isa/sb/sb16.c b/sound/isa/sb/sb16.c
index 6333f900eaee..7f7f05fa518a 100644
--- a/sound/isa/sb/sb16.c
+++ b/sound/isa/sb/sb16.c
@@ -85,7 +85,7 @@ static int dma8[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;	/* 0,1,3 */
 static int dma16[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;      /* 5,6,7 */
 static int mic_agc[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
 #ifdef CONFIG_SND_SB16_CSP
-static int csp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0};
+static int csp[SNDRV_CARDS];
 #endif
 #ifdef SNDRV_SBAWE_EMU8000
 static int seq_ports[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 4};
diff --git a/sound/isa/sb/sb16_csp.c b/sound/isa/sb/sb16_csp.c
index 9703c68e4e08..fcd638090a9e 100644
--- a/sound/isa/sb/sb16_csp.c
+++ b/sound/isa/sb/sb16_csp.c
@@ -1101,7 +1101,7 @@ static int init_proc_entry(struct snd_sb_csp * p, int device)
         struct snd_info_entry *entry;
         sprintf(name, "cspD%d", device);
         if (! snd_card_proc_new(p->chip->card, name, &entry))
-                snd_info_set_text_ops(entry, p, 1024, info_read);
+                snd_info_set_text_ops(entry, p, info_read);
         return 0;
 }
 
diff --git a/sound/isa/sb/sb8_midi.c b/sound/isa/sb/sb8_midi.c
index c549aceea294..0b67edd7ac6e 100644
--- a/sound/isa/sb/sb8_midi.c
+++ b/sound/isa/sb/sb8_midi.c
@@ -32,20 +32,22 @@
 #include <sound/core.h>
 #include <sound/sb.h>
 
-/*
-
- */
 
-irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb * chip)
+irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb *chip)
 {
         struct snd_rawmidi *rmidi;
         int max = 64;
         char byte;
 
-        if (chip == NULL || (rmidi = chip->rmidi) == NULL) {
+        if (!chip)
+                return IRQ_NONE;
+        
+        rmidi = chip->rmidi;
+        if (!rmidi) {
                 inb(SBP(chip, DATA_AVAIL));     /* ack interrupt */
                 return IRQ_NONE;
         }
+
         spin_lock(&chip->midi_input_lock);
         while (max-- > 0) {
                 if (inb(SBP(chip, DATA_AVAIL)) & 0x80) {
@@ -59,10 +61,6 @@ irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb * chip)
         return IRQ_HANDLED;
 }
 
-/*
-
- */
-
 static int snd_sb8dsp_midi_input_open(struct snd_rawmidi_substream *substream)
 {
         unsigned long flags;
@@ -252,10 +250,6 @@ static void snd_sb8dsp_midi_output_trigger(struct snd_rawmidi_substream *substre
                 snd_sb8dsp_midi_output_write(substream);
 }
 
-/*
-
- */
-
 static struct snd_rawmidi_ops snd_sb8dsp_midi_output =
 {
         .open =         snd_sb8dsp_midi_output_open,
diff --git a/sound/isa/sscape.c b/sound/isa/sscape.c
index d2a856f0fde2..27271c9446dc 100644
--- a/sound/isa/sscape.c
+++ b/sound/isa/sscape.c
@@ -897,10 +897,9 @@ static int __devinit create_mpu401(struct snd_card *card, int devnum, unsigned l
         struct snd_rawmidi *rawmidi;
         int err;
 
-#define MPU401_SHARE_HARDWARE  1
         if ((err = snd_mpu401_uart_new(card, devnum,
                                        MPU401_HW_MPU401,
-                                       port, MPU401_SHARE_HARDWARE,
+                                       port, MPU401_INFO_INTEGRATED,
                                        irq, SA_INTERRUPT,
                                        &rawmidi)) == 0) {
                 struct snd_mpu401 *mpu = (struct snd_mpu401 *) rawmidi->private_data;
diff --git a/sound/isa/wavefront/wavefront.c b/sound/isa/wavefront/wavefront.c
index 7ae86f82c3fa..9eb27082c659 100644
--- a/sound/isa/wavefront/wavefront.c
+++ b/sound/isa/wavefront/wavefront.c
@@ -50,7 +50,7 @@ static int ics2115_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;    /* 2,9,11,12,15 */
 static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;      /* PnP setup */
 static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;           /* 0,1,3,5,6,7 */
 static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;           /* 0,1,3,5,6,7 */
-static int use_cs4232_midi[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0}; 
+static int use_cs4232_midi[SNDRV_CARDS];
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for WaveFront soundcard.");
diff --git a/sound/oss/au1550_ac97.c b/sound/oss/au1550_ac97.c
index c1168fae6be6..9011abe241ab 100644
--- a/sound/oss/au1550_ac97.c
+++ b/sound/oss/au1550_ac97.c
@@ -57,9 +57,9 @@
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/hardirq.h>
-#include <asm/mach-au1x00/au1000.h>
 #include <asm/mach-au1x00/au1xxx_psc.h>
 #include <asm/mach-au1x00/au1xxx_dbdma.h>
+#include <asm/mach-au1x00/au1xxx.h>
 
 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
 
diff --git a/sound/oss/cs46xx.c b/sound/oss/cs46xx.c
index 53881bc91bba..994c71e986e4 100644
--- a/sound/oss/cs46xx.c
+++ b/sound/oss/cs46xx.c
@@ -147,7 +147,7 @@
  * that should be printed on any released driver.
  */
 #if CSDEBUG
-#define CS_DBGOUT(mask,level,x) if((cs_debuglevel >= (level)) && ((mask) & cs_debugmask)) {x;} 
+#define CS_DBGOUT(mask,level,x) if ((cs_debuglevel >= (level)) && ((mask) & cs_debugmask)) {x;}
 #else
 #define CS_DBGOUT(mask,level,x) 
 #endif
@@ -175,19 +175,19 @@
 #define CS_IOCTL_CMD_RESUME     0x2     // resume
 
 #if CSDEBUG
-static unsigned long cs_debuglevel=1;                   /* levels range from 1-9 */
+static unsigned long cs_debuglevel = 1;                 /* levels range from 1-9 */
 module_param(cs_debuglevel, ulong, 0644);
-static unsigned long cs_debugmask=CS_INIT | CS_ERROR;   /* use CS_DBGOUT with various mask values */
+static unsigned long cs_debugmask = CS_INIT | CS_ERROR; /* use CS_DBGOUT with various mask values */
 module_param(cs_debugmask, ulong, 0644);
 #endif
 static unsigned long hercules_egpio_disable;  /* if non-zero set all EGPIO to 0 */
 module_param(hercules_egpio_disable, ulong, 0);
-static unsigned long initdelay=700;  /* PM delay in millisecs */
+static unsigned long initdelay = 700;  /* PM delay in millisecs */
 module_param(initdelay, ulong, 0);
-static unsigned long powerdown=-1;  /* turn on/off powerdown processing in driver */
+static unsigned long powerdown = -1;  /* turn on/off powerdown processing in driver */
 module_param(powerdown, ulong, 0);
 #define DMABUF_DEFAULTORDER 3
-static unsigned long defaultorder=DMABUF_DEFAULTORDER;
+static unsigned long defaultorder = DMABUF_DEFAULTORDER;
 module_param(defaultorder, ulong, 0);
 
 static int external_amp;
@@ -200,8 +200,8 @@ module_param(thinkpad, bool, 0);
 * powerdown. also set thinkpad to 1 to disable powerdown, 
 * but also to enable the clkrun functionality.
 */
-static unsigned cs_powerdown=1;
-static unsigned cs_laptop_wait=1;
+static unsigned cs_powerdown = 1;
+static unsigned cs_laptop_wait = 1;
 
 /* An instance of the 4610 channel */
 struct cs_channel 
@@ -319,7 +319,7 @@ struct cs_card {
         atomic_t mixer_use_cnt;
 
         /* PCI device stuff */
-        struct pci_dev * pci_dev;
+        struct pci_dev *pci_dev;
         struct list_head list;
 
         unsigned int pctl, cctl;        /* Hardware DMA flag sets */
@@ -384,7 +384,7 @@ struct cs_card {
 static int cs_open_mixdev(struct inode *inode, struct file *file);
 static int cs_release_mixdev(struct inode *inode, struct file *file);
 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
-                                unsigned long arg);
+                        unsigned long arg);
 static int cs_hardware_init(struct cs_card *card);
 static int cs46xx_powerup(struct cs_card *card, unsigned int type);
 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag);
@@ -423,8 +423,7 @@ static void printioctl(unsigned int x)
                 [SOUND_MIXER_VOLUME]  = 9    /* Master Volume */
         };
         
-    switch(x) 
-    {
+    switch (x) {
         case SOUND_MIXER_CS_GETDBGMASK:
                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGMASK: ") );
                 break;
@@ -521,7 +520,6 @@ static void printioctl(unsigned int x)
         case SOUND_PCM_READ_FILTER:
                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_FILTER: ") );
                 break;
-
         case SOUND_MIXER_PRIVATE1:
                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE1: ") );
                 break;
@@ -543,10 +541,8 @@ static void printioctl(unsigned int x)
         case SOUND_OLD_MIXER_INFO:
                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_OLD_MIXER_INFO: ") );
                 break;
-
         default:
-                switch (_IOC_NR(x)) 
-                {
+                switch (_IOC_NR(x)) {
                         case SOUND_MIXER_VOLUME:
                                 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_VOLUME: ") );
                                 break;
@@ -579,14 +575,11 @@ static void printioctl(unsigned int x)
                                 break;
                         default:
                                 i = _IOC_NR(x);
-                                if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i]))
-                                {
+                                if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i])) {
                                         CS_DBGOUT(CS_IOCTL, 4, printk("UNKNOWN IOCTL: 0x%.8x NR=%d ",x,i) );
-                                }
-                                else
-                                {
+                                } else {
                                         CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_IOCTL AC9x: 0x%.8x NR=%d ",
-                                                        x,i) );
+                                                        x,i));
                                 }
                                 break;
                 }
@@ -601,22 +594,22 @@ static void printioctl(unsigned int x)
 
 static void cs461x_poke(struct cs_card *codec, unsigned long reg, unsigned int val)
 {
-        writel(val, codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
+        writel(val, codec->ba1.idx[(reg >> 16) & 3] + (reg & 0xffff));
 }
 
 static unsigned int cs461x_peek(struct cs_card *codec, unsigned long reg)
 {
-        return readl(codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
+        return readl(codec->ba1.idx[(reg >> 16) & 3] + (reg & 0xffff));
 }
 
 static void cs461x_pokeBA0(struct cs_card *codec, unsigned long reg, unsigned int val)
 {
-        writel(val, codec->ba0+reg);
+        writel(val, codec->ba0 + reg);
 }
 
 static unsigned int cs461x_peekBA0(struct cs_card *codec, unsigned long reg)
 {
-        return readl(codec->ba0+reg);
+        return readl(codec->ba0 + reg);
 }
 
 
@@ -625,26 +618,26 @@ static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
 
 static struct cs_channel *cs_alloc_pcm_channel(struct cs_card *card)
 {
-        if(card->channel[1].used==1)
+        if (card->channel[1].used == 1)
                 return NULL;
-        card->channel[1].used=1;
-        card->channel[1].num=1;
+        card->channel[1].used = 1;
+        card->channel[1].num = 1;
         return &card->channel[1];
 }
 
 static struct cs_channel *cs_alloc_rec_pcm_channel(struct cs_card *card)
 {
-        if(card->channel[0].used==1)
+        if (card->channel[0].used == 1)
                 return NULL;
-        card->channel[0].used=1;
-        card->channel[0].num=0;
+        card->channel[0].used = 1;
+        card->channel[0].num = 0;
         return &card->channel[0];
 }
 
 static void cs_free_pcm_channel(struct cs_card *card, int channel)
 {
         card->channel[channel].state = NULL;
-        card->channel[channel].used=0;
+        card->channel[channel].used = 0;
 }
 
 /*
@@ -655,15 +648,15 @@ static void cs_free_pcm_channel(struct cs_card *card, int channel)
  */
 static void cs_set_divisor(struct dmabuf *dmabuf)
 {
-        if(dmabuf->type == CS_TYPE_DAC)
+        if (dmabuf->type == CS_TYPE_DAC)
                 dmabuf->divisor = 1;
-        else if( !(dmabuf->fmt & CS_FMT_STEREO) && 
+        else if (!(dmabuf->fmt & CS_FMT_STEREO) &&
             (dmabuf->fmt & CS_FMT_16BIT))
                 dmabuf->divisor = 2;
-        else if( (dmabuf->fmt & CS_FMT_STEREO) && 
+        else if ((dmabuf->fmt & CS_FMT_STEREO) &&
             !(dmabuf->fmt & CS_FMT_16BIT))
                 dmabuf->divisor = 2;
-        else if( !(dmabuf->fmt & CS_FMT_STEREO) && 
+        else if (!(dmabuf->fmt & CS_FMT_STEREO) &&
             !(dmabuf->fmt & CS_FMT_16BIT))
                 dmabuf->divisor = 4;
         else
@@ -680,13 +673,12 @@ static void cs_set_divisor(struct dmabuf *dmabuf)
 */
 static void cs_mute(struct cs_card *card, int state) 
 {
-        struct ac97_codec *dev=card->ac97_codec[0];
+        struct ac97_codec *dev = card->ac97_codec[0];
 
         CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()+ %s\n",
-                (state == CS_TRUE) ? "Muting" : "UnMuting") );
+                (state == CS_TRUE) ? "Muting" : "UnMuting"));
 
-        if(state == CS_TRUE)
-        {
+        if (state == CS_TRUE) {
         /*
         * fix pops when powering up on thinkpads
         */
@@ -703,9 +695,7 @@ static void cs_mute(struct cs_card *card, int state)
                 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
                 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
                 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
-        }
-        else
-        {
+        } else {
                 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, card->pm.u32AC97_master_volume);
                 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, card->pm.u32AC97_headphone_volume);
                 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, card->pm.u32AC97_master_volume_mono);
@@ -757,7 +747,6 @@ static unsigned int cs_set_dac_rate(struct cs_state * state, unsigned int rate)
         /*
          *  Fill in the SampleRateConverter control block.
          */
-         
         spin_lock_irqsave(&state->card->lock, flags);
         cs461x_poke(state->card, BA1_PSRC,
           ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
@@ -770,7 +759,7 @@ static unsigned int cs_set_dac_rate(struct cs_state * state, unsigned int rate)
 }
 
 /* set recording sample rate */
-static unsigned int cs_set_adc_rate(struct cs_state * state, unsigned int rate)
+static unsigned int cs_set_adc_rate(struct cs_state *state, unsigned int rate)
 {
         struct dmabuf *dmabuf = &state->dmabuf;
         struct cs_card *card = state->card;
@@ -815,7 +804,6 @@ static unsigned int cs_set_adc_rate(struct cs_state * state, unsigned int rate)
          *          dividend:remainder(ulOther / GOF_PER_SEC)
          *     initialDelay = dividend(((24 * Fs,in) + Fs,out - 1) / Fs,out)
          */
-
         tmp1 = rate << 16;
         coeffIncr = tmp1 / 48000;
         tmp1 -= coeffIncr * 48000;
@@ -891,7 +879,7 @@ static void cs_play_setup(struct cs_state *state)
 
         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()+\n") );
         cs461x_poke(card, BA1_PVOL, 0x80008000);
-        if(!dmabuf->SGok)
+        if (!dmabuf->SGok)
                cs461x_poke(card, BA1_PBA, virt_to_bus(dmabuf->pbuf));
     
         Count = 4;                                                          
@@ -899,16 +887,14 @@ static void cs_play_setup(struct cs_state *state)
         if ((dmabuf->fmt & CS_FMT_STEREO)) {                                
                 playFormat &= ~DMA_RQ_C2_AC_MONO_TO_STEREO;                 
                 Count *= 2;                                                 
-        }                                                                   
-        else                                                                
+        } else
                 playFormat |= DMA_RQ_C2_AC_MONO_TO_STEREO;                  
                                                                             
         if ((dmabuf->fmt & CS_FMT_16BIT)) {                                 
                 playFormat &= ~(DMA_RQ_C2_AC_8_TO_16_BIT                    
                            | DMA_RQ_C2_AC_SIGNED_CONVERT);                  
                 Count *= 2;                                                 
-        }                                                                   
-        else                                                                
+        } else
                 playFormat |= (DMA_RQ_C2_AC_8_TO_16_BIT                     
                            | DMA_RQ_C2_AC_SIGNED_CONVERT);                  
                                                                             
@@ -919,7 +905,6 @@ static void cs_play_setup(struct cs_state *state)
         cs461x_poke(card, BA1_PDTC, tmp | --Count);                         
 
         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()-\n") );
-
 }
 
 static struct InitStruct
@@ -944,8 +929,7 @@ static void SetCaptureSPValues(struct cs_card *card)
 {
         unsigned i, offset;
         CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()+\n") );
-        for(i=0; i<sizeof(InitArray)/sizeof(struct InitStruct); i++)
-        {
+        for (i = 0; i < sizeof(InitArray) / sizeof(struct InitStruct); i++) {
                 offset = InitArray[i].off*4; /* 8bit to 32bit offset value */
                 cs461x_poke(card, offset, InitArray[i].val );
         }
@@ -957,8 +941,8 @@ static void cs_rec_setup(struct cs_state *state)
 {
         struct cs_card *card = state->card;
         struct dmabuf *dmabuf = &state->dmabuf;
-        CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()+\n") );
 
+        CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()+\n"));
         SetCaptureSPValues(card);
 
         /*
@@ -994,14 +978,11 @@ static inline unsigned cs_get_dma_addr(struct cs_state *state)
         /*
          * granularity is byte boundary, good part.
          */
-        if(dmabuf->enable & DAC_RUNNING)
-        {
+        if (dmabuf->enable & DAC_RUNNING)
                 offset = cs461x_peek(state->card, BA1_PBA);                                  
-        }
         else /* ADC_RUNNING must be set */
-        {
                 offset = cs461x_peek(state->card, BA1_CBA);                                  
-        }
+
         CS_DBGOUT(CS_PARMS | CS_FUNCTION, 9, 
                 printk("cs46xx: cs_get_dma_addr() %d\n",offset) );
         offset = (u32)bus_to_virt((unsigned long)offset) - (u32)dmabuf->rawbuf;
@@ -1015,8 +996,7 @@ static void resync_dma_ptrs(struct cs_state *state)
         struct dmabuf *dmabuf;
         
         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()+ \n") );
-        if(state)
-        {
+        if (state) {
                 dmabuf = &state->dmabuf;
                 dmabuf->hwptr=dmabuf->swptr = 0;
                 dmabuf->pringbuf = 0;
@@ -1149,13 +1129,13 @@ static int alloc_dmabuf(struct cs_state *state)
 /*
 * check for order within limits, but do not overwrite value.
 */
-        if((defaultorder > 1) && (defaultorder < 12))
+        if ((defaultorder > 1) && (defaultorder < 12))
                 df = defaultorder;
         else
                 df = 2; 
 
         for (order = df; order >= DMABUF_MINORDER; order--)
-                if ( (rawbuf = (void *) pci_alloc_consistent(
+                if ((rawbuf = (void *)pci_alloc_consistent(
                         card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr)))
                             break;
         if (!rawbuf) {
@@ -1181,8 +1161,7 @@ static int alloc_dmabuf(struct cs_state *state)
 /*
 *  only allocate the conversion buffer for the ADC
 */
-        if(dmabuf->type == CS_TYPE_DAC)
-        {
+        if (dmabuf->type == CS_TYPE_DAC) {
                 dmabuf->tmpbuff = NULL;
                 dmabuf->buforder_tmpbuff = 0;
                 return 0;
@@ -1258,8 +1237,7 @@ static int __prog_dmabuf(struct cs_state *state)
 /*
  * check for CAPTURE and use only non-sg for initial release
  */
-        if(dmabuf->type == CS_TYPE_ADC)
-        {
+        if (dmabuf->type == CS_TYPE_ADC) {
                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() ADC\n"));
                 /* 
                  * add in non-sg support for capture.
@@ -1313,9 +1291,7 @@ static int __prog_dmabuf(struct cs_state *state)
 
                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- 0 \n"));
                 return 0;
-        }
-        else if (dmabuf->type == CS_TYPE_DAC)
-        {
+        } else if (dmabuf->type == CS_TYPE_DAC) {
         /*
          * Must be DAC
          */
@@ -1337,8 +1313,7 @@ static int __prog_dmabuf(struct cs_state *state)
                 allocated_pages = 1 << dmabuf->buforder;                            
                 allocated_bytes = allocated_pages*PAGE_SIZE;                        
                                                                                     
-                if(allocated_pages < 2)                                             
-                {
+                if (allocated_pages < 2) {
                         CS_DBGOUT(CS_FUNCTION, 4, printk(
                             "cs46xx: prog_dmabuf() Error: allocated_pages too small (%d)\n",
                                 (unsigned)allocated_pages));
@@ -1353,14 +1328,14 @@ static int __prog_dmabuf(struct cs_state *state)
                                                                                     
                      /* Set up S/G variables. */
                 *ptmp = virt_to_bus(dmabuf->rawbuf);                                
-                *(ptmp+1) = 0x00000008;                                             
-                for(tmp1= 1; tmp1 < nSGpages; tmp1++) {                             
-                        *(ptmp+2*tmp1) = virt_to_bus( (dmabuf->rawbuf)+4096*tmp1);  
-                        if( tmp1 == nSGpages-1)                                     
+                *(ptmp + 1) = 0x00000008;
+                for (tmp1 = 1; tmp1 < nSGpages; tmp1++) {
+                        *(ptmp + 2 * tmp1) = virt_to_bus((dmabuf->rawbuf) + 4096 * tmp1);
+                        if (tmp1 == nSGpages - 1)
                                 tmp2 = 0xbfff0000;
                         else                                                        
-                                tmp2 = 0x80000000+8*(tmp1+1);                       
-                        *(ptmp+2*tmp1+1) = tmp2;                                    
+                                tmp2 = 0x80000000 + 8 * (tmp1 + 1);
+                        *(ptmp + 2 * tmp1 + 1) = tmp2;
                 }                                                                   
                 SGarray[0] = 0x82c0200d;                                            
                 SGarray[1] = 0xffff0000;                                            
@@ -1368,18 +1343,17 @@ static int __prog_dmabuf(struct cs_state *state)
                 SGarray[3] = 0x00010600;                                            
                 SGarray[4] = *(ptmp+2);                                             
                 SGarray[5] = 0x80000010;                                            
-                SGarray[6] = *ptmp;                                                 
-                SGarray[7] = *(ptmp+2);                                             
-                SGarray[8] = (virt_to_bus(dmabuf->pbuf) & 0xffff000) | 0x10;        
-
-                if (dmabuf->SGok) {                                                 
-                        dmabuf->numfrag = nSGpages;                                 
-                        dmabuf->fragsize = 4096;                                    
-                        dmabuf->fragsamples = 4096 >> sample_shift[dmabuf->fmt];    
-                        dmabuf->fragshift = 12;                                     
-                        dmabuf->dmasize = dmabuf->numfrag*4096;                     
-                }                                                                   
-                else {                                                              
+                SGarray[6] = *ptmp;
+                SGarray[7] = *(ptmp+2);
+                SGarray[8] = (virt_to_bus(dmabuf->pbuf) & 0xffff000) | 0x10;
+
+                if (dmabuf->SGok) {
+                        dmabuf->numfrag = nSGpages;
+                        dmabuf->fragsize = 4096;
+                        dmabuf->fragsamples = 4096 >> sample_shift[dmabuf->fmt];
+                        dmabuf->fragshift = 12;
+                        dmabuf->dmasize = dmabuf->numfrag * 4096;
+                } else {
                         SGarray[0] = 0xf2c0000f;                                    
                         SGarray[1] = 0x00000200;                                    
                         SGarray[2] = 0;                                             
@@ -1391,8 +1365,8 @@ static int __prog_dmabuf(struct cs_state *state)
                         dmabuf->dmasize = 4096;                                     
                         dmabuf->fragshift = 11;                                     
                 }
-                for(tmp1 = 0; tmp1 < sizeof(SGarray)/4; tmp1++)                     
-                        cs461x_poke( state->card, BA1_PDTC+tmp1*4, SGarray[tmp1]);  
+                for (tmp1 = 0; tmp1 < sizeof(SGarray) / 4; tmp1++)
+                        cs461x_poke(state->card, BA1_PDTC+tmp1 * 4, SGarray[tmp1]);
 
                 memset(dmabuf->rawbuf, (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
                        dmabuf->dmasize);
@@ -1416,9 +1390,7 @@ static int __prog_dmabuf(struct cs_state *state)
 
                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- \n"));
                 return 0;
-        }
-        else
-        {
+        } else {
                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- Invalid Type %d\n",
                         dmabuf->type));
         }
@@ -1489,8 +1461,7 @@ static int drain_dac(struct cs_state *state, int nonblock)
         }
         remove_wait_queue(&dmabuf->wait, &wait);
         current->state = TASK_RUNNING;
-        if (signal_pending(current))
-        {
+        if (signal_pending(current)) {
                 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- -ERESTARTSYS\n"));
                 /*
                 * set to silence and let that clear the fifos.
@@ -1514,8 +1485,7 @@ static void cs_update_ptr(struct cs_card *card, int wake)
 
         /* error handling and process wake up for ADC */
         state = card->states[0];
-        if(state)
-        {
+        if (state) {
                 dmabuf = &state->dmabuf;
                 if (dmabuf->enable & ADC_RUNNING) {
                         /* update hardware pointer */
@@ -1531,12 +1501,10 @@ static void cs_update_ptr(struct cs_card *card, int wake)
                         if (dmabuf->count > dmabuf->dmasize)
                                 dmabuf->count = dmabuf->dmasize;
 
-                        if(dmabuf->mapped)
-                        {
+                        if (dmabuf->mapped) {
                                 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
                                         wake_up(&dmabuf->wait);
-                        } else 
-                        {
+                        } else {
                                 if (wake && dmabuf->count > 0)
                                         wake_up(&dmabuf->wait);
                         }
@@ -1547,8 +1515,7 @@ static void cs_update_ptr(struct cs_card *card, int wake)
  * Now the DAC
  */
         state = card->states[1];
-        if(state)
-        {
+        if (state) {
                 dmabuf = &state->dmabuf;
                 /* error handling and process wake up for DAC */
                 if (dmabuf->enable & DAC_RUNNING) {
@@ -1570,7 +1537,7 @@ static void cs_update_ptr(struct cs_card *card, int wake)
                                  * in that, since dmasize is the buffer asked for
                                  * via mmap.
                                  */
-                                if( dmabuf->count > dmabuf->dmasize)
+                                if (dmabuf->count > dmabuf->dmasize)
                                         dmabuf->count &= dmabuf->dmasize-1;
                         } else {
                                 dmabuf->count -= diff;
@@ -1578,13 +1545,10 @@ static void cs_update_ptr(struct cs_card *card, int wake)
                                  * backfill with silence and clear out the last 
                                  * "diff" number of bytes.
                                  */
-                                if(hwptr >= diff)
-                                {
+                                if (hwptr >= diff) {
                                         memset(dmabuf->rawbuf + hwptr - diff, 
                                                 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80, diff);
-                                }
-                                else
-                                {
+                                } else {
                                         memset(dmabuf->rawbuf, 
                                                 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
                                                 (unsigned)hwptr);
@@ -1602,12 +1566,12 @@ static void cs_update_ptr(struct cs_card *card, int wake)
                                         * buffer underrun or buffer overrun, reset the
                                         * count of bytes written back to 0.
                                         */
-                                        if(dmabuf->count < 0)
-                                                dmabuf->underrun=1;
+                                        if (dmabuf->count < 0)
+                                                dmabuf->underrun = 1;
                                         dmabuf->count = 0;
                                         dmabuf->error++;
                                 }
-                                if (wake && dmabuf->count < (signed)dmabuf->dmasize/2)
+                                if (wake && dmabuf->count < (signed)dmabuf->dmasize / 2)
                                         wake_up(&dmabuf->wait);
                         }
                 }
@@ -1661,8 +1625,7 @@ static irqreturn_t cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 
         status = cs461x_peekBA0(card, BA0_HISR);
         
-        if ((status & 0x7fffffff) == 0)
-        {
+        if ((status & 0x7fffffff) == 0) {
                 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
                 spin_unlock(&card->lock);
                 return IRQ_HANDLED;     /* Might be IRQ_NONE.. */
@@ -1671,15 +1634,14 @@ static irqreturn_t cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         /*
          * check for playback or capture interrupt only
          */
-        if( ((status & HISR_VC0) && playstate && playstate->dmabuf.ready) || 
-            (((status & HISR_VC1) && recstate && recstate->dmabuf.ready)) )
-        {
+        if (((status & HISR_VC0) && playstate && playstate->dmabuf.ready) ||
+            (((status & HISR_VC1) && recstate && recstate->dmabuf.ready))) {
                 CS_DBGOUT(CS_INTERRUPT, 8, printk(
                         "cs46xx: cs_interrupt() interrupt bit(s) set (0x%x)\n",status));
                 cs_update_ptr(card, CS_TRUE);
         }
 
-        if( status & HISR_MIDI )
+        if (status & HISR_MIDI)
                 cs_handle_midi(card);
         
         /* clear 'em */
@@ -1694,7 +1656,7 @@ static irqreturn_t cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 
 static ssize_t cs_midi_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 {
-        struct cs_card *card = (struct cs_card *)file->private_data;
+        struct cs_card *card = file->private_data;
         ssize_t ret;
         unsigned long flags;
         unsigned ptr;
@@ -1737,7 +1699,7 @@ static ssize_t cs_midi_read(struct file *file, char __user *buffer, size_t count
 
 static ssize_t cs_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
-        struct cs_card *card = (struct cs_card *)file->private_data;
+        struct cs_card *card = file->private_data;
         ssize_t ret;
         unsigned long flags;
         unsigned ptr;
@@ -1785,7 +1747,7 @@ static ssize_t cs_midi_write(struct file *file, const char __user *buffer, size_
 
 static unsigned int cs_midi_poll(struct file *file, struct poll_table_struct *wait)
 {
-        struct cs_card *card = (struct cs_card *)file->private_data;
+        struct cs_card *card = file->private_data;
         unsigned long flags;
         unsigned int mask = 0;
 
@@ -1810,12 +1772,11 @@ static unsigned int cs_midi_poll(struct file *file, struct poll_table_struct *wa
 static int cs_midi_open(struct inode *inode, struct file *file)
 {
         unsigned int minor = iminor(inode);
-        struct cs_card *card=NULL;
+        struct cs_card *card = NULL;
         unsigned long flags;
         struct list_head *entry;
 
-        list_for_each(entry, &cs46xx_devs)
-        {
+        list_for_each(entry, &cs46xx_devs) {
                 card = list_entry(entry, struct cs_card, list);
                 if (card->dev_midi == minor)
                         break;
@@ -1823,8 +1784,7 @@ static int cs_midi_open(struct inode *inode, struct file *file)
 
         if (entry == &cs46xx_devs)
                 return -ENODEV;
-        if (!card)
-        {
+        if (!card) {
                 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
                         "cs46xx: cs46xx_midi_open(): Error - unable to find card struct\n"));
                 return -ENODEV;
@@ -1852,12 +1812,10 @@ static int cs_midi_open(struct inode *inode, struct file *file)
                 cs461x_pokeBA0(card, BA0_MIDCR, 0x0000000f);            /* Enable xmit, rcv. */
                 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);   /* Enable interrupts */
         }
-        if (file->f_mode & FMODE_READ) {
+        if (file->f_mode & FMODE_READ)
                 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
-        }
-        if (file->f_mode & FMODE_WRITE) {
+        if (file->f_mode & FMODE_WRITE)
                 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
-        }
         spin_unlock_irqrestore(&card->midi.lock, flags);
         card->midi.open_mode |= (file->f_mode & (FMODE_READ | FMODE_WRITE));
         mutex_unlock(&card->midi.open_mutex);
@@ -1867,7 +1825,7 @@ static int cs_midi_open(struct inode *inode, struct file *file)
 
 static int cs_midi_release(struct inode *inode, struct file *file)
 {
-        struct cs_card *card = (struct cs_card *)file->private_data;
+        struct cs_card *card = file->private_data;
         DECLARE_WAITQUEUE(wait, current);
         unsigned long flags;
         unsigned count, tmo;
@@ -1933,11 +1891,10 @@ static /*const*/ struct file_operations cs_midi_fops = {
 static void CopySamples(char *dst, char *src, int count, unsigned fmt, 
                 struct dmabuf *dmabuf)
 {
-
     s32 s32AudioSample;
-    s16 *psSrc=(s16 *)src;
-    s16 *psDst=(s16 *)dst;
-    u8 *pucDst=(u8 *)dst;
+    s16 *psSrc = (s16 *)src;
+    s16 *psDst = (s16 *)dst;
+    u8 *pucDst = (u8 *)dst;
 
     CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: CopySamples()+ ") );
     CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
@@ -1947,34 +1904,29 @@ static void CopySamples(char *dst, char *src, int count, unsigned fmt,
     /*
      * See if the data should be output as 8-bit unsigned stereo.
      */
-    if((fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
-    {
+    if ((fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT)) {
         /*
          * Convert each 16-bit signed stereo sample to 8-bit unsigned 
          * stereo using rounding.
          */
         psSrc = (s16 *)src;
-        count = count/2;
-        while(count--)
-        {
+        count = count / 2;
+        while (count--)
             *(pucDst++) = (u8)(((s16)(*psSrc++) + (s16)0x8000) >> 8);
-        }
     }
     /*
      * See if the data should be output at 8-bit unsigned mono.
      */
-    else if(!(fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
-    {
+    else if (!(fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT)) {
         /*
          * Convert each 16-bit signed stereo sample to 8-bit unsigned 
          * mono using averaging and rounding.
          */
         psSrc = (s16 *)src;
-        count = count/2;
-        while(count--)
-        {
-            s32AudioSample = ((*psSrc)+(*(psSrc + 1)))/2 + (s32)0x80;
-            if(s32AudioSample > 0x7fff)
+        count = count / 2;
+        while (count--) {
+            s32AudioSample = ((*psSrc) + (*(psSrc + 1))) / 2 + (s32)0x80;
+            if (s32AudioSample > 0x7fff)
                 s32AudioSample = 0x7fff;
             *(pucDst++) = (u8)(((s16)s32AudioSample + (s16)0x8000) >> 8);
             psSrc += 2;
@@ -1983,17 +1935,15 @@ static void CopySamples(char *dst, char *src, int count, unsigned fmt,
     /*
      * See if the data should be output at 16-bit signed mono.
      */
-    else if(!(fmt & CS_FMT_STEREO) && (fmt & CS_FMT_16BIT))
-    {
+    else if (!(fmt & CS_FMT_STEREO) && (fmt & CS_FMT_16BIT)) {
         /*
          * Convert each 16-bit signed stereo sample to 16-bit signed 
          * mono using averaging.
          */
         psSrc = (s16 *)src;
-        count = count/2;
-        while(count--)
-        {
-            *(psDst++) = (s16)((*psSrc)+(*(psSrc + 1)))/2;
+        count = count / 2;
+        while (count--) {
+            *(psDst++) = (s16)((*psSrc) + (*(psSrc + 1))) / 2;
             psSrc += 2;
         }
     }
@@ -2020,20 +1970,15 @@ static unsigned cs_copy_to_user(
                 "cs_copy_to_user()+ fmt=0x%x cnt=%d dest=%p\n",
                 dmabuf->fmt,(unsigned)cnt,dest) );
 
-        if(cnt > dmabuf->dmasize)
-        {
+        if (cnt > dmabuf->dmasize)
                 cnt = dmabuf->dmasize;
-        }
-        if(!cnt)
-        {
+        if (!cnt) {
                 *copied = 0;
                 return 0;
         }
-        if(dmabuf->divisor != 1)
-        {
-                if(!dmabuf->tmpbuff)
-                {
-                        *copied = cnt/dmabuf->divisor;
+        if (dmabuf->divisor != 1) {
+                if (!dmabuf->tmpbuff) {
+                        *copied = cnt / dmabuf->divisor;
                         return 0;
                 }
 
@@ -2042,17 +1987,16 @@ static unsigned cs_copy_to_user(
                 src = dmabuf->tmpbuff;
                 cnt = cnt/dmabuf->divisor;
         }
-        if (copy_to_user(dest, src, cnt))
-        {
+        if (copy_to_user(dest, src, cnt)) {
                 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_ERR 
                         "cs46xx: cs_copy_to_user()- fault dest=%p src=%p cnt=%d\n",
-                                dest,src,cnt) );
+                                dest,src,cnt));
                 *copied = 0;
                 return -EFAULT;
         }
         *copied = cnt;
         CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO 
-                "cs46xx: cs_copy_to_user()- copied bytes is %d \n",cnt) );
+                "cs46xx: cs_copy_to_user()- copied bytes is %d \n",cnt));
         return 0;
 }
 
@@ -2060,7 +2004,7 @@ static unsigned cs_copy_to_user(
    the user's buffer.  it is filled by the dma machine and drained by this loop. */
 static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
 {
-        struct cs_card *card = (struct cs_card *) file->private_data;
+        struct cs_card *card = file->private_data;
         struct cs_state *state;
         DECLARE_WAITQUEUE(wait, current);
         struct dmabuf *dmabuf;
@@ -2068,12 +2012,12 @@ static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, lof
         unsigned long flags;
         unsigned swptr;
         int cnt;
-        unsigned copied=0;
+        unsigned copied = 0;
 
         CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4, 
                 printk("cs46xx: cs_read()+ %zd\n",count) );
-        state = (struct cs_state *)card->states[0];
-        if(!state)
+        state = card->states[0];
+        if (!state)
                 return -ENODEV;
         dmabuf = &state->dmabuf;
 
@@ -2088,11 +2032,11 @@ static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, lof
 
         add_wait_queue(&state->dmabuf.wait, &wait);
         while (count > 0) {
-                while(!(card->pm.flags & CS46XX_PM_IDLE))
-                {
+                while (!(card->pm.flags & CS46XX_PM_IDLE)) {
                         schedule();
                         if (signal_pending(current)) {
-                                if(!ret) ret = -ERESTARTSYS;
+                                if (!ret)
+                                        ret = -ERESTARTSYS;
                                 goto out;
                         }
                 }
@@ -2112,19 +2056,20 @@ static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, lof
                            recorded */
                         start_adc(state);
                         if (file->f_flags & O_NONBLOCK) {
-                                if (!ret) ret = -EAGAIN;
+                                if (!ret)
+                                        ret = -EAGAIN;
                                 goto out;
                         }
                         mutex_unlock(&state->sem);
                         schedule();
                         if (signal_pending(current)) {
-                                if(!ret) ret = -ERESTARTSYS;
+                                if (!ret)
+                                        ret = -ERESTARTSYS;
                                 goto out;
                         }
                         mutex_lock(&state->sem);
-                        if (dmabuf->mapped) 
-                        {
-                                if(!ret)
+                        if (dmabuf->mapped) {
+                                if (!ret)
                                         ret = -ENXIO;
                                 goto out;
                         }
@@ -2135,12 +2080,12 @@ static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, lof
                         "_read() copy_to cnt=%d count=%zd ", cnt,count) );
                 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO 
                         " .dmasize=%d .count=%d buffer=%p ret=%zd\n",
-                        dmabuf->dmasize,dmabuf->count,buffer,ret) );
+                        dmabuf->dmasize,dmabuf->count,buffer,ret));
 
                 if (cs_copy_to_user(state, buffer, 
-                        (char *)dmabuf->rawbuf + swptr, cnt, &copied))
-                {
-                        if (!ret) ret = -EFAULT;
+                        (char *)dmabuf->rawbuf + swptr, cnt, &copied)) {
+                        if (!ret)
+                                ret = -EFAULT;
                         goto out;
                 }
                 swptr = (swptr + cnt) % dmabuf->dmasize;
@@ -2167,7 +2112,7 @@ out2:
    the soundcard.  it is drained by the dma machine and filled by this loop. */
 static ssize_t cs_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
 {
-        struct cs_card *card = (struct cs_card *) file->private_data;
+        struct cs_card *card = file->private_data;
         struct cs_state *state;
         DECLARE_WAITQUEUE(wait, current);
         struct dmabuf *dmabuf;
@@ -2178,16 +2123,15 @@ static ssize_t cs_write(struct file *file, const char __user *buffer, size_t cou
 
         CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 4,
                 printk("cs46xx: cs_write called, count = %zd\n", count) );
-        state = (struct cs_state *)card->states[1];
-        if(!state)
+        state = card->states[1];
+        if (!state)
                 return -ENODEV;
         if (!access_ok(VERIFY_READ, buffer, count))
                 return -EFAULT;
         dmabuf = &state->dmabuf;
 
         mutex_lock(&state->sem);
-        if (dmabuf->mapped)
-        {
+        if (dmabuf->mapped) {
                 ret = -ENXIO;
                 goto out;
         }
@@ -2201,11 +2145,11 @@ static ssize_t cs_write(struct file *file, const char __user *buffer, size_t cou
 * check for PM events and underrun/overrun in the loop.
 */
         while (count > 0) {
-                while(!(card->pm.flags & CS46XX_PM_IDLE))
-                {
+                while (!(card->pm.flags & CS46XX_PM_IDLE)) {
                         schedule();
                         if (signal_pending(current)) {
-                                if(!ret) ret = -ERESTARTSYS;
+                                if (!ret)
+                                        ret = -ERESTARTSYS;
                                 goto out;
                         }
                 }
@@ -2216,8 +2160,7 @@ static ssize_t cs_write(struct file *file, const char __user *buffer, size_t cou
                         dmabuf->count = 0;
                         dmabuf->swptr = dmabuf->hwptr;
                 }
-                if (dmabuf->underrun)
-                {
+                if (dmabuf->underrun) {
                         dmabuf->underrun = 0;
                         dmabuf->hwptr = cs_get_dma_addr(state);
                         dmabuf->swptr = dmabuf->hwptr;
@@ -2238,34 +2181,35 @@ static ssize_t cs_write(struct file *file, const char __user *buffer, size_t cou
                            played */
                         start_dac(state);
                         if (file->f_flags & O_NONBLOCK) {
-                                if (!ret) ret = -EAGAIN;
+                                if (!ret)
+                                        ret = -EAGAIN;
                                 goto out;
                         }
                         mutex_unlock(&state->sem);
                         schedule();
                         if (signal_pending(current)) {
-                                if(!ret) ret = -ERESTARTSYS;
+                                if (!ret)
+                                        ret = -ERESTARTSYS;
                                 goto out;
                         }
                         mutex_lock(&state->sem);
-                        if (dmabuf->mapped)
-                        {
-                                if(!ret)
+                        if (dmabuf->mapped) {
+                                if (!ret)
                                         ret = -ENXIO;
                                 goto out;
                         }
                         continue;
                 }
                 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
-                        if (!ret) ret = -EFAULT;
+                        if (!ret)
+                                ret = -EFAULT;
                         goto out;
                 }
                 spin_lock_irqsave(&state->card->lock, flags);
                 swptr = (swptr + cnt) % dmabuf->dmasize;
                 dmabuf->swptr = swptr;
                 dmabuf->count += cnt;
-                if(dmabuf->count > dmabuf->dmasize)
-                {
+                if (dmabuf->count > dmabuf->dmasize) {
                         CS_DBGOUT(CS_WAVE_WRITE | CS_ERROR, 2, printk(
                             "cs46xx: cs_write() d->count > dmasize - resetting\n"));
                         dmabuf->count = dmabuf->dmasize;
@@ -2284,38 +2228,32 @@ out:
         set_current_state(TASK_RUNNING);
 
         CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 2, 
-                printk("cs46xx: cs_write()- ret=%zd\n", ret) );
+                printk("cs46xx: cs_write()- ret=%zd\n", ret));
         return ret;
 }
 
 static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
 {
-        struct cs_card *card = (struct cs_card *)file->private_data;
+        struct cs_card *card = file->private_data;
         struct dmabuf *dmabuf;
         struct cs_state *state;
-
         unsigned long flags;
         unsigned int mask = 0;
 
         CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()+ \n"));
-        if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
-        {
+        if (!(file->f_mode & (FMODE_WRITE | FMODE_READ))) {
                 return -EINVAL;
         }
-        if (file->f_mode & FMODE_WRITE)
-        {
+        if (file->f_mode & FMODE_WRITE) {
                 state = card->states[1];
-                if(state)
-                {
+                if (state) {
                         dmabuf = &state->dmabuf;
                         poll_wait(file, &dmabuf->wait, wait);
                 }
         }
-        if (file->f_mode & FMODE_READ)
-        {
+        if (file->f_mode & FMODE_READ) {
                 state = card->states[0];
-                if(state)
-                {
+                if (state) {
                         dmabuf = &state->dmabuf;
                         poll_wait(file, &dmabuf->wait, wait);
                 }
@@ -2325,8 +2263,7 @@ static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
         cs_update_ptr(card, CS_FALSE);
         if (file->f_mode & FMODE_READ) {
                 state = card->states[0];
-                if(state)
-                {
+                if (state) {
                         dmabuf = &state->dmabuf;
                         if (dmabuf->count >= (signed)dmabuf->fragsize)
                                 mask |= POLLIN | POLLRDNORM;
@@ -2334,8 +2271,7 @@ static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
         }
         if (file->f_mode & FMODE_WRITE) {
                 state = card->states[1];
-                if(state)
-                {
+                if (state) {
                         dmabuf = &state->dmabuf;
                         if (dmabuf->mapped) {
                                 if (dmabuf->count >= (signed)dmabuf->fragsize)
@@ -2364,7 +2300,7 @@ static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
  
 static int cs_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct cs_card *card = (struct cs_card *)file->private_data;
+        struct cs_card *card = file->private_data;
         struct cs_state *state;
         struct dmabuf *dmabuf;
         int ret = 0;
@@ -2376,8 +2312,7 @@ static int cs_mmap(struct file *file, struct vm_area_struct *vma)
 
         if (vma->vm_flags & VM_WRITE) {
                 state = card->states[1];
-                if(state)
-                {
+                if (state) {
                         CS_DBGOUT(CS_OPEN, 2, printk(
                           "cs46xx: cs_mmap() VM_WRITE - state TRUE prog_dmabuf DAC\n") );
                         if ((ret = prog_dmabuf(state)) != 0)
@@ -2385,8 +2320,7 @@ static int cs_mmap(struct file *file, struct vm_area_struct *vma)
                 }
         } else if (vma->vm_flags & VM_READ) {
                 state = card->states[0];
-                if(state)
-                {
+                if (state) {
                         CS_DBGOUT(CS_OPEN, 2, printk(
                           "cs46xx: cs_mmap() VM_READ - state TRUE prog_dmabuf ADC\n") );
                         if ((ret = prog_dmabuf(state)) != 0)
@@ -2414,8 +2348,7 @@ static int cs_mmap(struct file *file, struct vm_area_struct *vma)
 
         mutex_lock(&state->sem);
         dmabuf = &state->dmabuf;
-        if (cs4x_pgoff(vma) != 0)
-        {
+        if (cs4x_pgoff(vma) != 0) {
                 ret = -EINVAL;
                 goto out;
         }
@@ -2423,15 +2356,13 @@ static int cs_mmap(struct file *file, struct vm_area_struct *vma)
 
         CS_DBGOUT(CS_PARMS, 2, printk("cs46xx: cs_mmap(): size=%d\n",(unsigned)size) );
 
-        if (size > (PAGE_SIZE << dmabuf->buforder))
-        {
+        if (size > (PAGE_SIZE << dmabuf->buforder)) {
                 ret = -EINVAL;
                 goto out;
         }
         if (remap_pfn_range(vma, vma->vm_start,
                              virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
-                             size, vma->vm_page_prot))
-        {
+                             size, vma->vm_page_prot)) {
                 ret = -EAGAIN;
                 goto out;
         }
@@ -2445,25 +2376,24 @@ out:
 
 static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct cs_card *card = (struct cs_card *)file->private_data;
+        struct cs_card *card = file->private_data;
         struct cs_state *state;
-        struct dmabuf *dmabuf=NULL;
+        struct dmabuf *dmabuf = NULL;
         unsigned long flags;
         audio_buf_info abinfo;
         count_info cinfo;
-        int val, valsave, mapped, ret;
+        int val, valsave, ret;
+        int mapped = 0;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
 
-        state = (struct cs_state *)card->states[0];
-        if(state)
-        {
+        state = card->states[0];
+        if (state) {
                 dmabuf = &state->dmabuf;
                 mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
         }
-        state = (struct cs_state *)card->states[1];
-        if(state)
-        {
+        state = card->states[1];
+        if (state) {
                 dmabuf = &state->dmabuf;
                 mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
         }
@@ -2472,17 +2402,14 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
         printioctl(cmd);
 #endif
 
-        switch (cmd) 
-        {
+        switch (cmd) {
         case OSS_GETVERSION:
                 return put_user(SOUND_VERSION, p);
-
         case SNDCTL_DSP_RESET:
                 /* FIXME: spin_lock ? */
                 if (file->f_mode & FMODE_WRITE) {
-                        state = (struct cs_state *)card->states[1];
-                        if(state)
-                        {
+                        state = card->states[1];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 stop_dac(state);
                                 synchronize_irq(card->irq);
@@ -2495,9 +2422,8 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         }
                 }
                 if (file->f_mode & FMODE_READ) {
-                        state = (struct cs_state *)card->states[0];
-                        if(state)
-                        {
+                        state = card->states[0];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 stop_adc(state);
                                 synchronize_irq(card->irq);
@@ -2511,20 +2437,17 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                 }
                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
                 return 0;
-
         case SNDCTL_DSP_SYNC:
                 if (file->f_mode & FMODE_WRITE)
                         return drain_dac(state, file->f_flags & O_NONBLOCK);
                 return 0;
-
         case SNDCTL_DSP_SPEED: /* set sample rate */
                 if (get_user(val, p))
                         return -EFAULT;
                 if (val >= 0) {
                         if (file->f_mode & FMODE_READ) {
-                                state = (struct cs_state *)card->states[0];
-                                if(state)
-                                {
+                                state = card->states[0];
+                                if (state) {
                                         dmabuf = &state->dmabuf;
                                         stop_adc(state);
                                         dmabuf->ready = 0;
@@ -2534,9 +2457,8 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                                 }
                         }
                         if (file->f_mode & FMODE_WRITE) {
-                                state = (struct cs_state *)card->states[1];
-                                if(state)
-                                {
+                                state = card->states[1];
+                                if (state) {
                                         dmabuf = &state->dmabuf;
                                         stop_dac(state);
                                         dmabuf->ready = 0;
@@ -2553,19 +2475,17 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         return put_user(dmabuf->rate, p);
                 }
                 return put_user(0, p);
-
         case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
                 if (get_user(val, p))
                         return -EFAULT;
                 if (file->f_mode & FMODE_WRITE) {
-                        state = (struct cs_state *)card->states[1];
-                        if(state)
-                        {
+                        state = card->states[1];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 stop_dac(state);
                                 dmabuf->ready = 0;
                                 dmabuf->SGok = 0;
-                                if(val)
+                                if (val)
                                         dmabuf->fmt |= CS_FMT_STEREO;
                                 else
                                         dmabuf->fmt &= ~CS_FMT_STEREO;
@@ -2577,14 +2497,13 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         }
                 }
                 if (file->f_mode & FMODE_READ) {
-                        state = (struct cs_state *)card->states[0];
-                        if(state)
-                        {
+                        state = card->states[0];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 stop_adc(state);
                                 dmabuf->ready = 0;
                                 dmabuf->SGok = 0;
-                                if(val)
+                                if (val)
                                         dmabuf->fmt |= CS_FMT_STEREO;
                                 else
                                         dmabuf->fmt &= ~CS_FMT_STEREO;
@@ -2596,12 +2515,10 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         }
                 }
                 return 0;
-
         case SNDCTL_DSP_GETBLKSIZE:
                 if (file->f_mode & FMODE_WRITE) {
-                        state = (struct cs_state *)card->states[1];
-                        if(state)
-                        {
+                        state = card->states[1];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 if ((val = prog_dmabuf(state)))
                                         return val;
@@ -2609,9 +2526,8 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         }
                 }
                 if (file->f_mode & FMODE_READ) {
-                        state = (struct cs_state *)card->states[0];
-                        if(state)
-                        {
+                        state = card->states[0];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 if ((val = prog_dmabuf(state)))
                                         return val;
@@ -2620,10 +2536,8 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         }
                 }
                 return put_user(0, p);
-
         case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
                 return put_user(AFMT_S16_LE | AFMT_U8, p);
-
         case SNDCTL_DSP_SETFMT: /* Select sample format */
                 if (get_user(val, p))
                         return -EFAULT;
@@ -2635,88 +2549,75 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         val == AFMT_U8 ? "8Bit Unsigned" : "") );
                 valsave = val;
                 if (val != AFMT_QUERY) {
-                        if(val==AFMT_S16_LE || val==AFMT_U8)
-                        {
+                        if (val==AFMT_S16_LE || val==AFMT_U8) {
                                 if (file->f_mode & FMODE_WRITE) {
-                                        state = (struct cs_state *)card->states[1];
-                                        if(state)
-                                        {
+                                        state = card->states[1];
+                                        if (state) {
                                                 dmabuf = &state->dmabuf;
                                                 stop_dac(state);
                                                 dmabuf->ready = 0;
                                                 dmabuf->SGok = 0;
-                                                if(val==AFMT_S16_LE)
+                                                if (val == AFMT_S16_LE)
                                                         dmabuf->fmt |= CS_FMT_16BIT;
                                                 else
                                                         dmabuf->fmt &= ~CS_FMT_16BIT;
                                                 cs_set_divisor(dmabuf);
-                                                if((ret = prog_dmabuf(state)))
+                                                if ((ret = prog_dmabuf(state)))
                                                         return ret;
                                         }
                                 }
                                 if (file->f_mode & FMODE_READ) {
                                         val = valsave;
-                                        state = (struct cs_state *)card->states[0];
-                                        if(state)
-                                        {
+                                        state = card->states[0];
+                                        if (state) {
                                                 dmabuf = &state->dmabuf;
                                                 stop_adc(state);
                                                 dmabuf->ready = 0;
                                                 dmabuf->SGok = 0;
-                                                if(val==AFMT_S16_LE)
+                                                if (val == AFMT_S16_LE)
                                                         dmabuf->fmt |= CS_FMT_16BIT;
                                                 else
                                                         dmabuf->fmt &= ~CS_FMT_16BIT;
                                                 cs_set_divisor(dmabuf);
-                                                if((ret = prog_dmabuf(state)))
+                                                if ((ret = prog_dmabuf(state)))
                                                         return ret;
                                         }
                                 }
-                        }
-                        else
-                        {
+                        } else {
                                 CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
                                     "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
                                         valsave) );
                         }
-                }
-                else
-                {
-                        if(file->f_mode & FMODE_WRITE)
-                        {
-                                state = (struct cs_state *)card->states[1];
-                                if(state)
+                } else {
+                        if (file->f_mode & FMODE_WRITE) {
+                                state = card->states[1];
+                                if (state)
                                         dmabuf = &state->dmabuf;
-                        }
-                        else if(file->f_mode & FMODE_READ)
-                        {
-                                state = (struct cs_state *)card->states[0];
-                                if(state)
+                        } else if (file->f_mode & FMODE_READ) {
+                                state = card->states[0];
+                                if (state)
                                         dmabuf = &state->dmabuf;
                         }
                 }
-                if(dmabuf)
-                {
-                        if(dmabuf->fmt & CS_FMT_16BIT)
+                if (dmabuf) {
+                        if (dmabuf->fmt & CS_FMT_16BIT)
                                 return put_user(AFMT_S16_LE, p);
                         else
                                 return put_user(AFMT_U8, p);
                 }
                 return put_user(0, p);
-
         case SNDCTL_DSP_CHANNELS:
                 if (get_user(val, p))
                         return -EFAULT;
                 if (val != 0) {
                         if (file->f_mode & FMODE_WRITE) {
-                                state = (struct cs_state *)card->states[1];
-                                if(state)
-                                {
+                                state = card->states[1];
+                                if (state) {
                                         dmabuf = &state->dmabuf;
                                         stop_dac(state);
                                         dmabuf->ready = 0;
                                         dmabuf->SGok = 0;
-                                        if(val>1)
+                                        if (val > 1)
                                                 dmabuf->fmt |= CS_FMT_STEREO;
                                         else
                                                 dmabuf->fmt &= ~CS_FMT_STEREO;
@@ -2726,14 +2627,13 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                                 }
                         }
                         if (file->f_mode & FMODE_READ) {
-                                state = (struct cs_state *)card->states[0];
-                                if(state)
-                                {
+                                state = card->states[0];
+                                if (state) {
                                         dmabuf = &state->dmabuf;
                                         stop_adc(state);
                                         dmabuf->ready = 0;
                                         dmabuf->SGok = 0;
-                                        if(val>1)
+                                        if (val > 1)
                                                 dmabuf->fmt |= CS_FMT_STEREO;
                                         else
                                                 dmabuf->fmt &= ~CS_FMT_STEREO;
@@ -2745,19 +2645,16 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                 }
                 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
                                 p);
-
         case SNDCTL_DSP_POST:
                 /*
                  * There will be a longer than normal pause in the data.
                  * so... do nothing, because there is nothing that we can do.
                  */
                 return 0;
-
         case SNDCTL_DSP_SUBDIVIDE:
                 if (file->f_mode & FMODE_WRITE) {
-                        state = (struct cs_state *)card->states[1];
-                        if(state)
-                        {
+                        state = card->states[1];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 if (dmabuf->subdivision)
                                         return -EINVAL;
@@ -2769,9 +2666,8 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         }
                 }
                 if (file->f_mode & FMODE_READ) {
-                        state = (struct cs_state *)card->states[0];
-                        if(state)
-                        {
+                        state = card->states[0];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 if (dmabuf->subdivision)
                                         return -EINVAL;
@@ -2783,37 +2679,31 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         }
                 }
                 return 0;
-
         case SNDCTL_DSP_SETFRAGMENT:
                 if (get_user(val, p))
                         return -EFAULT;
-
                 if (file->f_mode & FMODE_WRITE) {
-                        state = (struct cs_state *)card->states[1];
-                        if(state)
-                        {
+                        state = card->states[1];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 dmabuf->ossfragshift = val & 0xffff;
                                 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
                         }
                 }
                 if (file->f_mode & FMODE_READ) {
-                        state = (struct cs_state *)card->states[0];
-                        if(state)
-                        {
+                        state = card->states[0];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 dmabuf->ossfragshift = val & 0xffff;
                                 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
                         }
                 }
                 return 0;
-
         case SNDCTL_DSP_GETOSPACE:
                 if (!(file->f_mode & FMODE_WRITE))
                         return -EINVAL;
-                state = (struct cs_state *)card->states[1];
-                if(state)
-                {
+                state = card->states[1];
+                if (state) {
                         dmabuf = &state->dmabuf;
                         spin_lock_irqsave(&state->card->lock, flags);
                         cs_update_ptr(card, CS_TRUE);
@@ -2832,13 +2722,11 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
                 }
                 return -ENODEV;
-
         case SNDCTL_DSP_GETISPACE:
                 if (!(file->f_mode & FMODE_READ))
                         return -EINVAL;
-                state = (struct cs_state *)card->states[0];
-                if(state)
-                {
+                state = card->states[0];
+                if (state) {
                         dmabuf = &state->dmabuf;
                         spin_lock_irqsave(&state->card->lock, flags);
                         cs_update_ptr(card, CS_TRUE);
@@ -2850,48 +2738,39 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
                 }
                 return -ENODEV;
-
         case SNDCTL_DSP_NONBLOCK:
                 file->f_flags |= O_NONBLOCK;
                 return 0;
-
         case SNDCTL_DSP_GETCAPS:
                 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
                             p);
-
         case SNDCTL_DSP_GETTRIGGER:
                 val = 0;
                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
-                if (file->f_mode & FMODE_WRITE)
-                {
-                        state = (struct cs_state *)card->states[1];
-                        if(state)
-                        {
+                if (file->f_mode & FMODE_WRITE) {
+                        state = card->states[1];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
-                                if(dmabuf->enable & DAC_RUNNING)
+                                if (dmabuf->enable & DAC_RUNNING)
                                         val |= PCM_ENABLE_INPUT;
                         }
                 }
-                if (file->f_mode & FMODE_READ)
-                {
-                        if(state)
-                        {
-                                state = (struct cs_state *)card->states[0];
+                if (file->f_mode & FMODE_READ) {
+                        if (state) {
+                                state = card->states[0];
                                 dmabuf = &state->dmabuf;
-                                if(dmabuf->enable & ADC_RUNNING)
+                                if (dmabuf->enable & ADC_RUNNING)
                                         val |= PCM_ENABLE_OUTPUT;
                         }
                 }
                 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
                 return put_user(val, p);
-
         case SNDCTL_DSP_SETTRIGGER:
                 if (get_user(val, p))
                         return -EFAULT;
                 if (file->f_mode & FMODE_READ) {
-                        state = (struct cs_state *)card->states[0];
-                        if(state)
-                        {
+                        state = card->states[0];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 if (val & PCM_ENABLE_INPUT) {
                                         if (!dmabuf->ready && (ret = prog_dmabuf(state)))
@@ -2902,9 +2781,8 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         }
                 }
                 if (file->f_mode & FMODE_WRITE) {
-                        state = (struct cs_state *)card->states[1];
-                        if(state)
-                        {
+                        state = card->states[1];
+                        if (state) {
                                 dmabuf = &state->dmabuf;
                                 if (val & PCM_ENABLE_OUTPUT) {
                                         if (!dmabuf->ready && (ret = prog_dmabuf(state)))
@@ -2915,13 +2793,11 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         }
                 }
                 return 0;
-
         case SNDCTL_DSP_GETIPTR:
                 if (!(file->f_mode & FMODE_READ))
                         return -EINVAL;
-                state = (struct cs_state *)card->states[0];
-                if(state)
-                {
+                state = card->states[0];
+                if (state) {
                         dmabuf = &state->dmabuf;
                         spin_lock_irqsave(&state->card->lock, flags);
                         cs_update_ptr(card, CS_TRUE);
@@ -2934,28 +2810,23 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         return 0;
                 }
                 return -ENODEV;
-
         case SNDCTL_DSP_GETOPTR:
                 if (!(file->f_mode & FMODE_WRITE))
                         return -EINVAL;
-                state = (struct cs_state *)card->states[1];
-                if(state)
-                {
+                state = card->states[1];
+                if (state) {
                         dmabuf = &state->dmabuf;
                         spin_lock_irqsave(&state->card->lock, flags);
                         cs_update_ptr(card, CS_TRUE);
                         cinfo.bytes = dmabuf->total_bytes;
-                        if (dmabuf->mapped)
-                        {
+                        if (dmabuf->mapped) {
                                 cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift) 
                                                         - dmabuf->blocks;
                                 CS_DBGOUT(CS_PARMS, 8, 
                                         printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n", 
                                         cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
                                 dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
-                        }
-                        else
-                        {
+                        } else {
                                 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
                         }
                         cinfo.ptr = dmabuf->hwptr;
@@ -2969,66 +2840,54 @@ static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
                         return 0;
                 }
                 return -ENODEV;
-
         case SNDCTL_DSP_SETDUPLEX:
                 return 0;
-
         case SNDCTL_DSP_GETODELAY:
                 if (!(file->f_mode & FMODE_WRITE))
                         return -EINVAL;
-                state = (struct cs_state *)card->states[1];
-                if(state)
-                {
+                state = card->states[1];
+                if (state) {
                         dmabuf = &state->dmabuf;
                         spin_lock_irqsave(&state->card->lock, flags);
                         cs_update_ptr(card, CS_TRUE);
                         val = dmabuf->count;
                         spin_unlock_irqrestore(&state->card->lock, flags);
-                }
-                else
+                } else
                         val = 0;
                 return put_user(val, p);
-
         case SOUND_PCM_READ_RATE:
-                if(file->f_mode & FMODE_READ)
-                        state = (struct cs_state *)card->states[0];
+                if (file->f_mode & FMODE_READ)
+                        state = card->states[0];
                 else 
-                        state = (struct cs_state *)card->states[1];
-                if(state)
-                {
+                        state = card->states[1];
+                if (state) {
                         dmabuf = &state->dmabuf;
                         return put_user(dmabuf->rate, p);
                 }
                 return put_user(0, p);
-                
-
         case SOUND_PCM_READ_CHANNELS:
-                if(file->f_mode & FMODE_READ)
-                        state = (struct cs_state *)card->states[0];
+                if (file->f_mode & FMODE_READ)
+                        state = card->states[0];
                 else 
-                        state = (struct cs_state *)card->states[1];
-                if(state)
-                {
+                        state = card->states[1];
+                if (state) {
                         dmabuf = &state->dmabuf;
                         return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
                                 p);
                 }
                 return put_user(0, p);
-
         case SOUND_PCM_READ_BITS:
-                if(file->f_mode & FMODE_READ)
-                        state = (struct cs_state *)card->states[0];
+                if (file->f_mode & FMODE_READ)
+                        state = card->states[0];
                 else 
-                        state = (struct cs_state *)card->states[1];
-                if(state)
-                {
+                        state = card->states[1];
+                if (state) {
                         dmabuf = &state->dmabuf;
                         return put_user((dmabuf->fmt & CS_FMT_16BIT) ? 
                                 AFMT_S16_LE : AFMT_U8, p);
 
                 }
                 return put_user(0, p);
-
         case SNDCTL_DSP_MAPINBUF:
         case SNDCTL_DSP_MAPOUTBUF:
         case SNDCTL_DSP_SETSYNCRO:
@@ -3057,18 +2916,15 @@ static void amp_voyetra(struct cs_card *card, int change)
         /* Manage the EAPD bit on the Crystal 4297 
            and the Analog AD1885 */
            
-        int old=card->amplifier;
+        int old = card->amplifier;
         
         card->amplifier+=change;
-        if(card->amplifier && !old)
-        {
+        if (card->amplifier && !old) {
                 /* Turn the EAPD amp on */
                 cs_ac97_set(card->ac97_codec[0],  AC97_POWER_CONTROL, 
                         cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
                                 0x8000);
-        }
-        else if(old && !card->amplifier)
-        {
+        } else if(old && !card->amplifier) {
                 /* Turn the EAPD amp off */
                 cs_ac97_set(card->ac97_codec[0],  AC97_POWER_CONTROL, 
                         cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
@@ -3083,25 +2939,21 @@ static void amp_voyetra(struct cs_card *card, int change)
  
 static void amp_hercules(struct cs_card *card, int change)
 {
-        int old=card->amplifier;
-        if(!card)
-        {
+        int old = card->amplifier;
+        if (!card) {
                 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO 
                         "cs46xx: amp_hercules() called before initialized.\n"));
                 return;
         }
         card->amplifier+=change;
-        if( (card->amplifier && !old) && !(hercules_egpio_disable))
-        {
+        if ((card->amplifier && !old) && !(hercules_egpio_disable)) {
                 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO 
                         "cs46xx: amp_hercules() external amp enabled\n"));
                 cs461x_pokeBA0(card, BA0_EGPIODR, 
                         EGPIODR_GPOE2);     /* enable EGPIO2 output */
                 cs461x_pokeBA0(card, BA0_EGPIOPTR, 
                         EGPIOPTR_GPPT2);   /* open-drain on output */
-        }
-        else if(old && !card->amplifier)
-        {
+        } else if (old && !card->amplifier) {
                 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO 
                         "cs46xx: amp_hercules() external amp disabled\n"));
                 cs461x_pokeBA0(card, BA0_EGPIODR, 0); /* disable */
@@ -3124,31 +2976,28 @@ static void clkrun_hack(struct cs_card *card, int change)
         u16 control;
         u8 pp;
         unsigned long port;
-        int old=card->active;
+        int old = card->active;
         
         card->active+=change;
         
         acpi_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
-        if(acpi_dev == NULL)
+        if (acpi_dev == NULL)
                 return;         /* Not a thinkpad thats for sure */
 
         /* Find the control port */             
         pci_read_config_byte(acpi_dev, 0x41, &pp);
-        port=pp<<8;
+        port = pp << 8;
 
         /* Read ACPI port */    
-        control=inw(port+0x10);
+        control = inw(port + 0x10);
 
         /* Flip CLKRUN off while running */
-        if(!card->active && old)
-        {
+        if (!card->active && old) {
                 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
                         "cs46xx: clkrun() enable clkrun - change=%d active=%d\n",
                                 change,card->active));
                 outw(control|0x2000, port+0x10);
-        }
-        else 
-        {
+        } else {
         /*
         * sometimes on a resume the bit is set, so always reset the bit.
         */
@@ -3162,20 +3011,19 @@ static void clkrun_hack(struct cs_card *card, int change)
         
 static int cs_open(struct inode *inode, struct file *file)
 {
-        struct cs_card *card = (struct cs_card *)file->private_data;
+        struct cs_card *card = file->private_data;
         struct cs_state *state = NULL;
         struct dmabuf *dmabuf = NULL;
         struct list_head *entry;
         unsigned int minor = iminor(inode);
-        int ret=0;
+        int ret = 0;
         unsigned int tmp;
 
         CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=%p %s %s\n",
                 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
                 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
 
-        list_for_each(entry, &cs46xx_devs)
-        {
+        list_for_each(entry, &cs46xx_devs) {
                 card = list_entry(entry, struct cs_card, list);
 
                 if (!((card->dev_audio ^ minor) & ~0xf))
@@ -3192,11 +3040,10 @@ static int cs_open(struct inode *inode, struct file *file)
         /*
          * hardcode state[0] for capture, [1] for playback
          */
-        if(file->f_mode & FMODE_READ)
-        {
+        if (file->f_mode & FMODE_READ) {
                 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
                 if (card->states[0] == NULL) {
-                        state = card->states[0] = (struct cs_state *)
+                        state = card->states[0] =
                                 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
                         if (state == NULL)
                                 return -ENOMEM;
@@ -3204,36 +3051,32 @@ static int cs_open(struct inode *inode, struct file *file)
                         mutex_init(&state->sem);
                         dmabuf = &state->dmabuf;
                         dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
-                        if(dmabuf->pbuf==NULL)
-                        {
+                        if (dmabuf->pbuf == NULL) {
                                 kfree(state);
-                                card->states[0]=NULL;
+                                card->states[0] = NULL;
                                 return -ENOMEM;
                         }
-                }
-                else
-                {
+                } else {
                         state = card->states[0];
-                        if(state->open_mode & FMODE_READ)
+                        if (state->open_mode & FMODE_READ)
                                 return -EBUSY;
                 }
                 dmabuf->channel = card->alloc_rec_pcm_channel(card);
                         
                 if (dmabuf->channel == NULL) {
-                        kfree (card->states[0]);
+                        kfree(card->states[0]);
                         card->states[0] = NULL;
                         return -ENODEV;
                 }
 
                 /* Now turn on external AMP if needed */
                 state->card = card;
-                state->card->active_ctrl(state->card,1);
-                state->card->amplifier_ctrl(state->card,1);
+                state->card->active_ctrl(state->card, 1);
+                state->card->amplifier_ctrl(state->card, 1);
                 
-                if( (tmp = cs46xx_powerup(card, CS_POWER_ADC)) )
-                {
+                if ((tmp = cs46xx_powerup(card, CS_POWER_ADC))) {
                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO 
-                                "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n",tmp) );
+                                "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n", tmp));
                         return -EIO;
                 }
 
@@ -3263,11 +3106,10 @@ static int cs_open(struct inode *inode, struct file *file)
                 state->open_mode |= FMODE_READ;
                 mutex_unlock(&state->open_mutex);
         }
-        if(file->f_mode & FMODE_WRITE)
-        {
+        if (file->f_mode & FMODE_WRITE) {
                 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
                 if (card->states[1] == NULL) {
-                        state = card->states[1] = (struct cs_state *)
+                        state = card->states[1] =
                                 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
                         if (state == NULL)
                                 return -ENOMEM;
@@ -3275,36 +3117,32 @@ static int cs_open(struct inode *inode, struct file *file)
                         mutex_init(&state->sem);
                         dmabuf = &state->dmabuf;
                         dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
-                        if(dmabuf->pbuf==NULL)
-                        {
+                        if (dmabuf->pbuf == NULL) {
                                 kfree(state);
-                                card->states[1]=NULL;
+                                card->states[1] = NULL;
                                 return -ENOMEM;
                         }
-                }
-                else
-                {
+                } else {
                         state = card->states[1];
-                        if(state->open_mode & FMODE_WRITE)
+                        if (state->open_mode & FMODE_WRITE)
                                 return -EBUSY;
                 }
                 dmabuf->channel = card->alloc_pcm_channel(card);
                         
                 if (dmabuf->channel == NULL) {
-                        kfree (card->states[1]);
+                        kfree(card->states[1]);
                         card->states[1] = NULL;
                         return -ENODEV;
                 }
 
                 /* Now turn on external AMP if needed */
                 state->card = card;
-                state->card->active_ctrl(state->card,1);
-                state->card->amplifier_ctrl(state->card,1);
+                state->card->active_ctrl(state->card, 1);
+                state->card->amplifier_ctrl(state->card, 1);
 
-                if( (tmp = cs46xx_powerup(card, CS_POWER_DAC)) )
-                {
+                if ((tmp = cs46xx_powerup(card, CS_POWER_DAC))) {
                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO 
-                                "cs46xx: cs46xx_powerup of DAC failed (0x%x)\n",tmp) );
+                                "cs46xx: cs46xx_powerup of DAC failed (0x%x)\n", tmp));
                         return -EIO;
                 }
                 
@@ -3333,33 +3171,29 @@ static int cs_open(struct inode *inode, struct file *file)
 
                 state->open_mode |= FMODE_WRITE;
                 mutex_unlock(&state->open_mutex);
-                if((ret = prog_dmabuf(state)))
+                if ((ret = prog_dmabuf(state)))
                         return ret;
         }
-        CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n") );
+        CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n"));
         return nonseekable_open(inode, file);
 }
 
 static int cs_release(struct inode *inode, struct file *file)
 {
-        struct cs_card *card = (struct cs_card *)file->private_data;
+        struct cs_card *card = file->private_data;
         struct dmabuf *dmabuf;
         struct cs_state *state;
         unsigned int tmp;
         CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=%p %s %s\n",
                 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
-                file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
+                file->f_mode & FMODE_READ ? "FMODE_READ" : ""));
 
         if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
-        {
                 return -EINVAL;
-        }
         state = card->states[1];
-        if(state)
-        {
-                if ( (state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE) )
-                {
-                        CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n") );
+        if (state) {
+                if ((state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE)) {
+                        CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n"));
                         dmabuf = &state->dmabuf;
                         cs_clear_tail(state);
                         drain_dac(state, file->f_flags & O_NONBLOCK);
@@ -3375,8 +3209,7 @@ static int cs_release(struct inode *inode, struct file *file)
                         state->card->states[state->virt] = NULL;
                         state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
 
-                        if( (tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE )) )
-                        {
+                        if ((tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE))) {
                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO 
                                         "cs46xx: cs_release_mixdev() powerdown DAC failure (0x%x)\n",tmp) );
                         }
@@ -3384,17 +3217,14 @@ static int cs_release(struct inode *inode, struct file *file)
                         /* Now turn off external AMP if needed */
                         state->card->amplifier_ctrl(state->card, -1);
                         state->card->active_ctrl(state->card, -1);
-
                         kfree(state);
                 }
         }
 
         state = card->states[0];
-        if(state)
-        {
-                if ( (state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ) )
-                {
-                        CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n") );
+        if (state) {
+                if ((state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ)) {
+                        CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n"));
                         dmabuf = &state->dmabuf;
                         mutex_lock(&state->open_mutex);
                         stop_adc(state);
@@ -3407,8 +3237,7 @@ static int cs_release(struct inode *inode, struct file *file)
                         state->card->states[state->virt] = NULL;
                         state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
 
-                        if( (tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE )) )
-                        {
+                        if ((tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE))) {
                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO 
                                         "cs46xx: cs_release_mixdev() powerdown ADC failure (0x%x)\n",tmp) );
                         }
@@ -3416,12 +3245,11 @@ static int cs_release(struct inode *inode, struct file *file)
                         /* Now turn off external AMP if needed */
                         state->card->amplifier_ctrl(state->card, -1);
                         state->card->active_ctrl(state->card, -1);
-
                         kfree(state);
                 }
         }
 
-        CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n") );
+        CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n"));
         return 0;
 }
 
@@ -3474,21 +3302,18 @@ static void cs46xx_ac97_suspend(struct cs_card *card)
 
         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()+\n"));
 
-        if(card->states[1])
-        {
+        if (card->states[1]) {
                 stop_dac(card->states[1]);
                 resync_dma_ptrs(card->states[1]);
         }
-        if(card->states[0])
-        {
+        if (card->states[0]) {
                 stop_adc(card->states[0]);
                 resync_dma_ptrs(card->states[0]);
         }
 
-        for(Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
-                        && (i < CS46XX_AC97_NUMBER_RESTORE_REGS); 
-                Count += 2, i++)
-        {
+        for (Count = 0x2, i = 0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
+                        && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
+                        Count += 2, i++) {
                 card->pm.ac97[i] = cs_ac97_get(dev, BA0_AC97_RESET + Count);
         }
 /*
@@ -3522,11 +3347,10 @@ static void cs46xx_ac97_suspend(struct cs_card *card)
 * well, for now, only power down the DAC/ADC and MIXER VREFON components. 
 * trouble with removing VREF.
 */
-        if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
-                        CS_POWER_MIXVON, CS_TRUE )) )
-        {
+        if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
+                        CS_POWER_MIXVON, CS_TRUE))) {
                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO 
-                        "cs46xx: cs46xx_ac97_suspend() failure (0x%x)\n",tmp) );
+                        "cs46xx: cs46xx_ac97_suspend() failure (0x%x)\n",tmp));
         }
 
         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()-\n"));
@@ -3566,16 +3390,13 @@ static void cs46xx_ac97_resume(struct cs_card *card)
 * Restore just the first set of registers, from register number
 * 0x02 to the register number that ulHighestRegToRestore specifies.
 */
-        for(    Count = 0x2, i=0; 
-                (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
-                        && (i < CS46XX_AC97_NUMBER_RESTORE_REGS); 
-                Count += 2, i++)
-        {
+        for (Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE) &&
+                        (i < CS46XX_AC97_NUMBER_RESTORE_REGS); Count += 2, i++) {
                 cs_ac97_set(dev, (u8)(BA0_AC97_RESET + Count), (u16)card->pm.ac97[i]);
         }
 
         /* Check if we have to init the amplifier */
-        if(card->amp_init)
+        if (card->amp_init)
                 card->amp_init(card);
         
         CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()-\n"));
@@ -3585,30 +3406,27 @@ static void cs46xx_ac97_resume(struct cs_card *card)
 static int cs46xx_restart_part(struct cs_card *card)
 {
         struct dmabuf *dmabuf;
+
         CS_DBGOUT(CS_PM | CS_FUNCTION, 4, 
                 printk( "cs46xx: cs46xx_restart_part()+\n"));
-        if(card->states[1])
-        {
+        if (card->states[1]) {
                 dmabuf = &card->states[1]->dmabuf;
                 dmabuf->ready = 0;
                 resync_dma_ptrs(card->states[1]);
                 cs_set_divisor(dmabuf);
-                if(__prog_dmabuf(card->states[1]))
-                {
+                if (__prog_dmabuf(card->states[1])) {
                         CS_DBGOUT(CS_PM | CS_ERROR, 1, 
                                 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() dac error\n"));
                         return -1;
                 }
                 cs_set_dac_rate(card->states[1], dmabuf->rate);
         }
-        if(card->states[0])
-        {
+        if (card->states[0]) {
                 dmabuf = &card->states[0]->dmabuf;
                 dmabuf->ready = 0;
                 resync_dma_ptrs(card->states[0]);
                 cs_set_divisor(dmabuf);
-                if(__prog_dmabuf(card->states[0]))
-                {
+                if (__prog_dmabuf(card->states[0])) {
                         CS_DBGOUT(CS_PM | CS_ERROR, 1, 
                                 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() adc error\n"));
                         return -1;
@@ -3616,17 +3434,17 @@ static int cs46xx_restart_part(struct cs_card *card)
                 cs_set_adc_rate(card->states[0], dmabuf->rate);
         }
         card->pm.flags |= CS46XX_PM_RESUMED;
-        if(card->states[0])
+        if (card->states[0])
                 start_adc(card->states[0]);
-        if(card->states[1])
+        if (card->states[1])
                 start_dac(card->states[1]);
 
         card->pm.flags |= CS46XX_PM_IDLE;
         card->pm.flags &= ~(CS46XX_PM_SUSPENDING | CS46XX_PM_SUSPENDED 
                         | CS46XX_PM_RESUMING | CS46XX_PM_RESUMED);
-        if(card->states[0])
+        if (card->states[0])
                 wake_up(&card->states[0]->dmabuf.wait);
-        if(card->states[1])
+        if (card->states[1])
                 wake_up(&card->states[1]->dmabuf.wait);
 
         CS_DBGOUT(CS_PM | CS_FUNCTION, 4, 
@@ -3634,20 +3452,19 @@ static int cs46xx_restart_part(struct cs_card *card)
         return 0;
 }
 
-
 static void cs461x_reset(struct cs_card *card);
 static void cs461x_proc_stop(struct cs_card *card);
 static int cs46xx_suspend(struct cs_card *card, pm_message_t state)
 {
         unsigned int tmp;
+
         CS_DBGOUT(CS_PM | CS_FUNCTION, 4, 
                 printk("cs46xx: cs46xx_suspend()+ flags=0x%x s=%p\n",
                         (unsigned)card->pm.flags,card));
 /*
 * check the current state, only suspend if IDLE
 */
-        if(!(card->pm.flags & CS46XX_PM_IDLE))
-        {
+        if (!(card->pm.flags & CS46XX_PM_IDLE)) {
                 CS_DBGOUT(CS_PM | CS_ERROR, 2, 
                         printk("cs46xx: cs46xx_suspend() unable to suspend, not IDLE\n"));
                 return 1;
@@ -3679,13 +3496,11 @@ static int cs46xx_suspend(struct cs_card *card, pm_message_t state)
         tmp = cs461x_peek(card, BA1_CCTL);
         cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
 
-        if(card->states[1])
-        {
+        if (card->states[1]) {
                 card->pm.dmabuf_swptr_play = card->states[1]->dmabuf.swptr;
                 card->pm.dmabuf_count_play = card->states[1]->dmabuf.count;
         }
-        if(card->states[0])
-        {
+        if (card->states[0]) {
                 card->pm.dmabuf_swptr_capture = card->states[0]->dmabuf.swptr;
                 card->pm.dmabuf_count_capture = card->states[0]->dmabuf.count;
         }
@@ -3736,8 +3551,7 @@ static int cs46xx_resume(struct cs_card *card)
         CS_DBGOUT(CS_PM | CS_FUNCTION, 4, 
                 printk( "cs46xx: cs46xx_resume()+ flags=0x%x\n",
                         (unsigned)card->pm.flags));
-        if(!(card->pm.flags & CS46XX_PM_SUSPENDED))
-        {
+        if (!(card->pm.flags & CS46XX_PM_SUSPENDED)) {
                 CS_DBGOUT(CS_PM | CS_ERROR, 2, 
                         printk("cs46xx: cs46xx_resume() unable to resume, not SUSPENDED\n"));
                 return 1;
@@ -3747,10 +3561,8 @@ static int cs46xx_resume(struct cs_card *card)
         printpm(card);
         card->active_ctrl(card, 1);
 
-        for(i=0;i<5;i++)
-        {
-                if (cs_hardware_init(card) != 0)
-                {
+        for (i = 0; i < 5; i++) {
+                if (cs_hardware_init(card) != 0) {
                         CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
                                 "cs46xx: cs46xx_resume()- ERROR in cs_hardware_init()\n"));
                         mdelay(10 * cs_laptop_wait);
@@ -3759,15 +3571,13 @@ static int cs46xx_resume(struct cs_card *card)
                 }
                 break;
         }
-        if(i>=4)
-        {
+        if (i >= 4) {
                 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
                         "cs46xx: cs46xx_resume()- cs_hardware_init() failed, retried %d times.\n",i));
                 return 0;
         }
 
-        if(cs46xx_restart_part(card))
-        {
+        if (cs46xx_restart_part(card)) {
                 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
                         "cs46xx: cs46xx_resume(): cs46xx_restart_part() returned error\n"));
         }
@@ -3835,7 +3645,7 @@ static u16 _cs_ac97_get(struct ac97_codec *dev, u8 reg)
         /*
          *  Wait for the read to occur.
          */
-        if(!(card->pm.flags & CS46XX_PM_IDLE))
+        if (!(card->pm.flags & CS46XX_PM_IDLE))
                 loopcnt = 2000;
         else
                 loopcnt = 500 * cs_laptop_wait;
@@ -3866,7 +3676,7 @@ static u16 _cs_ac97_get(struct ac97_codec *dev, u8 reg)
          *  Wait for the valid status bit to go active.
          */
 
-        if(!(card->pm.flags & CS46XX_PM_IDLE))
+        if (!(card->pm.flags & CS46XX_PM_IDLE))
                 loopcnt = 2000;
         else
                 loopcnt = 1000;
@@ -3885,7 +3695,7 @@ static u16 _cs_ac97_get(struct ac97_codec *dev, u8 reg)
         /*
          *  Make sure we got valid status.
          */
-        if (!( (tmp=cs461x_peekBA0(card, BA0_ACSTS)) & ACSTS_VSTS)) {
+        if (!((tmp = cs461x_peekBA0(card, BA0_ACSTS)) & ACSTS_VSTS)) {
                 CS_DBGOUT(CS_ERROR, 2, printk(KERN_WARNING 
                         "cs46xx: AC'97 read problem (ACSTS_VSTS), reg = 0x%x val=0x%x 0xffff \n", 
                                 reg, tmp));
@@ -3923,12 +3733,9 @@ static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
         
         spin_lock(&card->ac97_lock);
         
-        if(reg == AC97_CD_VOL)
-        {
+        if (reg == AC97_CD_VOL)
                 val2 = _cs_ac97_get(dev, AC97_CD_VOL);
-        }
-        
-        
+
         /*
          *  1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
          *  2. Write ACCDA = Command Data Register = 470h    for data to write to AC97
@@ -3970,8 +3777,7 @@ static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
         /*
          *  Make sure the write completed.
          */
-        if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV)
-        {
+        if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING 
                         "cs46xx: AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val));
         }
@@ -3998,25 +3804,23 @@ static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
          
         /* CD mute change ? */
         
-        if(reg==AC97_CD_VOL)
-        {
+        if (reg == AC97_CD_VOL) {
                 /* Mute bit change ? */
-                if((val2^val)&0x8000 || ((val2 == 0x1f1f || val == 0x1f1f) && val2 != val))
-                {
+                if ((val2^val) & 0x8000 ||
+                    ((val2 == 0x1f1f || val == 0x1f1f) && val2 != val)) {
                         /* This is a hack but its cleaner than the alternatives.
                            Right now card->ac97_codec[0] might be NULL as we are
                            still doing codec setup. This does an early assignment
                            to avoid the problem if it occurs */
                            
-                        if(card->ac97_codec[0]==NULL)
-                                card->ac97_codec[0]=dev;
+                        if (card->ac97_codec[0] == NULL)
+                                card->ac97_codec[0] = dev;
                                 
                         /* Mute on */
-                        if(val&0x8000 || val == 0x1f1f)
+                        if (val & 0x8000 || val == 0x1f1f)
                                 card->amplifier_ctrl(card, -1);
-                        else /* Mute off power on */
-                        {
-                                if(card->amp_init)
+                        else { /* Mute off power on */
+                                if (card->amp_init)
                                         card->amp_init(card);
                                 card->amplifier_ctrl(card, 1);
                         }
@@ -4024,46 +3828,41 @@ static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
         }
 }
 
-
 /* OSS /dev/mixer file operation methods */
 
 static int cs_open_mixdev(struct inode *inode, struct file *file)
 {
-        int i=0;
+        int i = 0;
         unsigned int minor = iminor(inode);
-        struct cs_card *card=NULL;
+        struct cs_card *card = NULL;
         struct list_head *entry;
         unsigned int tmp;
 
         CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
                   printk(KERN_INFO "cs46xx: cs_open_mixdev()+\n"));
 
-        list_for_each(entry, &cs46xx_devs)
-        {
+        list_for_each(entry, &cs46xx_devs) {
                 card = list_entry(entry, struct cs_card, list);
                 for (i = 0; i < NR_AC97; i++)
                         if (card->ac97_codec[i] != NULL &&
                             card->ac97_codec[i]->dev_mixer == minor)
                                 goto match;
         }
-        if (!card)
-        {
+        if (!card) {
                 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
                         printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
                 return -ENODEV;
         }
  match:
-        if(!card->ac97_codec[i])
+        if (!card->ac97_codec[i])
                 return -ENODEV;
         file->private_data = card->ac97_codec[i];
 
         card->active_ctrl(card,1);
-        if(!CS_IN_USE(&card->mixer_use_cnt))
-        {
-                if( (tmp = cs46xx_powerup(card, CS_POWER_MIXVON )) )
-                {
+        if (!CS_IN_USE(&card->mixer_use_cnt)) {
+                if ((tmp = cs46xx_powerup(card, CS_POWER_MIXVON))) {
                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO 
-                                "cs46xx: cs_open_mixdev() powerup failure (0x%x)\n",tmp) );
+                                "cs46xx: cs_open_mixdev() powerup failure (0x%x)\n", tmp));
                         return -EIO;
                 }
         }
@@ -4077,7 +3876,7 @@ static int cs_open_mixdev(struct inode *inode, struct file *file)
 static int cs_release_mixdev(struct inode *inode, struct file *file)
 {
         unsigned int minor = iminor(inode);
-        struct cs_card *card=NULL;
+        struct cs_card *card = NULL;
         struct list_head *entry;
         int i;
         unsigned int tmp;
@@ -4092,15 +3891,13 @@ static int cs_release_mixdev(struct inode *inode, struct file *file)
                             card->ac97_codec[i]->dev_mixer == minor)
                                 goto match;
         }
-        if (!card)
-        {
+        if (!card) {
                 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
                         printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
                 return -ENODEV;
         }
 match:
-        if(!CS_DEC_AND_TEST(&card->mixer_use_cnt))
-        {
+        if (!CS_DEC_AND_TEST(&card->mixer_use_cnt)) {
                 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
                           printk(KERN_INFO "cs46xx: cs_release_mixdev()- no powerdown, usecnt>0\n"));
                 card->active_ctrl(card, -1);
@@ -4110,10 +3907,9 @@ match:
 /*
 * ok, no outstanding mixer opens, so powerdown.
 */
-        if( (tmp = cs461x_powerdown(card, CS_POWER_MIXVON, CS_FALSE )) )
-        {
+        if ((tmp = cs461x_powerdown(card, CS_POWER_MIXVON, CS_FALSE))) {
                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO 
-                        "cs46xx: cs_release_mixdev() powerdown MIXVON failure (0x%x)\n",tmp) );
+                        "cs46xx: cs_release_mixdev() powerdown MIXVON failure (0x%x)\n", tmp));
                 card->active_ctrl(card, -1);
                 card->amplifier_ctrl(card, -1);
                 return -EIO;
@@ -4126,76 +3922,60 @@ match:
 }
 
 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
-                                unsigned long arg)
+                        unsigned long arg)
 {
-        struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
-        struct cs_card *card=NULL;
+        struct ac97_codec *codec = file->private_data;
+        struct cs_card *card = NULL;
         struct list_head *entry;
         unsigned long __user *p = (long __user *)arg;
-
 #if CSDEBUG_INTERFACE
         int val;
 
-        if(     (cmd == SOUND_MIXER_CS_GETDBGMASK) || 
+        if (    (cmd == SOUND_MIXER_CS_GETDBGMASK) ||
                 (cmd == SOUND_MIXER_CS_SETDBGMASK) ||
                 (cmd == SOUND_MIXER_CS_GETDBGLEVEL) ||
                 (cmd == SOUND_MIXER_CS_SETDBGLEVEL) ||
-                (cmd == SOUND_MIXER_CS_APM))
-        {
-            switch(cmd)
-            {
-
+                (cmd == SOUND_MIXER_CS_APM)) {
+                switch (cmd) {
                 case SOUND_MIXER_CS_GETDBGMASK:
                         return put_user(cs_debugmask, p);
-                
                 case SOUND_MIXER_CS_GETDBGLEVEL:
                         return put_user(cs_debuglevel, p);
-
                 case SOUND_MIXER_CS_SETDBGMASK:
                         if (get_user(val, p))
                                 return -EFAULT;
                         cs_debugmask = val;
                         return 0;
-
                 case SOUND_MIXER_CS_SETDBGLEVEL:
                         if (get_user(val, p))
                                 return -EFAULT;
                         cs_debuglevel = val;
                         return 0;
-
                 case SOUND_MIXER_CS_APM:
                         if (get_user(val, p))
                                 return -EFAULT;
-                        if(val == CS_IOCTL_CMD_SUSPEND) 
-                        {
-                                list_for_each(entry, &cs46xx_devs)
-                                {
+                        if (val == CS_IOCTL_CMD_SUSPEND) {
+                                list_for_each(entry, &cs46xx_devs) {
                                         card = list_entry(entry, struct cs_card, list);
                                         cs46xx_suspend(card, PMSG_ON);
                                 }
 
-                        }
-                        else if(val == CS_IOCTL_CMD_RESUME)
-                        {
-                                list_for_each(entry, &cs46xx_devs)
-                                {
+                        } else if (val == CS_IOCTL_CMD_RESUME) {
+                                list_for_each(entry, &cs46xx_devs) {
                                         card = list_entry(entry, struct cs_card, list);
                                         cs46xx_resume(card);
                                 }
-                        }
-                        else
-                        {
+                        } else {
                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
                                     "cs46xx: mixer_ioctl(): invalid APM cmd (%d)\n",
                                         val));
                         }
                         return 0;
-
                 default:
                         CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO 
-                                "cs46xx: mixer_ioctl(): ERROR unknown debug cmd\n") );
+                                "cs46xx: mixer_ioctl(): ERROR unknown debug cmd\n"));
                         return 0;
-            }
+                }
         }
 #endif
         return codec->mixer_ioctl(codec, cmd, arg);
@@ -4232,8 +4012,7 @@ static int __init cs_ac97_init(struct cs_card *card)
                 codec->codec_read = cs_ac97_get;
                 codec->codec_write = cs_ac97_set;
         
-                if (ac97_probe_codec(codec) == 0)
-                {
+                if (ac97_probe_codec(codec) == 0) {
                         CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO 
                                 "cs46xx: cs_ac97_init()- codec number %d not found\n",
                                         num_ac97) );
@@ -4241,12 +4020,11 @@ static int __init cs_ac97_init(struct cs_card *card)
                         break;
                 }
                 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO 
-                        "cs46xx: cs_ac97_init() found codec %d\n",num_ac97) );
+                        "cs46xx: cs_ac97_init() found codec %d\n",num_ac97));
 
                 eid = cs_ac97_get(codec, AC97_EXTENDED_ID);
                 
-                if(eid==0xFFFF)
-                {
+                if (eid == 0xFFFF) {
                         printk(KERN_WARNING "cs46xx: codec %d not present\n",num_ac97);
                         ac97_release_codec(codec);
                         break;
@@ -4285,27 +4063,23 @@ static void cs461x_download_image(struct cs_card *card)
 {
     unsigned i, j, temp1, temp2, offset, count;
     unsigned char __iomem *pBA1 = ioremap(card->ba1_addr, 0x40000);
-    for( i=0; i < CLEAR__COUNT; i++)
-    {
+    for (i = 0; i < CLEAR__COUNT; i++) {
         offset = ClrStat[i].BA1__DestByteOffset;
         count  = ClrStat[i].BA1__SourceSize;
-        for(  temp1 = offset; temp1<(offset+count); temp1+=4 )
+        for (temp1 = offset; temp1 < (offset + count); temp1 += 4)
               writel(0, pBA1+temp1);
     }
 
-    for(i=0; i<FILL__COUNT; i++)
-    {
+    for (i = 0; i < FILL__COUNT; i++) {
         temp2 = FillStat[i].Offset;
-        for(j=0; j<(FillStat[i].Size)/4; j++)
-        {
+        for (j = 0; j < (FillStat[i].Size) / 4; j++) {
             temp1 = (FillStat[i]).pFill[j];
-            writel(temp1, pBA1+temp2+j*4);
+            writel(temp1, pBA1+temp2 + j * 4);
         }
     }
     iounmap(pBA1);
 }
 
-
 /*
  *  Chip reset
  */
@@ -4365,15 +4139,13 @@ static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type)
         * playing or capturing then we don't want to put in 128 bytes of
         * "noise".
          */
-        if(type & CS_TYPE_DAC)
-        {
+        if (type & CS_TYPE_DAC) {
                 startfifo = 128;
                 endfifo = 256;
         }
-        if(type & CS_TYPE_ADC)
-        {
+        if (type & CS_TYPE_ADC) {
                 startfifo = 0;
-                if(!endfifo)
+                if (!endfifo)
                         endfifo = 128;
         }
         /*
@@ -4417,8 +4189,7 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
 
         CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO 
                 "cs46xx: cs461x_powerdown()+ type=0x%x\n",type));
-        if(!cs_powerdown && !suspendflag)
-        {
+        if (!cs_powerdown && !suspendflag) {
                 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO 
                         "cs46xx: cs461x_powerdown() DISABLED exiting\n"));
                 return 0;
@@ -4432,12 +4203,11 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
 * currently powered down.  If powering down DAC and ADC, then
 * it is possible to power down the VREF (ON).
 */
-        if (    ((type & CS_POWER_MIXVON) && 
-                 (!(type & CS_POWER_ADC) || (!(type & CS_POWER_DAC))) )
+        if (((type & CS_POWER_MIXVON) &&
+                 (!(type & CS_POWER_ADC) || (!(type & CS_POWER_DAC))))
               && 
                 ((tmp & CS_AC97_POWER_CONTROL_ADC_ON) ||
-                 (tmp & CS_AC97_POWER_CONTROL_DAC_ON) ) )
-        {
+                 (tmp & CS_AC97_POWER_CONTROL_DAC_ON))) {
                 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO 
                         "cs46xx: cs461x_powerdown()- 0  unable to powerdown. tmp=0x%x\n",tmp));
                 return 0;
@@ -4452,8 +4222,7 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
         /*
          *  Power down indicated areas.
          */
-        if(type & CS_POWER_MIXVOFF)
-        {
+        if (type & CS_POWER_MIXVOFF) {
 
                 CS_DBGOUT(CS_FUNCTION, 4, 
                         printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVOFF\n"));
@@ -4461,12 +4230,10 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
                  *  Power down the MIXER (VREF ON) on the AC97 card.  
                  */
                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
-                if (tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON)
-                {
-                        if(!muted)
-                        {
+                if (tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON) {
+                        if (!muted) {
                                 cs_mute(card, CS_TRUE);
-                                muted=1;
+                                muted = 1;
                         }
                         tmp |= CS_AC97_POWER_CONTROL_MIXVOFF;
                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
@@ -4492,16 +4259,14 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
                          *  Check the status..
                          */
                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 
-                                CS_AC97_POWER_CONTROL_MIXVOFF_ON)
-                        {
+                                CS_AC97_POWER_CONTROL_MIXVOFF_ON) {
                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING 
                                         "cs46xx: powerdown MIXVOFF failed\n"));
                                 return 1;
                         }
                 }
         }
-        if(type & CS_POWER_MIXVON)
-        {
+        if (type & CS_POWER_MIXVON) {
 
                 CS_DBGOUT(CS_FUNCTION, 4, 
                         printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVON\n"));
@@ -4509,15 +4274,13 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
                  *  Power down the MIXER (VREF ON) on the AC97 card.  
                  */
                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
-                if (tmp & CS_AC97_POWER_CONTROL_MIXVON_ON)
-                {
-                        if(!muted)
-                        {
+                if (tmp & CS_AC97_POWER_CONTROL_MIXVON_ON) {
+                        if (!muted) {
                                 cs_mute(card, CS_TRUE);
-                                muted=1;
+                                muted = 1;
                         }
                         tmp |= CS_AC97_POWER_CONTROL_MIXVON;
-                        cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
+                        cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
                         /*
                          *  Now, we wait until we sample a ready state.
                          */
@@ -4540,30 +4303,26 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
                          *  Check the status..
                          */
                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 
-                                CS_AC97_POWER_CONTROL_MIXVON_ON)
-                        {
+                                CS_AC97_POWER_CONTROL_MIXVON_ON) {
                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING 
                                         "cs46xx: powerdown MIXVON failed\n"));
                                 return 1;
                         }
                 }
         }
-        if(type & CS_POWER_ADC)
-        {
+        if (type & CS_POWER_ADC) {
                 /*
                  *  Power down the ADC on the AC97 card.  
                  */
                 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs461x_powerdown()+ ADC\n"));
                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
-                if (tmp & CS_AC97_POWER_CONTROL_ADC_ON)
-                {
-                        if(!muted)
-                        {
+                if (tmp & CS_AC97_POWER_CONTROL_ADC_ON) {
+                        if (!muted) {
                                 cs_mute(card, CS_TRUE);
-                                muted=1;
+                                muted = 1;
                         }
                         tmp |= CS_AC97_POWER_CONTROL_ADC;
-                        cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
+                        cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
 
                         /*
                          *  Now, we wait until we sample a ready state.
@@ -4587,16 +4346,14 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
                          *  Check the status..
                          */
                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 
-                                CS_AC97_POWER_CONTROL_ADC_ON)
-                        {
+                                CS_AC97_POWER_CONTROL_ADC_ON) {
                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING 
                                         "cs46xx: powerdown ADC failed\n"));
                                 return 1;
                         }
                 }
         }
-        if(type & CS_POWER_DAC)
-        {
+        if (type & CS_POWER_DAC) {
                 /*
                  *  Power down the DAC on the AC97 card.  
                  */
@@ -4604,15 +4361,13 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
                 CS_DBGOUT(CS_FUNCTION, 4, 
                         printk(KERN_INFO "cs46xx: cs461x_powerdown()+ DAC\n"));
                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
-                if (tmp & CS_AC97_POWER_CONTROL_DAC_ON)
-                {
-                        if(!muted)
-                        {
+                if (tmp & CS_AC97_POWER_CONTROL_DAC_ON) {
+                        if (!muted) {
                                 cs_mute(card, CS_TRUE);
-                                muted=1;
+                                muted = 1;
                         }
                         tmp |= CS_AC97_POWER_CONTROL_DAC;
-                        cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
+                        cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
                         /*
                          *  Now, we wait until we sample a ready state.
                          */
@@ -4635,8 +4390,7 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
                          *  Check the status..
                          */
                         if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 
-                                CS_AC97_POWER_CONTROL_DAC_ON)
-                        {
+                                CS_AC97_POWER_CONTROL_DAC_ON) {
                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING 
                                         "cs46xx: powerdown DAC failed\n"));
                                 return 1;
@@ -4644,7 +4398,7 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
                 }
         }
         tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
-        if(muted)
+        if (muted)
                 cs_mute(card, CS_FALSE);
         CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO 
                 "cs46xx: cs461x_powerdown()- 0 tmp=0x%x\n",tmp));
@@ -4654,23 +4408,22 @@ static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspend
 static int cs46xx_powerup(struct cs_card *card, unsigned int type)
 {
         int count;
-        unsigned int tmp=0,muted=0;
+        unsigned int tmp = 0, muted = 0;
 
         CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO 
                 "cs46xx: cs46xx_powerup()+ type=0x%x\n",type));
         /*
         * check for VREF and powerup if need to.
         */
-        if(type & CS_POWER_MIXVON)
+        if (type & CS_POWER_MIXVON)
                 type |= CS_POWER_MIXVOFF;
-        if(type & (CS_POWER_DAC | CS_POWER_ADC))
+        if (type & (CS_POWER_DAC | CS_POWER_ADC))
                 type |= CS_POWER_MIXVON | CS_POWER_MIXVOFF;
 
         /*
          *  Power up indicated areas.
          */
-        if(type & CS_POWER_MIXVOFF)
-        {
+        if (type & CS_POWER_MIXVOFF) {
 
                 CS_DBGOUT(CS_FUNCTION, 4, 
                         printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVOFF\n"));
@@ -4678,12 +4431,10 @@ static int cs46xx_powerup(struct cs_card *card, unsigned int type)
                  *  Power up the MIXER (VREF ON) on the AC97 card.  
                  */
                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
-                if (!(tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON))
-                {
-                        if(!muted)
-                        {
+                if (!(tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON)) {
+                        if (!muted) {
                                 cs_mute(card, CS_TRUE);
-                                muted=1;
+                                muted = 1;
                         }
                         tmp &= ~CS_AC97_POWER_CONTROL_MIXVOFF;
                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
@@ -4709,16 +4460,14 @@ static int cs46xx_powerup(struct cs_card *card, unsigned int type)
                          *  Check the status..
                          */
                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 
-                                CS_AC97_POWER_CONTROL_MIXVOFF_ON))
-                        {
+                                CS_AC97_POWER_CONTROL_MIXVOFF_ON)) {
                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING 
                                         "cs46xx: powerup MIXVOFF failed\n"));
                                 return 1;
                         }
                 }
         }
-        if(type & CS_POWER_MIXVON)
-        {
+        if(type & CS_POWER_MIXVON) {
 
                 CS_DBGOUT(CS_FUNCTION, 4, 
                         printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVON\n"));
@@ -4726,12 +4475,10 @@ static int cs46xx_powerup(struct cs_card *card, unsigned int type)
                  *  Power up the MIXER (VREF ON) on the AC97 card.  
                  */
                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
-                if (!(tmp & CS_AC97_POWER_CONTROL_MIXVON_ON))
-                {
-                        if(!muted)
-                        {
+                if (!(tmp & CS_AC97_POWER_CONTROL_MIXVON_ON)) {
+                        if (!muted) {
                                 cs_mute(card, CS_TRUE);
-                                muted=1;
+                                muted = 1;
                         }
                         tmp &= ~CS_AC97_POWER_CONTROL_MIXVON;
                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
@@ -4757,27 +4504,23 @@ static int cs46xx_powerup(struct cs_card *card, unsigned int type)
                          *  Check the status..
                          */
                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 
-                                CS_AC97_POWER_CONTROL_MIXVON_ON))
-                        {
+                                CS_AC97_POWER_CONTROL_MIXVON_ON)) {
                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING 
                                         "cs46xx: powerup MIXVON failed\n"));
                                 return 1;
                         }
                 }
         }
-        if(type & CS_POWER_ADC)
-        {
+        if (type & CS_POWER_ADC) {
                 /*
                  *  Power up the ADC on the AC97 card.  
                  */
                 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs46xx_powerup()+ ADC\n"));
                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
-                if (!(tmp & CS_AC97_POWER_CONTROL_ADC_ON))
-                {
-                        if(!muted)
-                        {
+                if (!(tmp & CS_AC97_POWER_CONTROL_ADC_ON)) {
+                        if (!muted) {
                                 cs_mute(card, CS_TRUE);
-                                muted=1;
+                                muted = 1;
                         }
                         tmp &= ~CS_AC97_POWER_CONTROL_ADC;
                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
@@ -4804,16 +4547,14 @@ static int cs46xx_powerup(struct cs_card *card, unsigned int type)
                          *  Check the status..
                          */
                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 
-                                CS_AC97_POWER_CONTROL_ADC_ON))
-                        {
+                                CS_AC97_POWER_CONTROL_ADC_ON)) {
                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING 
                                         "cs46xx: powerup ADC failed\n"));
                                 return 1;
                         }
                 }
         }
-        if(type & CS_POWER_DAC)
-        {
+        if (type & CS_POWER_DAC) {
                 /*
                  *  Power up the DAC on the AC97 card.  
                  */
@@ -4821,12 +4562,10 @@ static int cs46xx_powerup(struct cs_card *card, unsigned int type)
                 CS_DBGOUT(CS_FUNCTION, 4, 
                         printk(KERN_INFO "cs46xx: cs46xx_powerup()+ DAC\n"));
                 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
-                if (!(tmp & CS_AC97_POWER_CONTROL_DAC_ON))
-                {
-                        if(!muted)
-                        {
+                if (!(tmp & CS_AC97_POWER_CONTROL_DAC_ON)) {
+                        if (!muted) {
                                 cs_mute(card, CS_TRUE);
-                                muted=1;
+                                muted = 1;
                         }
                         tmp &= ~CS_AC97_POWER_CONTROL_DAC;
                         cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
@@ -4852,8 +4591,7 @@ static int cs46xx_powerup(struct cs_card *card, unsigned int type)
                          *  Check the status..
                          */
                         if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 
-                                CS_AC97_POWER_CONTROL_DAC_ON))
-                        {
+                                CS_AC97_POWER_CONTROL_DAC_ON)) {
                                 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING 
                                         "cs46xx: powerup DAC failed\n"));
                                 return 1;
@@ -4861,14 +4599,13 @@ static int cs46xx_powerup(struct cs_card *card, unsigned int type)
                 }
         }
         tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
-        if(muted)
+        if (muted)
                 cs_mute(card, CS_FALSE);
         CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO 
                 "cs46xx: cs46xx_powerup()- 0 tmp=0x%x\n",tmp));
         return 0;
 }
 
-
 static void cs461x_proc_start(struct cs_card *card)
 {
         int cnt;
@@ -4965,7 +4702,7 @@ static int cs_hardware_init(struct cs_card *card)
         * is not enough for some platforms! tested on an IBM Thinkpads and 
         * reference cards.
         */
-        if(!(card->pm.flags & CS46XX_PM_IDLE))
+        if (!(card->pm.flags & CS46XX_PM_IDLE))
                 mdelay(initdelay);
         /*
          *  Write the selected clock control setup to the hardware.  Do not turn on
@@ -5017,8 +4754,7 @@ static int cs_hardware_init(struct cs_card *card)
 * If we are resuming under 2.2.x then we can not schedule a timeout.
 * so, just spin the CPU.
 */
-        if(card->pm.flags & CS46XX_PM_IDLE)
-        {
+        if (card->pm.flags & CS46XX_PM_IDLE) {
         /*
          * Wait for the card ready signal from the AC97 card.
          */
@@ -5033,9 +4769,7 @@ static int cs_hardware_init(struct cs_card *card)
                         current->state = TASK_UNINTERRUPTIBLE;
                         schedule_timeout(1);
                 } while (time_before(jiffies, end_time));
-        }
-        else
-        {
+        } else {
                 for (count = 0; count < 100; count++) {
                 // First, we want to wait for a short time.
                         udelay(25 * cs_laptop_wait);
@@ -5064,8 +4798,7 @@ static int cs_hardware_init(struct cs_card *card)
          */
         cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
 
-        if(card->pm.flags & CS46XX_PM_IDLE)
-        {
+        if (card->pm.flags & CS46XX_PM_IDLE) {
         /*
          *  Wait until we've sampled input slots 3 and 4 as valid, meaning that
          *  the card is pumping ADC data across the AC-link.
@@ -5081,9 +4814,7 @@ static int cs_hardware_init(struct cs_card *card)
                         current->state = TASK_UNINTERRUPTIBLE;
                         schedule_timeout(1);
                 } while (time_before(jiffies, end_time));
-        }
-        else
-        {
+        } else {
                 for (count = 0; count < 100; count++) {
                 // First, we want to wait for a short time.
                         udelay(25 * cs_laptop_wait);
@@ -5140,17 +4871,13 @@ static int cs_hardware_init(struct cs_card *card)
         cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
 
         /* initialize AC97 codec and register /dev/mixer */
-        if(card->pm.flags & CS46XX_PM_IDLE)
-        {
-                if (cs_ac97_init(card) <= 0)
-                {
+        if (card->pm.flags & CS46XX_PM_IDLE) {
+                if (cs_ac97_init(card) <= 0) {
                         CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO 
-                                "cs46xx: cs_ac97_init() failure\n") );
+                                "cs46xx: cs_ac97_init() failure\n"));
                         return -EIO;
                 }
-        }
-        else
-        {
+        } else {
                 cs46xx_ac97_resume(card);
         }
         
@@ -5174,23 +4901,17 @@ static int cs_hardware_init(struct cs_card *card)
          *  If IDLE then Power down the part.  We will power components up 
          *  when we need them.  
          */
-        if(card->pm.flags & CS46XX_PM_IDLE)
-        {
-                if(!cs_powerdown)
-                {
-                        if( (tmp = cs46xx_powerup(card, CS_POWER_DAC | CS_POWER_ADC |
-                                        CS_POWER_MIXVON )) )
-                        {
+        if (card->pm.flags & CS46XX_PM_IDLE) {
+                if (!cs_powerdown) {
+                        if ((tmp = cs46xx_powerup(card, CS_POWER_DAC | CS_POWER_ADC |
+                                        CS_POWER_MIXVON))) {
                                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO 
                                         "cs46xx: cs461x_powerup() failure (0x%x)\n",tmp) );
                                 return -EIO;
                         }
-                }
-                else
-                {
-                        if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
-                                        CS_POWER_MIXVON, CS_FALSE )) )
-                        {
+                } else {
+                        if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
+                                        CS_POWER_MIXVON, CS_FALSE))) {
                                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO 
                                         "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
                                 return -EIO;
@@ -5310,14 +5031,13 @@ MODULE_AUTHOR("Alan Cox <alan@redhat.com>, Jaroslav Kysela, <pcaudio@crystal.cir
 MODULE_DESCRIPTION("Crystal SoundFusion Audio Support");
 MODULE_LICENSE("GPL");
 
-
 static const char cs46xx_banner[] = KERN_INFO "Crystal 4280/46xx + AC97 Audio, version " CS46XX_MAJOR_VERSION "." CS46XX_MINOR_VERSION "." CS46XX_ARCH ", " __TIME__ " " __DATE__ "\n";
 static const char fndmsg[] = KERN_INFO "cs46xx: Found %d audio device(s).\n";
 
 static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
                                   const struct pci_device_id *pciid)
 {
-        int i,j;
+        int i, j;
         u16 ss_card, ss_vendor;
         struct cs_card *card;
         dma_addr_t dma_mask;
@@ -5378,42 +5098,35 @@ static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
 
         while (cp->name)
         {
-                if(cp->vendor == ss_vendor && cp->id == ss_card)
-                {
+                if (cp->vendor == ss_vendor && cp->id == ss_card) {
                         card->amplifier_ctrl = cp->amp;
-                        if(cp->active)
+                        if (cp->active)
                                 card->active_ctrl = cp->active;
-                        if(cp->amp_init)
+                        if (cp->amp_init)
                                 card->amp_init = cp->amp_init;
                         break;
                 }
                 cp++;
         }
-        if (cp->name==NULL)
-        {
+        if (cp->name == NULL) {
                 printk(KERN_INFO "cs46xx: Unknown card (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
                         ss_vendor, ss_card, card->ba0_addr, card->ba1_addr,  card->irq);
-        }
-        else
-        {
+        } else {
                 printk(KERN_INFO "cs46xx: %s (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
                         cp->name, ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
         }
         
-        if (card->amplifier_ctrl==NULL)
-        {
+        if (card->amplifier_ctrl == NULL) {
                 card->amplifier_ctrl = amp_none;
                 card->active_ctrl = clkrun_hack;
         }               
 
-        if (external_amp == 1)
-        {
+        if (external_amp == 1) {
                 printk(KERN_INFO "cs46xx: Crystal EAPD support forced on.\n");
                 card->amplifier_ctrl = amp_voyetra;
         }
 
-        if (thinkpad == 1)
-        {
+        if (thinkpad == 1) {
                 printk(KERN_INFO "cs46xx: Activating CLKRUN hack for Thinkpad.\n");
                 card->active_ctrl = clkrun_hack;
         }
@@ -5425,13 +5138,11 @@ static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
 * and mdelay kernel code is replaced by a pm timer, or the delays
 * work well for battery and/or AC power both.
 */
-        if(card->active_ctrl == clkrun_hack)
-        {
+        if (card->active_ctrl == clkrun_hack) {
                 initdelay = 2100;
                 cs_laptop_wait = 5;
         }
-        if((card->active_ctrl == clkrun_hack) && !(powerdown == 1))
-        {
+        if ((card->active_ctrl == clkrun_hack) && !(powerdown == 1)) {
 /*
 * for some currently unknown reason, powering down the DAC and ADC component
 * blocks on thinkpads causes some funky behavior... distoorrrtion and ac97 
@@ -5440,7 +5151,7 @@ static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
 */
                 cs_powerdown = 0;
         }
-        if(powerdown == 0)
+        if (powerdown == 0)
                 cs_powerdown = 0;
         card->active_ctrl(card, 1);
 
@@ -5461,7 +5172,7 @@ static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
                         card->ba1.name.pmem,
                         card->ba1.name.reg) );
 
-        if(card->ba0 == 0 || card->ba1.name.data0 == 0 ||
+        if (card->ba0 == 0 || card->ba1.name.data0 == 0 ||
                 card->ba1.name.data1 == 0 || card->ba1.name.pmem == 0 ||
                 card->ba1.name.reg == 0)
                 goto fail2;
@@ -5477,14 +5188,12 @@ static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
         }
 
         /* register /dev/midi */
-        if((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
+        if ((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
                 printk(KERN_ERR "cs46xx: unable to register midi\n");
                 
         card->pm.flags |= CS46XX_PM_IDLE;
-        for(i=0;i<5;i++)
-        {
-                if (cs_hardware_init(card) != 0)
-                {
+        for (i = 0; i < 5; i++) {
+                if (cs_hardware_init(card) != 0) {
                         CS_DBGOUT(CS_ERROR, 4, printk(
                                 "cs46xx: ERROR in cs_hardware_init()... retrying\n"));
                         for (j = 0; j < NR_AC97; j++)
@@ -5497,12 +5206,11 @@ static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
                 }
                 break;
         }
-        if(i>=4)
-        {
+        if(i >= 4) {
                 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
                         "cs46xx: cs46xx_probe()- cs_hardware_init() failed, retried %d times.\n",i));
                 unregister_sound_dsp(card->dev_audio);
-                if(card->dev_midi)
+                if (card->dev_midi)
                         unregister_sound_midi(card->dev_midi);
                 goto fail;
         }
@@ -5518,7 +5226,7 @@ static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
         * Check if we have to init the amplifier, but probably already done
         * since the CD logic in the ac97 init code will turn on the ext amp.
         */
-        if(cp->amp_init)
+        if (cp->amp_init)
                 cp->amp_init(card);
         card->active_ctrl(card, -1);
 
@@ -5536,15 +5244,15 @@ static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
 fail:
         free_irq(card->irq, card);
 fail2:
-        if(card->ba0)
+        if (card->ba0)
                 iounmap(card->ba0);
-        if(card->ba1.name.data0)
+        if (card->ba1.name.data0)
                 iounmap(card->ba1.name.data0);
-        if(card->ba1.name.data1)
+        if (card->ba1.name.data1)
                 iounmap(card->ba1.name.data1);
-        if(card->ba1.name.pmem)
+        if (card->ba1.name.pmem)
                 iounmap(card->ba1.name.pmem);
-        if(card->ba1.name.reg)
+        if (card->ba1.name.reg)
                 iounmap(card->ba1.name.reg);
         kfree(card);
         CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_INFO
@@ -5598,9 +5306,8 @@ static void __devexit cs46xx_remove(struct pci_dev *pci_dev)
          *  Power down the DAC and ADC.  We will power them up (if) when we need
          *  them.
          */
-        if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
-                        CS_POWER_MIXVON, CS_TRUE )) )
-        {
+        if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
+                        CS_POWER_MIXVON, CS_TRUE))) {
                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO 
                         "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
         }
@@ -5634,7 +5341,7 @@ static void __devexit cs46xx_remove(struct pci_dev *pci_dev)
                         ac97_release_codec(card->ac97_codec[i]);
                 }
         unregister_sound_dsp(card->dev_audio);
-        if(card->dev_midi)
+        if (card->dev_midi)
                 unregister_sound_midi(card->dev_midi);
         list_del(&card->list);
         kfree(card);
@@ -5693,8 +5400,7 @@ static int __init cs46xx_init_module(void)
                 "cs46xx: cs46xx_init_module()+ \n"));
         rtn = pci_register_driver(&cs46xx_pci_driver);
 
-        if(rtn == -ENODEV)
-        {
+        if (rtn == -ENODEV) {
                 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk( 
                         "cs46xx: Unable to detect valid cs46xx device\n"));
         }
diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig
index a2081803a827..d37346b12dc0 100644
--- a/sound/pci/Kconfig
+++ b/sound/pci/Kconfig
@@ -216,14 +216,19 @@ config SND_CS46XX_NEW_DSP
           This works better than the old code, so say Y.
 
 config SND_CS5535AUDIO
-        tristate "CS5535 Audio"
+        tristate "CS5535/CS5536 Audio"
         depends on SND && X86 && !X86_64
         select SND_PCM
         select SND_AC97_CODEC
         help
           Say Y here to include support for audio on CS5535 chips. It is
           referred to as NS CS5535 IO or AMD CS5535 IO companion in
-          various literature.
+          various literature. This driver also supports the CS5536 audio
+          device. However, for both chips, on certain boards, you may
+          need to use ac97_quirk=hp_only if your board has physically 
+          mapped headphone out to master output. If that works for you,
+          send lspci -vvv output to the mailing list so that your board
+          can be identified in the quirks list.
 
           To compile this driver as a module, choose M here: the module
           will be called snd-cs5535audio.
diff --git a/sound/pci/ac97/ac97_codec.c b/sound/pci/ac97/ac97_codec.c
index d05200741ac3..0abf2808d59f 100644
--- a/sound/pci/ac97/ac97_codec.c
+++ b/sound/pci/ac97/ac97_codec.c
@@ -253,6 +253,8 @@ void snd_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short va
         ac97->bus->ops->write(ac97, reg, value);
 }
 
+EXPORT_SYMBOL(snd_ac97_write);
+
 /**
  * snd_ac97_read - read a value from the given register
  * 
@@ -281,6 +283,8 @@ static inline unsigned short snd_ac97_read_cache(struct snd_ac97 *ac97, unsigned
         return ac97->regs[reg];
 }
 
+EXPORT_SYMBOL(snd_ac97_read);
+
 /**
  * snd_ac97_write_cache - write a value on the given register and update the cache
  * @ac97: the ac97 instance
@@ -302,6 +306,8 @@ void snd_ac97_write_cache(struct snd_ac97 *ac97, unsigned short reg, unsigned sh
         mutex_unlock(&ac97->reg_mutex);
 }
 
+EXPORT_SYMBOL(snd_ac97_write_cache);
+
 /**
  * snd_ac97_update - update the value on the given register
  * @ac97: the ac97 instance
@@ -331,6 +337,8 @@ int snd_ac97_update(struct snd_ac97 *ac97, unsigned short reg, unsigned short va
         return change;
 }
 
+EXPORT_SYMBOL(snd_ac97_update);
+
 /**
  * snd_ac97_update_bits - update the bits on the given register
  * @ac97: the ac97 instance
@@ -356,6 +364,8 @@ int snd_ac97_update_bits(struct snd_ac97 *ac97, unsigned short reg, unsigned sho
         return change;
 }
 
+EXPORT_SYMBOL(snd_ac97_update_bits);
+
 /* no lock version - see snd_ac97_updat_bits() */
 int snd_ac97_update_bits_nolock(struct snd_ac97 *ac97, unsigned short reg,
                                 unsigned short mask, unsigned short value)
@@ -563,7 +573,7 @@ AC97_SINGLE("PC Speaker Playback Volume", AC97_PC_BEEP, 1, 15, 1)
 };
 
 static const struct snd_kcontrol_new snd_ac97_controls_mic_boost =
-        AC97_SINGLE("Mic Boost (+20dB)", AC97_MIC, 6, 1, 0);
+        AC97_SINGLE("Mic Boost (+20dB) Switch", AC97_MIC, 6, 1, 0);
 
 
 static const char* std_rec_sel[] = {"Mic", "CD", "Video", "Aux", "Line", "Mix", "Mix Mono", "Phone"};
@@ -605,7 +615,7 @@ AC97_SINGLE("Simulated Stereo Enhancement", AC97_GENERAL_PURPOSE, 14, 1, 0),
 AC97_SINGLE("3D Control - Switch", AC97_GENERAL_PURPOSE, 13, 1, 0),
 AC97_SINGLE("Loudness (bass boost)", AC97_GENERAL_PURPOSE, 12, 1, 0),
 AC97_ENUM("Mono Output Select", std_enum[2]),
-AC97_ENUM("Mic Select", std_enum[3]),
+AC97_ENUM("Mic Select Capture Switch", std_enum[3]),
 AC97_SINGLE("ADC/DAC Loopback", AC97_GENERAL_PURPOSE, 7, 1, 0)
 };
 
@@ -1226,7 +1236,8 @@ static int snd_ac97_mixer_build(struct snd_ac97 * ac97)
         ac97->regs[AC97_CENTER_LFE_MASTER] = 0x8080;
 
         /* build center controls */
-        if (snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER)) {
+        if ((snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER)) 
+                && !(ac97->flags & AC97_AD_MULTI)) {
                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_center[0], ac97))) < 0)
                         return err;
                 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_center[1], ac97))) < 0)
@@ -1238,7 +1249,8 @@ static int snd_ac97_mixer_build(struct snd_ac97 * ac97)
         }
 
         /* build LFE controls */
-        if (snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER+1)) {
+        if ((snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER+1))
+                && !(ac97->flags & AC97_AD_MULTI)) {
                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_lfe[0], ac97))) < 0)
                         return err;
                 if ((err = snd_ctl_add(card, kctl = snd_ac97_cnew(&snd_ac97_controls_lfe[1], ac97))) < 0)
@@ -1250,7 +1262,8 @@ static int snd_ac97_mixer_build(struct snd_ac97 * ac97)
         }
 
         /* build surround controls */
-        if (snd_ac97_try_volume_mix(ac97, AC97_SURROUND_MASTER)) {
+        if ((snd_ac97_try_volume_mix(ac97, AC97_SURROUND_MASTER)) 
+                && !(ac97->flags & AC97_AD_MULTI)) {
                 /* Surround Master (0x38) is with stereo mutes */
                 if ((err = snd_ac97_cmix_new_stereo(card, "Surround Playback", AC97_SURROUND_MASTER, 1, ac97)) < 0)
                         return err;
@@ -1335,9 +1348,11 @@ static int snd_ac97_mixer_build(struct snd_ac97 * ac97)
         }
 
         /* build Aux controls */
-        if (snd_ac97_try_volume_mix(ac97, AC97_AUX)) {
-                if ((err = snd_ac97_cmix_new(card, "Aux Playback", AC97_AUX, ac97)) < 0)
-                        return err;
+        if (!(ac97->flags & AC97_HAS_NO_AUX)) {
+                if (snd_ac97_try_volume_mix(ac97, AC97_AUX)) {
+                        if ((err = snd_ac97_cmix_new(card, "Aux Playback", AC97_AUX, ac97)) < 0)
+                                return err;
+                }
         }
 
         /* build PCM controls */
@@ -1682,6 +1697,7 @@ const char *snd_ac97_get_short_name(struct snd_ac97 *ac97)
         return "unknown codec";
 }
 
+EXPORT_SYMBOL(snd_ac97_get_short_name);
 
 /* wait for a while until registers are accessible after RESET
  * return 0 if ok, negative not ready
@@ -1774,6 +1790,8 @@ int snd_ac97_bus(struct snd_card *card, int num, struct snd_ac97_bus_ops *ops,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_ac97_bus);
+
 /* stop no dev release warning */
 static void ac97_device_release(struct device * dev)
 {
@@ -2117,6 +2135,7 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_ac97_mixer);
 
 /*
  * Power down the chip.
@@ -2166,6 +2185,8 @@ void snd_ac97_suspend(struct snd_ac97 *ac97)
         snd_ac97_powerdown(ac97);
 }
 
+EXPORT_SYMBOL(snd_ac97_suspend);
+
 /*
  * restore ac97 status
  */
@@ -2267,6 +2288,8 @@ __reset_ready:
                 snd_ac97_restore_iec958(ac97);
         }
 }
+
+EXPORT_SYMBOL(snd_ac97_resume);
 #endif
 
 
@@ -2590,29 +2613,7 @@ int snd_ac97_tune_hardware(struct snd_ac97 *ac97, struct ac97_quirk *quirk, cons
         return 0;
 }
 
-
-/*
- *  Exported symbols
- */
-
-EXPORT_SYMBOL(snd_ac97_write);
-EXPORT_SYMBOL(snd_ac97_read);
-EXPORT_SYMBOL(snd_ac97_write_cache);
-EXPORT_SYMBOL(snd_ac97_update);
-EXPORT_SYMBOL(snd_ac97_update_bits);
-EXPORT_SYMBOL(snd_ac97_get_short_name);
-EXPORT_SYMBOL(snd_ac97_bus);
-EXPORT_SYMBOL(snd_ac97_mixer);
-EXPORT_SYMBOL(snd_ac97_pcm_assign);
-EXPORT_SYMBOL(snd_ac97_pcm_open);
-EXPORT_SYMBOL(snd_ac97_pcm_close);
-EXPORT_SYMBOL(snd_ac97_pcm_double_rate_rules);
 EXPORT_SYMBOL(snd_ac97_tune_hardware);
-EXPORT_SYMBOL(snd_ac97_set_rate);
-#ifdef CONFIG_PM
-EXPORT_SYMBOL(snd_ac97_resume);
-EXPORT_SYMBOL(snd_ac97_suspend);
-#endif
 
 /*
  *  INIT part
diff --git a/sound/pci/ac97/ac97_patch.c b/sound/pci/ac97/ac97_patch.c
index 4d9cf37300f7..7f197c780816 100644
--- a/sound/pci/ac97/ac97_patch.c
+++ b/sound/pci/ac97/ac97_patch.c
@@ -464,6 +464,10 @@ int patch_wolfson05(struct snd_ac97 * ac97)
 {
         /* WM9705, WM9710 */
         ac97->build_ops = &patch_wolfson_wm9705_ops;
+#ifdef CONFIG_TOUCHSCREEN_WM9705
+        /* WM9705 touchscreen uses AUX and VIDEO for touch */
+        ac97->flags |=3D AC97_HAS_NO_VIDEO | AC97_HAS_NO_AUX;
+#endif
         return 0;
 }
 
@@ -1367,6 +1371,13 @@ static void ad18xx_resume(struct snd_ac97 *ac97)
 
         snd_ac97_restore_iec958(ac97);
 }
+
+static void ad1888_resume(struct snd_ac97 *ac97)
+{
+        ad18xx_resume(ac97);
+        snd_ac97_write_cache(ac97, AC97_CODEC_CLASS_REV, 0x8080);
+}
+
 #endif
 
 int patch_ad1819(struct snd_ac97 * ac97)
@@ -1627,6 +1638,7 @@ static const struct snd_kcontrol_new snd_ac97_ad1981x_jack_sense[] = {
  * (SS vendor << 16 | device)
  */
 static unsigned int ad1981_jacks_blacklist[] = {
+        0x10140537, /* Thinkpad T41p */
         0x10140554, /* Thinkpad T42p/R50p */
         0 /* end */
 };
@@ -1839,7 +1851,7 @@ static struct snd_ac97_build_ops patch_ad1888_build_ops = {
         .build_post_spdif = patch_ad198x_post_spdif,
         .build_specific = patch_ad1888_specific,
 #ifdef CONFIG_PM
-        .resume = ad18xx_resume,
+        .resume = ad1888_resume,
 #endif
         .update_jacks = ad1888_update_jacks,
 };
@@ -2048,7 +2060,10 @@ int patch_alc650(struct snd_ac97 * ac97)
         /* Enable SPDIF-IN only on Rev.E and above */
         val = snd_ac97_read(ac97, AC97_ALC650_CLOCK);
         /* SPDIF IN with pin 47 */
-        if (ac97->spec.dev_flags)
+        if (ac97->spec.dev_flags &&
+            /* ASUS A6KM requires EAPD */
+            ! (ac97->subsystem_vendor == 0x1043 &&
+               ac97->subsystem_device == 0x1103))
                 val |= 0x03; /* enable */
         else
                 val &= ~0x03; /* disable */
diff --git a/sound/pci/ac97/ac97_pcm.c b/sound/pci/ac97/ac97_pcm.c
index 512a3583b0ce..f684aa2c0067 100644
--- a/sound/pci/ac97/ac97_pcm.c
+++ b/sound/pci/ac97/ac97_pcm.c
@@ -317,6 +317,8 @@ int snd_ac97_set_rate(struct snd_ac97 *ac97, int reg, unsigned int rate)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_ac97_set_rate);
+
 static unsigned short get_pslots(struct snd_ac97 *ac97, unsigned char *rate_table, unsigned short *spdif_slots)
 {
         if (!ac97_is_audio(ac97))
@@ -550,6 +552,8 @@ int snd_ac97_pcm_assign(struct snd_ac97_bus *bus,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_ac97_pcm_assign);
+
 /**
  * snd_ac97_pcm_open - opens the given AC97 pcm
  * @pcm: the ac97 pcm instance
@@ -633,6 +637,8 @@ int snd_ac97_pcm_open(struct ac97_pcm *pcm, unsigned int rate,
         return err;
 }
 
+EXPORT_SYMBOL(snd_ac97_pcm_open);
+
 /**
  * snd_ac97_pcm_close - closes the given AC97 pcm
  * @pcm: the ac97 pcm instance
@@ -658,6 +664,8 @@ int snd_ac97_pcm_close(struct ac97_pcm *pcm)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_ac97_pcm_close);
+
 static int double_rate_hw_constraint_rate(struct snd_pcm_hw_params *params,
                                           struct snd_pcm_hw_rule *rule)
 {
@@ -709,3 +717,5 @@ int snd_ac97_pcm_double_rate_rules(struct snd_pcm_runtime *runtime)
                                   SNDRV_PCM_HW_PARAM_RATE, -1);
         return err;
 }
+
+EXPORT_SYMBOL(snd_ac97_pcm_double_rate_rules);
diff --git a/sound/pci/ac97/ac97_proc.c b/sound/pci/ac97/ac97_proc.c
index 4d523df79cc7..2118df50b9d6 100644
--- a/sound/pci/ac97/ac97_proc.c
+++ b/sound/pci/ac97/ac97_proc.c
@@ -433,7 +433,7 @@ void snd_ac97_proc_init(struct snd_ac97 * ac97)
         prefix = ac97_is_audio(ac97) ? "ac97" : "mc97";
         sprintf(name, "%s#%d-%d", prefix, ac97->addr, ac97->num);
         if ((entry = snd_info_create_card_entry(ac97->bus->card, name, ac97->bus->proc)) != NULL) {
-                snd_info_set_text_ops(entry, ac97, 1024, snd_ac97_proc_read);
+                snd_info_set_text_ops(entry, ac97, snd_ac97_proc_read);
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
                         entry = NULL;
@@ -442,10 +442,9 @@ void snd_ac97_proc_init(struct snd_ac97 * ac97)
         ac97->proc = entry;
         sprintf(name, "%s#%d-%d+regs", prefix, ac97->addr, ac97->num);
         if ((entry = snd_info_create_card_entry(ac97->bus->card, name, ac97->bus->proc)) != NULL) {
-                snd_info_set_text_ops(entry, ac97, 1024, snd_ac97_proc_regs_read);
+                snd_info_set_text_ops(entry, ac97, snd_ac97_proc_regs_read);
 #ifdef CONFIG_SND_DEBUG
                 entry->mode |= S_IWUSR;
-                entry->c.text.write_size = 1024;
                 entry->c.text.write = snd_ac97_proc_regs_write;
 #endif
                 if (snd_info_register(entry) < 0) {
diff --git a/sound/pci/ac97/ak4531_codec.c b/sound/pci/ac97/ak4531_codec.c
index 0fb7b3407312..94c26ec05882 100644
--- a/sound/pci/ac97/ak4531_codec.c
+++ b/sound/pci/ac97/ak4531_codec.c
@@ -453,7 +453,7 @@ static void snd_ak4531_proc_init(struct snd_card *card, struct snd_ak4531 *ak453
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(card, "ak4531", &entry))
-                snd_info_set_text_ops(entry, ak4531, 1024, snd_ak4531_proc_read);
+                snd_info_set_text_ops(entry, ak4531, snd_ak4531_proc_read);
 }
 #endif
 
diff --git a/sound/pci/ad1889.c b/sound/pci/ad1889.c
index eece1c7e55a0..d42bf4570367 100644
--- a/sound/pci/ad1889.c
+++ b/sound/pci/ad1889.c
@@ -753,7 +753,7 @@ snd_ad1889_proc_init(struct snd_ad1889 *chip)
         struct snd_info_entry *entry;
 
         if (!snd_card_proc_new(chip->card, chip->card->driver, &entry))
-                snd_info_set_text_ops(entry, chip, 1024, snd_ad1889_proc_read);
+                snd_info_set_text_ops(entry, chip, snd_ad1889_proc_read);
 }
 
 static struct ac97_quirk ac97_quirks[] = {
diff --git a/sound/pci/ali5451/ali5451.c b/sound/pci/ali5451/ali5451.c
index e2dbc2118902..5dfdbf6657f2 100644
--- a/sound/pci/ali5451/ali5451.c
+++ b/sound/pci/ali5451/ali5451.c
@@ -49,7 +49,7 @@ MODULE_SUPPORTED_DEVICE("{{ALI,M5451,pci},{ALI,M5451}}");
 static int index = SNDRV_DEFAULT_IDX1;  /* Index */
 static char *id = SNDRV_DEFAULT_STR1;   /* ID for this card */
 static int pcm_channels = 32;
-static int spdif = 0;
+static int spdif;
 
 module_param(index, int, 0444);
 MODULE_PARM_DESC(index, "Index value for ALI M5451 PCI Audio.");
@@ -2173,7 +2173,7 @@ static void __devinit snd_ali_proc_init(struct snd_ali *codec)
 {
         struct snd_info_entry *entry;
         if(!snd_card_proc_new(codec->card, "ali5451", &entry))
-                snd_info_set_text_ops(entry, codec, 1024, snd_ali_proc_read);
+                snd_info_set_text_ops(entry, codec, snd_ali_proc_read);
 }
 
 static int __devinit snd_ali_resources(struct snd_ali *codec)
diff --git a/sound/pci/als4000.c b/sound/pci/als4000.c
index 60423b1c678b..a9f08066459a 100644
--- a/sound/pci/als4000.c
+++ b/sound/pci/als4000.c
@@ -746,8 +746,8 @@ static int __devinit snd_card_als4000_probe(struct pci_dev *pci,
                 card->shortname, chip->alt_port, chip->irq);
 
         if ((err = snd_mpu401_uart_new( card, 0, MPU401_HW_ALS4000,
-                                        gcr+0x30, 1, pci->irq, 0,
-                                        &chip->rmidi)) < 0) {
+                                        gcr+0x30, MPU401_INFO_INTEGRATED,
+                                        pci->irq, 0, &chip->rmidi)) < 0) {
                 printk(KERN_ERR "als4000: no MPU-401 device at 0x%lx?\n", gcr+0x30);
                 goto out_err;
         }
diff --git a/sound/pci/atiixp.c b/sound/pci/atiixp.c
index d0f759d86d3d..f18a8c0e4688 100644
--- a/sound/pci/atiixp.c
+++ b/sound/pci/atiixp.c
@@ -1504,7 +1504,7 @@ static void __devinit snd_atiixp_proc_init(struct atiixp *chip)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(chip->card, "atiixp", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, snd_atiixp_proc_read);
+                snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read);
 }
 #else /* !CONFIG_PROC_FS */
 #define snd_atiixp_proc_init(chip)
diff --git a/sound/pci/atiixp_modem.c b/sound/pci/atiixp_modem.c
index 12a34c39caa7..40739057076b 100644
--- a/sound/pci/atiixp_modem.c
+++ b/sound/pci/atiixp_modem.c
@@ -1177,7 +1177,7 @@ static void __devinit snd_atiixp_proc_init(struct atiixp_modem *chip)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(chip->card, "atiixp-modem", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, snd_atiixp_proc_read);
+                snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read);
 }
 #else
 #define snd_atiixp_proc_init(chip)
diff --git a/sound/pci/au88x0/au88x0.c b/sound/pci/au88x0/au88x0.c
index 126870ec063a..8a3b118989bf 100644
--- a/sound/pci/au88x0/au88x0.c
+++ b/sound/pci/au88x0/au88x0.c
@@ -261,6 +261,13 @@ snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
                 return err;
         }
         snd_vortex_workaround(pci, pcifix[dev]);
+
+        // Card details needed in snd_vortex_midi
+        strcpy(card->driver, CARD_NAME_SHORT);
+        sprintf(card->shortname, "Aureal Vortex %s", CARD_NAME_SHORT);
+        sprintf(card->longname, "%s at 0x%lx irq %i",
+                card->shortname, chip->io, chip->irq);
+
         // (4) Alloc components.
         // ADB pcm.
         if ((err = snd_vortex_new_pcm(chip, VORTEX_PCM_ADB, NR_ADB)) < 0) {
@@ -323,11 +330,6 @@ snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
 #endif
 
         // (5)
-        strcpy(card->driver, CARD_NAME_SHORT);
-        strcpy(card->shortname, CARD_NAME_SHORT);
-        sprintf(card->longname, "%s at 0x%lx irq %i",
-                card->shortname, chip->io, chip->irq);
-
         if ((err = pci_read_config_word(pci, PCI_DEVICE_ID,
                                   &(chip->device))) < 0) {
                 snd_card_free(card);
diff --git a/sound/pci/au88x0/au88x0_mpu401.c b/sound/pci/au88x0/au88x0_mpu401.c
index 873f486b07b8..c75d368ea087 100644
--- a/sound/pci/au88x0/au88x0_mpu401.c
+++ b/sound/pci/au88x0/au88x0_mpu401.c
@@ -47,7 +47,7 @@ static int __devinit snd_vortex_midi(vortex_t * vortex)
         struct snd_rawmidi *rmidi;
         int temp, mode;
         struct snd_mpu401 *mpu;
-        int port;
+        unsigned long port;
 
 #ifdef VORTEX_MPU401_LEGACY
         /* EnableHardCodedMPU401Port() */
@@ -70,9 +70,6 @@ static int __devinit snd_vortex_midi(vortex_t * vortex)
         temp |= (MIDI_CLOCK_DIV << 8) | ((mode >> 24) & 0xff) << 4;
         hwwrite(vortex->mmio, VORTEX_CTRL2, temp);
         hwwrite(vortex->mmio, VORTEX_MIDI_CMD, MPU401_RESET);
-        /* Set some kind of mode */
-        if (mode)
-                hwwrite(vortex->mmio, VORTEX_MIDI_CMD, MPU401_ENTER_UART);
 
         /* Check if anything is OK. */
         temp = hwread(vortex->mmio, VORTEX_MIDI_DATA);
@@ -98,7 +95,8 @@ static int __devinit snd_vortex_midi(vortex_t * vortex)
         port = (unsigned long)(vortex->mmio + VORTEX_MIDI_DATA);
         if ((temp =
              snd_mpu401_uart_new(vortex->card, 0, MPU401_HW_AUREAL, port,
-                                 1, 0, 0, &rmidi)) != 0) {
+                                 MPU401_INFO_INTEGRATED | MPU401_INFO_MMIO,
+                                 0, 0, &rmidi)) != 0) {
                 hwwrite(vortex->mmio, VORTEX_CTRL,
                         (hwread(vortex->mmio, VORTEX_CTRL) &
                          ~CTRL_MIDI_PORT) & ~CTRL_MIDI_EN);
@@ -107,6 +105,9 @@ static int __devinit snd_vortex_midi(vortex_t * vortex)
         mpu = rmidi->private_data;
         mpu->cport = (unsigned long)(vortex->mmio + VORTEX_MIDI_CMD);
 #endif
+        /* Overwrite MIDI name */
+        snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI %d", CARD_NAME_SHORT , vortex->card->number);
+
         vortex->rmidi = rmidi;
         return 0;
 }
diff --git a/sound/pci/au88x0/au88x0_xtalk.c b/sound/pci/au88x0/au88x0_xtalk.c
index 4534e1882ada..b4151e208b71 100644
--- a/sound/pci/au88x0/au88x0_xtalk.c
+++ b/sound/pci/au88x0/au88x0_xtalk.c
@@ -66,31 +66,20 @@ static xtalk_gains_t const asXtalkGainsAllChan = {
         0
             //0x7FFF,0x7FFF,0x7FFF,0x7FFF,0x7fff,0x7FFF,0x7FFF,0x7FFF,0x7FFF,0x7fff
 };
-static xtalk_gains_t const asXtalkGainsZeros = {
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-};
+static xtalk_gains_t const asXtalkGainsZeros;
 
-static xtalk_dline_t const alXtalkDlineZeros = {
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0
-};
+static xtalk_dline_t const alXtalkDlineZeros;
 static xtalk_dline_t const alXtalkDlineTest = {
         0xFC18, 0x03E8FFFF, 0x186A0, 0x7960FFFE, 1, 0xFFFFFFFF,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0
 };
 
-static xtalk_instate_t const asXtalkInStateZeros = { 0, 0, 0, 0 };
+static xtalk_instate_t const asXtalkInStateZeros;
 static xtalk_instate_t const asXtalkInStateTest =
     { 0xFF80, 0x0080, 0xFFFF, 0x0001 };
-static xtalk_state_t const asXtalkOutStateZeros = {
-        {0, 0, 0, 0},
-        {0, 0, 0, 0},
-        {0, 0, 0, 0},
-        {0, 0, 0, 0},
-        {0, 0, 0, 0}
-};
+static xtalk_state_t const asXtalkOutStateZeros;
+
 static short const sDiamondKLeftEq = 0x401d;
 static short const sDiamondKRightEq = 0x401d;
 static short const sDiamondKLeftXt = 0xF90E;
@@ -162,13 +151,7 @@ static xtalk_coefs_t const asXtalkNarrowCoefsRightXt = {
         {0, 0, 0, 0, 0}
 };
 
-static xtalk_coefs_t const asXtalkCoefsZeros = {
-        {0, 0, 0, 0, 0},
-        {0, 0, 0, 0, 0},
-        {0, 0, 0, 0, 0},
-        {0, 0, 0, 0, 0},
-        {0, 0, 0, 0, 0}
-};
+static xtalk_coefs_t const asXtalkCoefsZeros;
 static xtalk_coefs_t const asXtalkCoefsPipe = {
         {0, 0, 0x0FA0, 0, 0},
         {0, 0, 0x0FA0, 0, 0},
diff --git a/sound/pci/azt3328.c b/sound/pci/azt3328.c
index 52a364524262..6e62dafb66cd 100644
--- a/sound/pci/azt3328.c
+++ b/sound/pci/azt3328.c
@@ -33,14 +33,21 @@
  *  in the first place >:-P}),
  *  I was forced to base this driver on reverse engineering
  *  (3 weeks' worth of evenings filled with driver work).
- *  (and no, I did NOT go the easy way: to pick up a PCI128 for 9 Euros)
+ *  (and no, I did NOT go the easy way: to pick up a SB PCI128 for 9 Euros)
  *
  *  The AZF3328 chip (note: AZF3328, *not* AZT3328, that's just the driver name
  *  for compatibility reasons) has the following features:
  *
  *  - builtin AC97 conformant codec (SNR over 80dB)
- *    (really AC97 compliant?? I really doubt it when looking
- *    at the mixer register layout)
+ *    Note that "conformant" != "compliant"!! this chip's mixer register layout
+ *    *differs* from the standard AC97 layout:
+ *    they chose to not implement the headphone register (which is not a
+ *    problem since it's merely optional), yet when doing this, they committed
+ *    the grave sin of letting other registers follow immediately instead of
+ *    keeping a headphone dummy register, thereby shifting the mixer register
+ *    addresses illegally. So far unfortunately it looks like the very flexible
+ *    ALSA AC97 support is still not enough to easily compensate for such a
+ *    grave layout violation despite all tweaks and quirks mechanisms it offers.
  *  - builtin genuine OPL3
  *  - full duplex 16bit playback/record at independent sampling rate
  *  - MPU401 (+ legacy address support) FIXME: how to enable legacy addr??
@@ -90,10 +97,15 @@
  * 
  * TODO
  *  - test MPU401 MIDI playback etc.
- *  - power management. See e.g. intel8x0 or cs4281.
- *    This would be nice since the chip runs a bit hot, and it's *required*
- *    anyway for proper ACPI power management.
+ *  - add some power micro-management (disable various units of the card
+ *    as long as they're unused). However this requires I/O ports which I
+ *    haven't figured out yet and which thus might not even exist...
+ *    The standard suspend/resume functionality could probably make use of
+ *    some improvement, too...
  *  - figure out what all unknown port bits are responsible for
+ *  - figure out some cleverly evil scheme to possibly make ALSA AC97 code
+ *    fully accept our quite incompatible ""AC97"" mixer and thus save some
+ *    code (but I'm not too optimistic that doing this is possible at all)
  */
 
 #include <sound/driver.h>
@@ -214,6 +226,16 @@ struct snd_azf3328 {
 
         struct pci_dev *pci;
         int irq;
+
+#ifdef CONFIG_PM
+        /* register value containers for power management
+         * Note: not always full I/O range preserved (just like Win driver!) */
+        u16 saved_regs_codec [AZF_IO_SIZE_CODEC_PM / 2];
+        u16 saved_regs_io2   [AZF_IO_SIZE_IO2_PM / 2];
+        u16 saved_regs_mpu   [AZF_IO_SIZE_MPU_PM / 2];
+        u16 saved_regs_synth[AZF_IO_SIZE_SYNTH_PM / 2];
+        u16 saved_regs_mixer[AZF_IO_SIZE_MIXER_PM / 2];
+#endif
 };
 
 static const struct pci_device_id snd_azf3328_ids[] __devinitdata = {
@@ -317,10 +339,8 @@ snd_azf3328_mixer_write_volume_gradually(const struct snd_azf3328 *chip, int reg
         else
                 dst_vol_left &= ~0x80;
 
-        do
-        {
-                if (!left_done)
-                {
+        do {
+                if (!left_done) {
                         if (curr_vol_left > dst_vol_left)
                                 curr_vol_left--;
                         else
@@ -330,8 +350,7 @@ snd_azf3328_mixer_write_volume_gradually(const struct snd_azf3328 *chip, int reg
                             left_done = 1;
                         outb(curr_vol_left, portbase + 1);
                 }
-                if (!right_done)
-                {
+                if (!right_done) {
                         if (curr_vol_right > dst_vol_right)
                                 curr_vol_right--;
                         else
@@ -346,8 +365,7 @@ snd_azf3328_mixer_write_volume_gradually(const struct snd_azf3328 *chip, int reg
                 }
                 if (delay)
                         mdelay(delay);
-        }
-        while ((!left_done) || (!right_done));
+        } while ((!left_done) || (!right_done));
         snd_azf3328_dbgcallleave();
 }
 
@@ -514,15 +532,18 @@ snd_azf3328_info_mixer_enum(struct snd_kcontrol *kcontrol,
                             struct snd_ctl_elem_info *uinfo)
 {
         static const char * const texts1[] = {
-                "ModemOut1", "ModemOut2"
+                "Mic1", "Mic2"
         };
         static const char * const texts2[] = {
-                "MonoSelectSource1", "MonoSelectSource2"
+                "Mix", "Mic"
         };
         static const char * const texts3[] = {
                 "Mic", "CD", "Video", "Aux",
                 "Line", "Mix", "Mix Mono", "Phone"
         };
+        static const char * const texts4[] = {
+                "pre 3D", "post 3D"
+        };
         struct azf3328_mixer_reg reg;
 
         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
@@ -531,14 +552,19 @@ snd_azf3328_info_mixer_enum(struct snd_kcontrol *kcontrol,
         uinfo->value.enumerated.items = reg.enum_c;
         if (uinfo->value.enumerated.item > reg.enum_c - 1U)
                 uinfo->value.enumerated.item = reg.enum_c - 1U;
-        if (reg.reg == IDX_MIXER_ADVCTL2)
-        {
-                if (reg.lchan_shift == 8) /* modem out sel */
+        if (reg.reg == IDX_MIXER_ADVCTL2) {
+                switch(reg.lchan_shift) {
+                case 8: /* modem out sel */
                         strcpy(uinfo->value.enumerated.name, texts1[uinfo->value.enumerated.item]);
-                else /* mono sel source */
+                        break;
+                case 9: /* mono sel source */
                         strcpy(uinfo->value.enumerated.name, texts2[uinfo->value.enumerated.item]);
-        }
-        else
+                        break;
+                case 15: /* PCM Out Path */
+                        strcpy(uinfo->value.enumerated.name, texts4[uinfo->value.enumerated.item]);
+                        break;
+                }
+        } else
                 strcpy(uinfo->value.enumerated.name, texts3[uinfo->value.enumerated.item]
 );
         return 0;
@@ -554,12 +580,10 @@ snd_azf3328_get_mixer_enum(struct snd_kcontrol *kcontrol,
         
         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
         val = snd_azf3328_mixer_inw(chip, reg.reg);
-        if (reg.reg == IDX_MIXER_REC_SELECT)
-        {
+        if (reg.reg == IDX_MIXER_REC_SELECT) {
                 ucontrol->value.enumerated.item[0] = (val >> 8) & (reg.enum_c - 1);
                 ucontrol->value.enumerated.item[1] = (val >> 0) & (reg.enum_c - 1);
-        }
-        else
+        } else
                 ucontrol->value.enumerated.item[0] = (val >> reg.lchan_shift) & (reg.enum_c - 1);
 
         snd_azf3328_dbgmixer("get_enum: %02x is %04x -> %d|%d (shift %02d, enum_c %d)\n",
@@ -579,16 +603,13 @@ snd_azf3328_put_mixer_enum(struct snd_kcontrol *kcontrol,
         snd_azf3328_mixer_reg_decode(&reg, kcontrol->private_value);
         oreg = snd_azf3328_mixer_inw(chip, reg.reg);
         val = oreg;
-        if (reg.reg == IDX_MIXER_REC_SELECT)
-        {
+        if (reg.reg == IDX_MIXER_REC_SELECT) {
                 if (ucontrol->value.enumerated.item[0] > reg.enum_c - 1U ||
                 ucontrol->value.enumerated.item[1] > reg.enum_c - 1U)
                         return -EINVAL;
                 val = (ucontrol->value.enumerated.item[0] << 8) |
                       (ucontrol->value.enumerated.item[1] << 0);
-        }
-        else
-        {
+        } else {
                 if (ucontrol->value.enumerated.item[0] > reg.enum_c - 1U)
                         return -EINVAL;
                 val &= ~((reg.enum_c - 1) << reg.lchan_shift);
@@ -629,13 +650,14 @@ static const struct snd_kcontrol_new snd_azf3328_mixer_controls[] __devinitdata
         AZF3328_MIXER_VOL_MONO("Modem Playback Volume", IDX_MIXER_MODEMOUT, 0x1f, 1),
         AZF3328_MIXER_SWITCH("Modem Capture Switch", IDX_MIXER_MODEMIN, 15, 1),
         AZF3328_MIXER_VOL_MONO("Modem Capture Volume", IDX_MIXER_MODEMIN, 0x1f, 1),
-        AZF3328_MIXER_ENUM("Modem Out Select", IDX_MIXER_ADVCTL2, 2, 8),
-        AZF3328_MIXER_ENUM("Mono Select Source", IDX_MIXER_ADVCTL2, 2, 9),
+        AZF3328_MIXER_ENUM("Mic Select", IDX_MIXER_ADVCTL2, 2, 8),
+        AZF3328_MIXER_ENUM("Mono Output Select", IDX_MIXER_ADVCTL2, 2, 9),
+        AZF3328_MIXER_ENUM("PCM", IDX_MIXER_ADVCTL2, 2, 15), /* PCM Out Path, place in front since it controls *both* 3D and Bass/Treble! */
         AZF3328_MIXER_VOL_SPECIAL("Tone Control - Treble", IDX_MIXER_BASSTREBLE, 0x07, 1, 0),
         AZF3328_MIXER_VOL_SPECIAL("Tone Control - Bass", IDX_MIXER_BASSTREBLE, 0x07, 9, 0),
         AZF3328_MIXER_SWITCH("3D Control - Switch", IDX_MIXER_ADVCTL2, 13, 0),
-        AZF3328_MIXER_VOL_SPECIAL("3D Control - Wide", IDX_MIXER_ADVCTL1, 0x07, 1, 0), /* "3D Width" */
-        AZF3328_MIXER_VOL_SPECIAL("3D Control - Space", IDX_MIXER_ADVCTL1, 0x03, 8, 0), /* "Hifi 3D" */
+        AZF3328_MIXER_VOL_SPECIAL("3D Control - Width", IDX_MIXER_ADVCTL1, 0x07, 1, 0), /* "3D Width" */
+        AZF3328_MIXER_VOL_SPECIAL("3D Control - Depth", IDX_MIXER_ADVCTL1, 0x03, 8, 0), /* "Hifi 3D" */
 #if MIXER_TESTING
         AZF3328_MIXER_SWITCH("0", IDX_MIXER_ADVCTL2, 0, 0),
         AZF3328_MIXER_SWITCH("1", IDX_MIXER_ADVCTL2, 1, 0),
@@ -813,22 +835,18 @@ snd_azf3328_setdmaa(struct snd_azf3328 *chip,
         unsigned int is_running;
 
         snd_azf3328_dbgcallenter();
-        if (do_recording)
-        {
+        if (do_recording) {
                 /* access capture registers, i.e. skip playback reg section */
                 portbase = chip->codec_port + 0x20;
                 is_running = chip->is_recording;
-        }
-        else
-        {
+        } else {
                 /* access the playback register section */
                 portbase = chip->codec_port + 0x00;
                 is_running = chip->is_playing;
         }
 
         /* AZF3328 uses a two buffer pointer DMA playback approach */
-        if (!is_running)
-        {
+        if (!is_running) {
                 unsigned long addr_area2;
                 unsigned long count_areas, count_tmp; /* width 32bit -- overflow!! */
                 count_areas = size/2;
@@ -961,6 +979,13 @@ snd_azf3328_playback_trigger(struct snd_pcm_substream *substream, int cmd)
                 chip->is_playing = 1;
                 snd_azf3328_dbgplay("STARTED PLAYBACK\n");
                 break;
+        case SNDRV_PCM_TRIGGER_RESUME:
+                snd_azf3328_dbgplay("RESUME PLAYBACK\n");
+                /* resume playback if we were active */
+                if (chip->is_playing)
+                        snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS,
+                                snd_azf3328_codec_inw(chip, IDX_IO_PLAY_FLAGS) | DMA_RESUME);
+                break;
         case SNDRV_PCM_TRIGGER_STOP:
                 snd_azf3328_dbgplay("STOP PLAYBACK\n");
 
@@ -988,6 +1013,12 @@ snd_azf3328_playback_trigger(struct snd_pcm_substream *substream, int cmd)
                 chip->is_playing = 0;
                 snd_azf3328_dbgplay("STOPPED PLAYBACK\n");
                 break;
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                snd_azf3328_dbgplay("SUSPEND PLAYBACK\n");
+                /* make sure playback is stopped */
+                snd_azf3328_codec_outw(chip, IDX_IO_PLAY_FLAGS,
+                        snd_azf3328_codec_inw(chip, IDX_IO_PLAY_FLAGS) & ~DMA_RESUME);
+                break;
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
                 snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_PUSH NIY!\n");
                 break;
@@ -995,6 +1026,7 @@ snd_azf3328_playback_trigger(struct snd_pcm_substream *substream, int cmd)
                 snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_RELEASE NIY!\n");
                 break;
         default:
+                printk(KERN_ERR "FIXME: unknown trigger mode!\n");
                 return -EINVAL;
         }
         
@@ -1068,6 +1100,13 @@ snd_azf3328_capture_trigger(struct snd_pcm_substream *substream, int cmd)
                 chip->is_recording = 1;
                 snd_azf3328_dbgplay("STARTED CAPTURE\n");
                 break;
+        case SNDRV_PCM_TRIGGER_RESUME:
+                snd_azf3328_dbgplay("RESUME CAPTURE\n");
+                /* resume recording if we were active */
+                if (chip->is_recording)
+                        snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS,
+                                snd_azf3328_codec_inw(chip, IDX_IO_REC_FLAGS) | DMA_RESUME);
+                break;
         case SNDRV_PCM_TRIGGER_STOP:
                 snd_azf3328_dbgplay("STOP CAPTURE\n");
 
@@ -1088,6 +1127,12 @@ snd_azf3328_capture_trigger(struct snd_pcm_substream *substream, int cmd)
                 chip->is_recording = 0;
                 snd_azf3328_dbgplay("STOPPED CAPTURE\n");
                 break;
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                snd_azf3328_dbgplay("SUSPEND CAPTURE\n");
+                /* make sure recording is stopped */
+                snd_azf3328_codec_outw(chip, IDX_IO_REC_FLAGS,
+                        snd_azf3328_codec_inw(chip, IDX_IO_REC_FLAGS) & ~DMA_RESUME);
+                break;
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
                 snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_PUSH NIY!\n");
                 break;
@@ -1095,6 +1140,7 @@ snd_azf3328_capture_trigger(struct snd_pcm_substream *substream, int cmd)
                 snd_printk(KERN_ERR "FIXME: SNDRV_PCM_TRIGGER_PAUSE_RELEASE NIY!\n");
                 break;
         default:
+                printk(KERN_ERR "FIXME: unknown trigger mode!\n");
                 return -EINVAL;
         }
         
@@ -1163,8 +1209,7 @@ snd_azf3328_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                 snd_azf3328_codec_inw(chip, IDX_IO_PLAY_IRQTYPE),
                 status);
                 
-        if (status & IRQ_TIMER)
-        {
+        if (status & IRQ_TIMER) {
                 /* snd_azf3328_dbgplay("timer %ld\n", inl(chip->codec_port+IDX_IO_TIMER_VALUE) & TIMER_VALUE_MASK); */
                 if (chip->timer)
                         snd_timer_interrupt(chip->timer, chip->timer->sticks);
@@ -1174,50 +1219,43 @@ snd_azf3328_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                 spin_unlock(&chip->reg_lock);
                 snd_azf3328_dbgplay("azt3328: timer IRQ\n");
         }
-        if (status & IRQ_PLAYBACK)
-        {
+        if (status & IRQ_PLAYBACK) {
                 spin_lock(&chip->reg_lock);
                 which = snd_azf3328_codec_inb(chip, IDX_IO_PLAY_IRQTYPE);
                 /* ack all IRQ types immediately */
                 snd_azf3328_codec_outb(chip, IDX_IO_PLAY_IRQTYPE, which);
                 spin_unlock(&chip->reg_lock);
 
-                if (chip->pcm && chip->playback_substream)
-                {
+                if (chip->pcm && chip->playback_substream) {
                         snd_pcm_period_elapsed(chip->playback_substream);
                         snd_azf3328_dbgplay("PLAY period done (#%x), @ %x\n",
                                 which,
                                 inl(chip->codec_port+IDX_IO_PLAY_DMA_CURRPOS));
-                }
-                else
+                } else
                         snd_azf3328_dbgplay("azt3328: ouch, irq handler problem!\n");
                 if (which & IRQ_PLAY_SOMETHING)
                         snd_azf3328_dbgplay("azt3328: unknown play IRQ type occurred, please report!\n");
         }
-        if (status & IRQ_RECORDING)
-        {
+        if (status & IRQ_RECORDING) {
                 spin_lock(&chip->reg_lock);
                 which = snd_azf3328_codec_inb(chip, IDX_IO_REC_IRQTYPE);
                 /* ack all IRQ types immediately */
                 snd_azf3328_codec_outb(chip, IDX_IO_REC_IRQTYPE, which);
                 spin_unlock(&chip->reg_lock);
 
-                if (chip->pcm && chip->capture_substream)
-                {
+                if (chip->pcm && chip->capture_substream) {
                         snd_pcm_period_elapsed(chip->capture_substream);
                         snd_azf3328_dbgplay("REC  period done (#%x), @ %x\n",
                                 which,
                                 inl(chip->codec_port+IDX_IO_REC_DMA_CURRPOS));
-                }
-                else
+                } else
                         snd_azf3328_dbgplay("azt3328: ouch, irq handler problem!\n");
                 if (which & IRQ_REC_SOMETHING)
                         snd_azf3328_dbgplay("azt3328: unknown rec IRQ type occurred, please report!\n");
         }
         /* MPU401 has less critical IRQ requirements
          * than timer and playback/recording, right? */
-        if (status & IRQ_MPU401)
-        {
+        if (status & IRQ_MPU401) {
                 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
 
                 /* hmm, do we have to ack the IRQ here somehow?
@@ -1511,8 +1549,7 @@ snd_azf3328_timer_start(struct snd_timer *timer)
         snd_azf3328_dbgcallenter();
         chip = snd_timer_chip(timer);
         delay = ((timer->sticks * seqtimer_scaling) - 1) & TIMER_VALUE_MASK;
-        if (delay < 49)
-        {
+        if (delay < 49) {
                 /* uhoh, that's not good, since user-space won't know about
                  * this timing tweak
                  * (we need to do it to avoid a lockup, though) */
@@ -1766,9 +1803,11 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
                 goto out_err;
         }
 
+        card->private_data = chip;
+
         if ((err = snd_mpu401_uart_new( card, 0, MPU401_HW_MPU401,
-                                        chip->mpu_port, 1, pci->irq, 0,
-                                        &chip->rmidi)) < 0) {
+                                        chip->mpu_port, MPU401_INFO_INTEGRATED,
+                                        pci->irq, 0, &chip->rmidi)) < 0) {
                 snd_printk(KERN_ERR "azf3328: no MPU-401 device at 0x%lx?\n", chip->mpu_port);
                 goto out_err;
         }
@@ -1791,6 +1830,8 @@ snd_azf3328_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
                 }
         }
 
+        opl3->private_data = chip;
+
         sprintf(card->longname, "%s at 0x%lx, irq %i",
                 card->shortname, chip->codec_port, chip->irq);
 
@@ -1834,11 +1875,80 @@ snd_azf3328_remove(struct pci_dev *pci)
         snd_azf3328_dbgcallleave();
 }
 
+#ifdef CONFIG_PM
+static int
+snd_azf3328_suspend(struct pci_dev *pci, pm_message_t state)
+{
+        struct snd_card *card = pci_get_drvdata(pci);
+        struct snd_azf3328 *chip = card->private_data;
+        int reg;
+
+        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
+        
+        snd_pcm_suspend_all(chip->pcm);
+
+        for (reg = 0; reg < AZF_IO_SIZE_MIXER_PM / 2; reg++)
+                chip->saved_regs_mixer[reg] = inw(chip->mixer_port + reg * 2);
+
+        /* make sure to disable master volume etc. to prevent looping sound */
+        snd_azf3328_mixer_set_mute(chip, IDX_MIXER_PLAY_MASTER, 1);
+        snd_azf3328_mixer_set_mute(chip, IDX_MIXER_WAVEOUT, 1);
+        
+        for (reg = 0; reg < AZF_IO_SIZE_CODEC_PM / 2; reg++)
+                chip->saved_regs_codec[reg] = inw(chip->codec_port + reg * 2);
+        for (reg = 0; reg < AZF_IO_SIZE_IO2_PM / 2; reg++)
+                chip->saved_regs_io2[reg] = inw(chip->io2_port + reg * 2);
+        for (reg = 0; reg < AZF_IO_SIZE_MPU_PM / 2; reg++)
+                chip->saved_regs_mpu[reg] = inw(chip->mpu_port + reg * 2);
+        for (reg = 0; reg < AZF_IO_SIZE_SYNTH_PM / 2; reg++)
+                chip->saved_regs_synth[reg] = inw(chip->synth_port + reg * 2);
+
+        pci_set_power_state(pci, PCI_D3hot);
+        pci_disable_device(pci);
+        pci_save_state(pci);
+        return 0;
+}
+
+static int
+snd_azf3328_resume(struct pci_dev *pci)
+{
+        struct snd_card *card = pci_get_drvdata(pci);
+        struct snd_azf3328 *chip = card->private_data;
+        int reg;
+
+        pci_restore_state(pci);
+        pci_enable_device(pci);
+        pci_set_power_state(pci, PCI_D0);
+        pci_set_master(pci);
+
+        for (reg = 0; reg < AZF_IO_SIZE_IO2_PM / 2; reg++)
+                outw(chip->saved_regs_io2[reg], chip->io2_port + reg * 2);
+        for (reg = 0; reg < AZF_IO_SIZE_MPU_PM / 2; reg++)
+                outw(chip->saved_regs_mpu[reg], chip->mpu_port + reg * 2);
+        for (reg = 0; reg < AZF_IO_SIZE_SYNTH_PM / 2; reg++)
+                outw(chip->saved_regs_synth[reg], chip->synth_port + reg * 2);
+        for (reg = 0; reg < AZF_IO_SIZE_MIXER_PM / 2; reg++)
+                outw(chip->saved_regs_mixer[reg], chip->mixer_port + reg * 2);
+        for (reg = 0; reg < AZF_IO_SIZE_CODEC_PM / 2; reg++)
+                outw(chip->saved_regs_codec[reg], chip->codec_port + reg * 2);
+
+        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
+        return 0;
+}
+#endif
+
+
+
+
 static struct pci_driver driver = {
         .name = "AZF3328",
         .id_table = snd_azf3328_ids,
         .probe = snd_azf3328_probe,
         .remove = __devexit_p(snd_azf3328_remove),
+#ifdef CONFIG_PM
+        .suspend = snd_azf3328_suspend,
+        .resume = snd_azf3328_resume,
+#endif
 };
 
 static int __init
diff --git a/sound/pci/azt3328.h b/sound/pci/azt3328.h
index f489bdaf6d40..b4f3e3cd006b 100644
--- a/sound/pci/azt3328.h
+++ b/sound/pci/azt3328.h
@@ -5,6 +5,9 @@
 
 /*** main I/O area port indices ***/
 /* (only 0x70 of 0x80 bytes saved/restored by Windows driver) */
+#define AZF_IO_SIZE_CODEC       0x80
+#define AZF_IO_SIZE_CODEC_PM    0x70
+
 /* the driver initialisation suggests a layout of 4 main areas:
  * from 0x00 (playback), from 0x20 (recording) and from 0x40 (maybe MPU401??).
  * And another area from 0x60 to 0x6f (DirectX timer, IRQ management,
@@ -87,7 +90,7 @@
 #define IDX_IO_REC_DMA_CURROFS  0x34 /* PU:0x00000000 */
 #define IDX_IO_REC_SOUNDFORMAT  0x36 /* PU:0x0000 */
 
-/** hmm, what is this I/O area for? MPU401?? (after playback, recording, ???, timer) **/
+/** hmm, what is this I/O area for? MPU401?? or external DAC via I2S?? (after playback, recording, ???, timer) **/
 #define IDX_IO_SOMETHING_FLAGS  0x40 /* gets set to 0x34 just like port 0x0 and 0x20 on card init, PU:0x0000 */
 /* general */
 #define IDX_IO_42H              0x42 /* PU:0x0001 */
@@ -107,7 +110,8 @@
   #define IRQ_UNKNOWN2                  0x0080 /* probably unused */
 #define IDX_IO_66H              0x66    /* writing 0xffff returns 0x0000 */
 #define IDX_IO_SOME_VALUE       0x68    /* this is set to e.g. 0x3ff or 0x300, and writable; maybe some buffer limit, but I couldn't find out more, PU:0x00ff */
-#define IDX_IO_6AH              0x6A    /* this WORD can be set to have bits 0x0028 activated; actually inhibits PCM playback!!! maybe power management?? */
+#define IDX_IO_6AH              0x6A    /* this WORD can be set to have bits 0x0028 activated (FIXME: correct??); actually inhibits PCM playback!!! maybe power management?? */
+  #define IO_6A_PAUSE_PLAYBACK          0x0200 /* bit 9; sure, this pauses playback, but what the heck is this really about?? */
 #define IDX_IO_6CH              0x6C
 #define IDX_IO_6EH              0x6E    /* writing 0xffff returns 0x83fe */
 /* further I/O indices not saved/restored, so probably not used */
@@ -115,15 +119,25 @@
 
 /*** I/O 2 area port indices ***/
 /* (only 0x06 of 0x08 bytes saved/restored by Windows driver) */ 
+#define AZF_IO_SIZE_IO2         0x08
+#define AZF_IO_SIZE_IO2_PM      0x06
+
 #define IDX_IO2_LEGACY_ADDR     0x04
   #define LEGACY_SOMETHING              0x01 /* OPL3?? */
   #define LEGACY_JOY                    0x08
 
+#define AZF_IO_SIZE_MPU         0x04
+#define AZF_IO_SIZE_MPU_PM      0x04
+
+#define AZF_IO_SIZE_SYNTH       0x08
+#define AZF_IO_SIZE_SYNTH_PM    0x06
 
 /*** mixer I/O area port indices ***/
 /* (only 0x22 of 0x40 bytes saved/restored by Windows driver)
- * generally spoken: AC97 register index = AZF3328 mixer reg index + 2
- * (in other words: AZF3328 NOT fully AC97 compliant) */
+ * UNFORTUNATELY azf3328 is NOT truly AC97 compliant: see main file intro */
+#define AZF_IO_SIZE_MIXER       0x40
+#define AZF_IO_SIZE_MIXER_PM    0x22
+
   #define MIXER_VOLUME_RIGHT_MASK       0x001f
   #define MIXER_VOLUME_LEFT_MASK        0x1f00
   #define MIXER_MUTE_MASK               0x8000
@@ -156,14 +170,14 @@
 #define IDX_MIXER_ADVCTL1       0x1e
   /* unlisted bits are unmodifiable */
   #define MIXER_ADVCTL1_3DWIDTH_MASK    0x000e
-  #define MIXER_ADVCTL1_HIFI3D_MASK     0x0300
-#define IDX_MIXER_ADVCTL2       0x20 /* resembles AC97_GENERAL_PURPOSE reg! */
+  #define MIXER_ADVCTL1_HIFI3D_MASK     0x0300 /* yup, this is missing the high bit that official AC97 contains, plus it doesn't have linear bit value range behaviour but instead acts weirdly (possibly we're dealing with two *different* 3D settings here??) */
+#define IDX_MIXER_ADVCTL2       0x20 /* subset of AC97_GENERAL_PURPOSE reg! */
   /* unlisted bits are unmodifiable */
-  #define MIXER_ADVCTL2_BIT7            0x0080 /* WaveOut 3D Bypass? mutes WaveOut at LineOut */
-  #define MIXER_ADVCTL2_BIT8            0x0100 /* is this Modem Out Select? */
-  #define MIXER_ADVCTL2_BIT9            0x0200 /* Mono Select Source? */
-  #define MIXER_ADVCTL2_BIT13           0x2000 /* 3D enable? */
-  #define MIXER_ADVCTL2_BIT15           0x8000 /* unknown */
+  #define MIXER_ADVCTL2_LPBK            0x0080 /* Loopback mode -- Win driver: "WaveOut3DBypass"? mutes WaveOut at LineOut */
+  #define MIXER_ADVCTL2_MS              0x0100 /* Mic Select 0=Mic1, 1=Mic2 -- Win driver: "ModemOutSelect"?? */
+  #define MIXER_ADVCTL2_MIX             0x0200 /* Mono output select 0=Mix, 1=Mic; Win driver: "MonoSelectSource"?? */
+  #define MIXER_ADVCTL2_3D              0x2000 /* 3D Enhancement 1=on */
+  #define MIXER_ADVCTL2_POP             0x8000 /* Pcm Out Path, 0=pre 3D, 1=post 3D */
   
 #define IDX_MIXER_SOMETHING30H  0x30 /* used, but unknown??? */
 
diff --git a/sound/pci/bt87x.c b/sound/pci/bt87x.c
index 9ee07d4aac1e..c33642d8d9a1 100644
--- a/sound/pci/bt87x.c
+++ b/sound/pci/bt87x.c
@@ -44,7 +44,7 @@ MODULE_SUPPORTED_DEVICE("{{Brooktree,Bt878},"
 static int index[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = -2}; /* Exclude the first card */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;      /* Enable this card */
-static int digital_rate[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0 }; /* digital input rate */
+static int digital_rate[SNDRV_CARDS];   /* digital input rate */
 static int load_all;    /* allow to load the non-whitelisted cards */
 
 module_param_array(index, int, NULL, 0444);
@@ -781,10 +781,12 @@ static struct pci_device_id snd_bt87x_ids[] __devinitdata = {
         BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_879, 0x0070, 0x13eb, 32000),
         /* Viewcast Osprey 200 */
         BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x0070, 0xff01, 44100),
-        /* AVerMedia Studio No. 103, 203, ...? */
-        BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x1461, 0x0003, 48000),
         /* Leadtek Winfast tv 2000xp delux */
         BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x107d, 0x6606, 32000),
+        /* Voodoo TV 200 */
+        BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x121a, 0x3000, 32000),
+        /* AVerMedia Studio No. 103, 203, ...? */
+        BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x1461, 0x0003, 48000),
         { }
 };
 MODULE_DEVICE_TABLE(pci, snd_bt87x_ids);
diff --git a/sound/pci/ca0106/ca0106.h b/sound/pci/ca0106/ca0106.h
index c8131ea92ed6..9cb66c59f523 100644
--- a/sound/pci/ca0106/ca0106.h
+++ b/sound/pci/ca0106/ca0106.h
@@ -537,9 +537,9 @@
 #endif
 
 #define ADC_MUX_MASK            0x0000000f      //Mask for ADC Mux
+#define ADC_MUX_PHONE           0x00000001      //Value to select TAD at ADC Mux (Not used)
 #define ADC_MUX_MIC             0x00000002      //Value to select Mic at ADC Mux
 #define ADC_MUX_LINEIN          0x00000004      //Value to select LineIn at ADC Mux
-#define ADC_MUX_PHONE           0x00000001      //Value to select TAD at ADC Mux (Not used)
 #define ADC_MUX_AUX             0x00000008      //Value to select Aux at ADC Mux
 
 #define SET_CHANNEL 0  /* Testing channel outputs 0=Front, 1=Center/LFE, 2=Unknown, 3=Rear */
@@ -604,6 +604,8 @@ struct snd_ca0106 {
         u32 spdif_bits[4];             /* s/pdif out setup */
         int spdif_enable;
         int capture_source;
+        int i2c_capture_source;
+        u8 i2c_capture_volume[4][2];
         int capture_mic_line_in;
 
         struct snd_dma_buffer buffer;
diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c
index fd8bfebfbd54..59bf9bd02534 100644
--- a/sound/pci/ca0106/ca0106_main.c
+++ b/sound/pci/ca0106/ca0106_main.c
@@ -186,8 +186,8 @@ static struct snd_ca0106_details ca0106_chip_details[] = {
          /* New Audigy SE. Has a different DAC. */
          /* SB0570:
           * CTRL:CA0106-DAT
-          * ADC: WM8768GEDS
-          * DAC: WM8775EDS
+          * ADC: WM8775EDS
+          * DAC: WM8768GEDS
           */
          { .serial = 0x100a1102,
            .name   = "Audigy SE [SB0570]",
@@ -195,9 +195,14 @@ static struct snd_ca0106_details ca0106_chip_details[] = {
            .i2c_adc = 1,
            .spi_dac = 1 } ,
          /* MSI K8N Diamond Motherboard with onboard SB Live 24bit without AC97 */
+         /* SB0438
+          * CTRL:CA0106-DAT
+          * ADC: WM8775SEDS
+          * DAC: CS4382-KQZ
+          */
          { .serial = 0x10091462,
            .name   = "MSI K8N Diamond MB [SB0438]",
-           .gpio_type = 1,
+           .gpio_type = 2,
            .i2c_adc = 1 } ,
          /* Shuttle XPC SD31P which has an onboard Creative Labs
           * Sound Blaster Live! 24-bit EAX
@@ -326,6 +331,7 @@ int snd_ca0106_spi_write(struct snd_ca0106 * emu,
         return 0;
 }
 
+/* The ADC does not support i2c read, so only write is implemented */
 int snd_ca0106_i2c_write(struct snd_ca0106 *emu,
                                 u32 reg,
                                 u32 value)
@@ -340,6 +346,7 @@ int snd_ca0106_i2c_write(struct snd_ca0106 *emu,
         }
 
         tmp = reg << 25 | value << 16;
+        // snd_printk("I2C-write:reg=0x%x, value=0x%x\n", reg, value);
         /* Not sure what this I2C channel controls. */
         /* snd_ca0106_ptr_write(emu, I2C_D0, 0, tmp); */
 
@@ -348,8 +355,9 @@ int snd_ca0106_i2c_write(struct snd_ca0106 *emu,
 
         for (retry = 0; retry < 10; retry++) {
                 /* Send the data to i2c */
-                tmp = snd_ca0106_ptr_read(emu, I2C_A, 0);
-                tmp = tmp & ~(I2C_A_ADC_READ|I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD_MASK);
+                //tmp = snd_ca0106_ptr_read(emu, I2C_A, 0);
+                //tmp = tmp & ~(I2C_A_ADC_READ|I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD_MASK);
+                tmp = 0;
                 tmp = tmp | (I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD);
                 snd_ca0106_ptr_write(emu, I2C_A, 0, tmp);
 
@@ -1181,7 +1189,7 @@ static unsigned int spi_dac_init[] = {
         0x02ff,
         0x0400,
         0x0520,
-        0x0600,
+        0x0620, /* Set 24 bit. Was 0x0600 */
         0x08ff,
         0x0aff,
         0x0cff,
@@ -1200,6 +1208,22 @@ static unsigned int spi_dac_init[] = {
         0x1400,
 };
 
+static unsigned int i2c_adc_init[][2] = {
+        { 0x17, 0x00 }, /* Reset */
+        { 0x07, 0x00 }, /* Timeout */
+        { 0x0b, 0x22 },  /* Interface control */
+        { 0x0c, 0x22 },  /* Master mode control */
+        { 0x0d, 0x08 },  /* Powerdown control */
+        { 0x0e, 0xcf },  /* Attenuation Left  0x01 = -103dB, 0xff = 24dB */
+        { 0x0f, 0xcf },  /* Attenuation Right 0.5dB steps */
+        { 0x10, 0x7b },  /* ALC Control 1 */
+        { 0x11, 0x00 },  /* ALC Control 2 */
+        { 0x12, 0x32 },  /* ALC Control 3 */
+        { 0x13, 0x00 },  /* Noise gate control */
+        { 0x14, 0xa6 },  /* Limiter control */
+        { 0x15, ADC_MUX_LINEIN },  /* ADC Mixer control */
+};
+
 static int __devinit snd_ca0106_create(struct snd_card *card,
                                          struct pci_dev *pci,
                                          struct snd_ca0106 **rchip)
@@ -1361,7 +1385,12 @@ static int __devinit snd_ca0106_create(struct snd_card *card,
         snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4); /* Select MIC, Line in, TAD in, AUX in */
         chip->capture_source = 3; /* Set CAPTURE_SOURCE */
 
-        if (chip->details->gpio_type == 1) { /* The SB0410 and SB0413 use GPIO differently. */
+        if (chip->details->gpio_type == 2) { /* The SB0438 use GPIO differently. */
+                /* FIXME: Still need to find out what the other GPIO bits do. E.g. For digital spdif out. */
+                outl(0x0, chip->port+GPIO);
+                //outl(0x00f0e000, chip->port+GPIO); /* Analog */
+                outl(0x005f5301, chip->port+GPIO); /* Analog */
+        } else if (chip->details->gpio_type == 1) { /* The SB0410 and SB0413 use GPIO differently. */
                 /* FIXME: Still need to find out what the other GPIO bits do. E.g. For digital spdif out. */
                 outl(0x0, chip->port+GPIO);
                 //outl(0x00f0e000, chip->port+GPIO); /* Analog */
@@ -1379,7 +1408,19 @@ static int __devinit snd_ca0106_create(struct snd_card *card,
         outl(HCFG_AC97 | HCFG_AUDIOENABLE, chip->port+HCFG); /* AC97 2.0, Enable outputs. */
 
         if (chip->details->i2c_adc == 1) { /* The SB0410 and SB0413 use I2C to control ADC. */
-                snd_ca0106_i2c_write(chip, ADC_MUX, ADC_MUX_LINEIN); /* Enable Line-in capture. MIC in currently untested. */
+                int size, n;
+
+                size = ARRAY_SIZE(i2c_adc_init);
+                //snd_printk("I2C:array size=0x%x\n", size);
+                for (n=0; n < size; n++) {
+                        snd_ca0106_i2c_write(chip, i2c_adc_init[n][0], i2c_adc_init[n][1]);
+                }
+                for (n=0; n < 4; n++) {
+                        chip->i2c_capture_volume[n][0]= 0xcf;
+                        chip->i2c_capture_volume[n][1]= 0xcf;
+                }
+                chip->i2c_capture_source=2; /* Line in */
+                //snd_ca0106_i2c_write(chip, ADC_MUX, ADC_MUX_LINEIN); /* Enable Line-in capture. MIC in currently untested. */
         }
         if (chip->details->spi_dac == 1) { /* The SB0570 use SPI to control DAC. */
                 int size, n;
diff --git a/sound/pci/ca0106/ca0106_mixer.c b/sound/pci/ca0106/ca0106_mixer.c
index 06fe055674fb..146eed70dce6 100644
--- a/sound/pci/ca0106/ca0106_mixer.c
+++ b/sound/pci/ca0106/ca0106_mixer.c
@@ -171,6 +171,76 @@ static int snd_ca0106_capture_source_put(struct snd_kcontrol *kcontrol,
         return change;
 }
 
+static int snd_ca0106_i2c_capture_source_info(struct snd_kcontrol *kcontrol,
+                                          struct snd_ctl_elem_info *uinfo)
+{
+        static char *texts[6] = {
+                "Phone", "Mic", "Line in", "Aux"
+        };
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 4;
+        if (uinfo->value.enumerated.item > 3)
+                uinfo->value.enumerated.item = 3;
+        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
+static int snd_ca0106_i2c_capture_source_get(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
+
+        ucontrol->value.enumerated.item[0] = emu->i2c_capture_source;
+        return 0;
+}
+
+static int snd_ca0106_i2c_capture_source_put(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
+        unsigned int source_id;
+        unsigned int ngain, ogain;
+        int change = 0;
+        u32 source;
+        /* If the capture source has changed,
+         * update the capture volume from the cached value
+         * for the particular source.
+         */
+        source_id = ucontrol->value.enumerated.item[0] ;
+        change = (emu->i2c_capture_source != source_id);
+        if (change) {
+                snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
+                ngain = emu->i2c_capture_volume[source_id][0]; /* Left */
+                ogain = emu->i2c_capture_volume[emu->i2c_capture_source][0]; /* Left */
+                if (ngain != ogain)
+                        snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff));
+                ngain = emu->i2c_capture_volume[source_id][1]; /* Left */
+                ogain = emu->i2c_capture_volume[emu->i2c_capture_source][1]; /* Left */
+                if (ngain != ogain)
+                        snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
+                source = 1 << source_id;
+                snd_ca0106_i2c_write(emu, ADC_MUX, source); /* Set source */
+                emu->i2c_capture_source = source_id;
+        }
+        return change;
+}
+
+static int snd_ca0106_capture_line_in_side_out_info(struct snd_kcontrol *kcontrol,
+                                               struct snd_ctl_elem_info *uinfo)
+{
+        static char *texts[2] = { "Side out", "Line in" };
+
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 2;
+        if (uinfo->value.enumerated.item > 1)
+                uinfo->value.enumerated.item = 1;
+        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
 static int snd_ca0106_capture_mic_line_in_info(struct snd_kcontrol *kcontrol,
                                                struct snd_ctl_elem_info *uinfo)
 {
@@ -207,16 +277,16 @@ static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
         if (change) {
                 emu->capture_mic_line_in = val;
                 if (val) {
-                        snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_PHONE); /* Mute input */
+                        //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
                         tmp = inl(emu->port+GPIO) & ~0x400;
                         tmp = tmp | 0x400;
                         outl(tmp, emu->port+GPIO);
-                        snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC);
+                        //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_MIC);
                 } else {
-                        snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_PHONE); /* Mute input */
+                        //snd_ca0106_i2c_write(emu, ADC_MUX, 0); /* Mute input */
                         tmp = inl(emu->port+GPIO) & ~0x400;
                         outl(tmp, emu->port+GPIO);
-                        snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN);
+                        //snd_ca0106_i2c_write(emu, ADC_MUX, ADC_MUX_LINEIN);
                 }
         }
         return change;
@@ -225,12 +295,22 @@ static int snd_ca0106_capture_mic_line_in_put(struct snd_kcontrol *kcontrol,
 static struct snd_kcontrol_new snd_ca0106_capture_mic_line_in __devinitdata =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name =         "Mic/Line in Capture",
+        .name =         "Shared Mic/Line in Capture Switch",
         .info =         snd_ca0106_capture_mic_line_in_info,
         .get =          snd_ca0106_capture_mic_line_in_get,
         .put =          snd_ca0106_capture_mic_line_in_put
 };
 
+static struct snd_kcontrol_new snd_ca0106_capture_line_in_side_out __devinitdata =
+{
+        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name =         "Shared Line in/Side out Capture Switch",
+        .info =         snd_ca0106_capture_line_in_side_out_info,
+        .get =          snd_ca0106_capture_mic_line_in_get,
+        .put =          snd_ca0106_capture_mic_line_in_put
+};
+
+
 static int snd_ca0106_spdif_info(struct snd_kcontrol *kcontrol,
                                  struct snd_ctl_elem_info *uinfo)
 {
@@ -329,15 +409,81 @@ static int snd_ca0106_volume_put(struct snd_kcontrol *kcontrol,
         return 1;
 }
 
+static int snd_ca0106_i2c_volume_info(struct snd_kcontrol *kcontrol,
+                                  struct snd_ctl_elem_info *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 2;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 255;
+        return 0;
+}
+
+static int snd_ca0106_i2c_volume_get(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
+        int source_id;
+
+        source_id = kcontrol->private_value;
+
+        ucontrol->value.integer.value[0] = emu->i2c_capture_volume[source_id][0];
+        ucontrol->value.integer.value[1] = emu->i2c_capture_volume[source_id][1];
+        return 0;
+}
+
+static int snd_ca0106_i2c_volume_put(struct snd_kcontrol *kcontrol,
+                                 struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_ca0106 *emu = snd_kcontrol_chip(kcontrol);
+        unsigned int ogain;
+        unsigned int ngain;
+        int source_id;
+        int change = 0;
+
+        source_id = kcontrol->private_value;
+        ogain = emu->i2c_capture_volume[source_id][0]; /* Left */
+        ngain = ucontrol->value.integer.value[0];
+        if (ngain > 0xff)
+                return 0;
+        if (ogain != ngain) {
+                if (emu->i2c_capture_source == source_id)
+                        snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCL, ((ngain) & 0xff) );
+                emu->i2c_capture_volume[source_id][0] = ucontrol->value.integer.value[0];
+                change = 1;
+        }
+        ogain = emu->i2c_capture_volume[source_id][1]; /* Right */
+        ngain = ucontrol->value.integer.value[1];
+        if (ngain > 0xff)
+                return 0;
+        if (ogain != ngain) {
+                if (emu->i2c_capture_source == source_id)
+                        snd_ca0106_i2c_write(emu, ADC_ATTEN_ADCR, ((ngain) & 0xff));
+                emu->i2c_capture_volume[source_id][1] = ucontrol->value.integer.value[1];
+                change = 1;
+        }
+
+        return change;
+}
+
 #define CA_VOLUME(xname,chid,reg) \
 {                                                               \
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,     \
-        .info = snd_ca0106_volume_info,                         \
-        .get =          snd_ca0106_volume_get,                  \
-        .put =          snd_ca0106_volume_put,                  \
+        .info =  snd_ca0106_volume_info,                        \
+        .get =   snd_ca0106_volume_get,                         \
+        .put =   snd_ca0106_volume_put,                         \
         .private_value = ((chid) << 8) | (reg)                  \
 }
 
+#define I2C_VOLUME(xname,chid) \
+{                                                               \
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,     \
+        .info =  snd_ca0106_i2c_volume_info,                    \
+        .get =   snd_ca0106_i2c_volume_get,                     \
+        .put =   snd_ca0106_i2c_volume_put,                     \
+        .private_value = chid                                   \
+}
+
 
 static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = {
         CA_VOLUME("Analog Front Playback Volume",
@@ -361,6 +507,11 @@ static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = {
         CA_VOLUME("CAPTURE feedback Playback Volume",
                   1, CAPTURE_CONTROL),
 
+        I2C_VOLUME("Phone Capture Volume", 0),
+        I2C_VOLUME("Mic Capture Volume", 1),
+        I2C_VOLUME("Line in Capture Volume", 2),
+        I2C_VOLUME("Aux Capture Volume", 3),
+
         {
                 .access =       SNDRV_CTL_ELEM_ACCESS_READ,
                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
@@ -378,12 +529,19 @@ static struct snd_kcontrol_new snd_ca0106_volume_ctls[] __devinitdata = {
         },
         {
                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name =         "Capture Source",
+                .name =         "Digital Capture Source",
                 .info =         snd_ca0106_capture_source_info,
                 .get =          snd_ca0106_capture_source_get,
                 .put =          snd_ca0106_capture_source_put
         },
         {
+                .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name =         "Capture Source",
+                .info =         snd_ca0106_i2c_capture_source_info,
+                .get =          snd_ca0106_i2c_capture_source_get,
+                .put =          snd_ca0106_i2c_capture_source_put
+        },
+        {
                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
                 .count =        4,
@@ -477,7 +635,10 @@ int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu)
                         return err;
         }
         if (emu->details->i2c_adc == 1) {
-                err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu));
+                if (emu->details->gpio_type == 1)
+                        err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_mic_line_in, emu));
+                else  /* gpio_type == 2 */
+                        err = snd_ctl_add(card, snd_ctl_new1(&snd_ca0106_capture_line_in_side_out, emu));
                 if (err < 0)
                         return err;
         }
diff --git a/sound/pci/ca0106/ca0106_proc.c b/sound/pci/ca0106/ca0106_proc.c
index 63757273bfb7..75ca421eb3a1 100644
--- a/sound/pci/ca0106/ca0106_proc.c
+++ b/sound/pci/ca0106/ca0106_proc.c
@@ -431,33 +431,30 @@ int __devinit snd_ca0106_proc_init(struct snd_ca0106 * emu)
         struct snd_info_entry *entry;
         
         if(! snd_card_proc_new(emu->card, "iec958", &entry))
-                snd_info_set_text_ops(entry, emu, 1024, snd_ca0106_proc_iec958);
+                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_iec958);
         if(! snd_card_proc_new(emu->card, "ca0106_reg32", &entry)) {
-                snd_info_set_text_ops(entry, emu, 1024, snd_ca0106_proc_reg_read32);
-                entry->c.text.write_size = 64;
+                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read32);
                 entry->c.text.write = snd_ca0106_proc_reg_write32;
                 entry->mode |= S_IWUSR;
         }
         if(! snd_card_proc_new(emu->card, "ca0106_reg16", &entry))
-                snd_info_set_text_ops(entry, emu, 1024, snd_ca0106_proc_reg_read16);
+                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read16);
         if(! snd_card_proc_new(emu->card, "ca0106_reg8", &entry))
-                snd_info_set_text_ops(entry, emu, 1024, snd_ca0106_proc_reg_read8);
+                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read8);
         if(! snd_card_proc_new(emu->card, "ca0106_regs1", &entry)) {
-                snd_info_set_text_ops(entry, emu, 1024, snd_ca0106_proc_reg_read1);
-                entry->c.text.write_size = 64;
+                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read1);
                 entry->c.text.write = snd_ca0106_proc_reg_write;
                 entry->mode |= S_IWUSR;
 //              entry->private_data = emu;
         }
         if(! snd_card_proc_new(emu->card, "ca0106_i2c", &entry)) {
-                snd_info_set_text_ops(entry, emu, 1024, snd_ca0106_proc_i2c_write);
-                entry->c.text.write_size = 64;
+                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_i2c_write);
                 entry->c.text.write = snd_ca0106_proc_i2c_write;
                 entry->mode |= S_IWUSR;
 //              entry->private_data = emu;
         }
         if(! snd_card_proc_new(emu->card, "ca0106_regs2", &entry)) 
-                snd_info_set_text_ops(entry, emu, 1024, snd_ca0106_proc_reg_read2);
+                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read2);
         return 0;
 }
 
diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c
index e5ce2dabd081..0938c158b5c9 100644
--- a/sound/pci/cmipci.c
+++ b/sound/pci/cmipci.c
@@ -2121,7 +2121,7 @@ static struct snd_kcontrol_new snd_cmipci_mixers[] __devinitdata = {
         CMIPCI_MIXER_VOL_MONO("Mic Capture Volume", CM_REG_MIXER2, CM_VADMIC_SHIFT, 7),
         CMIPCI_SB_VOL_MONO("Phone Playback Volume", CM_REG_EXTENT_IND, 5, 7),
         CMIPCI_DOUBLE("Phone Playback Switch", CM_REG_EXTENT_IND, CM_REG_EXTENT_IND, 4, 4, 1, 0, 0),
-        CMIPCI_DOUBLE("PC Speaker Playnack Switch", CM_REG_EXTENT_IND, CM_REG_EXTENT_IND, 3, 3, 1, 0, 0),
+        CMIPCI_DOUBLE("PC Speaker Playback Switch", CM_REG_EXTENT_IND, CM_REG_EXTENT_IND, 3, 3, 1, 0, 0),
         CMIPCI_DOUBLE("Mic Boost Capture Switch", CM_REG_EXTENT_IND, CM_REG_EXTENT_IND, 0, 0, 1, 0, 0),
 };
 
@@ -2602,7 +2602,7 @@ static void __devinit snd_cmipci_proc_init(struct cmipci *cm)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(cm->card, "cmipci", &entry))
-                snd_info_set_text_ops(entry, cm, 1024, snd_cmipci_proc_read);
+                snd_info_set_text_ops(entry, cm, snd_cmipci_proc_read);
 }
 #else /* !CONFIG_PROC_FS */
 static inline void snd_cmipci_proc_init(struct cmipci *cm) {}
@@ -2932,7 +2932,7 @@ static int __devinit snd_cmipci_create(struct snd_card *card, struct pci_dev *pc
         }
 
         integrated_midi = snd_cmipci_read_b(cm, CM_REG_MPU_PCI) != 0xff;
-        if (integrated_midi)
+        if (integrated_midi && mpu_port[dev] == 1)
                 iomidi = cm->iobase + CM_REG_MPU_PCI;
         else {
                 iomidi = mpu_port[dev];
@@ -2981,7 +2981,9 @@ static int __devinit snd_cmipci_create(struct snd_card *card, struct pci_dev *pc
 
         if (iomidi > 0) {
                 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_CMIPCI,
-                                               iomidi, integrated_midi,
+                                               iomidi,
+                                               (integrated_midi ?
+                                                MPU401_INFO_INTEGRATED : 0),
                                                cm->irq, 0, &cm->rmidi)) < 0) {
                         printk(KERN_ERR "cmipci: no UART401 device at 0x%lx\n", iomidi);
                 }
diff --git a/sound/pci/cs4281.c b/sound/pci/cs4281.c
index b3c94d83450a..e77a4ce314b7 100644
--- a/sound/pci/cs4281.c
+++ b/sound/pci/cs4281.c
@@ -1184,7 +1184,7 @@ static void __devinit snd_cs4281_proc_init(struct cs4281 * chip)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(chip->card, "cs4281", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, snd_cs4281_proc_read);
+                snd_info_set_text_ops(entry, chip, snd_cs4281_proc_read);
         if (! snd_card_proc_new(chip->card, "cs4281_BA0", &entry)) {
                 entry->content = SNDRV_INFO_CONTENT_DATA;
                 entry->private_data = chip;
@@ -1379,6 +1379,13 @@ static int __devinit snd_cs4281_create(struct snd_card *card,
         chip->ba0_addr = pci_resource_start(pci, 0);
         chip->ba1_addr = pci_resource_start(pci, 1);
 
+        chip->ba0 = ioremap_nocache(chip->ba0_addr, pci_resource_len(pci, 0));
+        chip->ba1 = ioremap_nocache(chip->ba1_addr, pci_resource_len(pci, 1));
+        if (!chip->ba0 || !chip->ba1) {
+                snd_cs4281_free(chip);
+                return -ENOMEM;
+        }
+        
         if (request_irq(pci->irq, snd_cs4281_interrupt, SA_INTERRUPT|SA_SHIRQ,
                         "CS4281", chip)) {
                 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
@@ -1387,13 +1394,6 @@ static int __devinit snd_cs4281_create(struct snd_card *card,
         }
         chip->irq = pci->irq;
 
-        chip->ba0 = ioremap_nocache(chip->ba0_addr, pci_resource_len(pci, 0));
-        chip->ba1 = ioremap_nocache(chip->ba1_addr, pci_resource_len(pci, 1));
-        if (!chip->ba0 || !chip->ba1) {
-                snd_cs4281_free(chip);
-                return -ENOMEM;
-        }
-        
         tmp = snd_cs4281_chip_init(chip);
         if (tmp) {
                 snd_cs4281_free(chip);
diff --git a/sound/pci/cs46xx/cs46xx.c b/sound/pci/cs46xx/cs46xx.c
index 848d772ae3c6..772dc52bfeb2 100644
--- a/sound/pci/cs46xx/cs46xx.c
+++ b/sound/pci/cs46xx/cs46xx.c
@@ -48,8 +48,8 @@ MODULE_SUPPORTED_DEVICE("{{Cirrus Logic,Sound Fusion (CS4280)},"
 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_PNP;      /* Enable this card */
-static int external_amp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0};
-static int thinkpad[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0};
+static int external_amp[SNDRV_CARDS];
+static int thinkpad[SNDRV_CARDS];
 static int mmap_valid[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
 
 module_param_array(index, int, NULL, 0444);
diff --git a/sound/pci/cs46xx/cs46xx_lib.c b/sound/pci/cs46xx/cs46xx_lib.c
index 69dbf542a6de..5c2114439204 100644
--- a/sound/pci/cs46xx/cs46xx_lib.c
+++ b/sound/pci/cs46xx/cs46xx_lib.c
@@ -2877,14 +2877,15 @@ static int snd_cs46xx_free(struct snd_cs46xx *chip)
         if (chip->region.idx[0].resource)
                 snd_cs46xx_hw_stop(chip);
 
+        if (chip->irq >= 0)
+                free_irq(chip->irq, chip);
+
         for (idx = 0; idx < 5; idx++) {
                 struct snd_cs46xx_region *region = &chip->region.idx[idx];
                 if (region->remap_addr)
                         iounmap(region->remap_addr);
                 release_and_free_resource(region->resource);
         }
-        if (chip->irq >= 0)
-                free_irq(chip->irq, chip);
 
         if (chip->active_ctrl)
                 chip->active_ctrl(chip, -chip->amplifier);
diff --git a/sound/pci/cs46xx/dsp_spos.c b/sound/pci/cs46xx/dsp_spos.c
index f407d2a5ce3b..5c9711c0265c 100644
--- a/sound/pci/cs46xx/dsp_spos.c
+++ b/sound/pci/cs46xx/dsp_spos.c
@@ -767,7 +767,6 @@ int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip)
         if ((entry = snd_info_create_card_entry(card, "dsp", card->proc_root)) != NULL) {
                 entry->content = SNDRV_INFO_CONTENT_TEXT;
                 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
-                entry->c.text.read_size = 512;
       
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
@@ -784,7 +783,6 @@ int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip)
                 entry->content = SNDRV_INFO_CONTENT_TEXT;
                 entry->private_data = chip;
                 entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 512;
                 entry->c.text.read = cs46xx_dsp_proc_symbol_table_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
@@ -797,7 +795,6 @@ int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip)
                 entry->content = SNDRV_INFO_CONTENT_TEXT;
                 entry->private_data = chip;
                 entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 512;
                 entry->c.text.read = cs46xx_dsp_proc_modules_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
@@ -810,7 +807,6 @@ int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip)
                 entry->content = SNDRV_INFO_CONTENT_TEXT;
                 entry->private_data = chip;
                 entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 512;
                 entry->c.text.read = cs46xx_dsp_proc_parameter_dump_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
@@ -823,7 +819,6 @@ int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip)
                 entry->content = SNDRV_INFO_CONTENT_TEXT;
                 entry->private_data = chip;
                 entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 512;
                 entry->c.text.read = cs46xx_dsp_proc_sample_dump_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
@@ -836,7 +831,6 @@ int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip)
                 entry->content = SNDRV_INFO_CONTENT_TEXT;
                 entry->private_data = chip;
                 entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 512;
                 entry->c.text.read = cs46xx_dsp_proc_task_tree_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
@@ -849,7 +843,6 @@ int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip)
                 entry->content = SNDRV_INFO_CONTENT_TEXT;
                 entry->private_data = chip;
                 entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 1024;
                 entry->c.text.read = cs46xx_dsp_proc_scb_read;
                 if (snd_info_register(entry) < 0) {
                         snd_info_free_entry(entry);
diff --git a/sound/pci/cs46xx/dsp_spos_scb_lib.c b/sound/pci/cs46xx/dsp_spos_scb_lib.c
index 2c4ee45fe10c..3844d18af19c 100644
--- a/sound/pci/cs46xx/dsp_spos_scb_lib.c
+++ b/sound/pci/cs46xx/dsp_spos_scb_lib.c
@@ -267,7 +267,6 @@ void cs46xx_dsp_proc_register_scb_desc (struct snd_cs46xx *chip,
                         entry->private_data = scb_info;
                         entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
       
-                        entry->c.text.read_size = 512;
                         entry->c.text.read = cs46xx_dsp_proc_scb_info_read;
       
                         if (snd_info_register(entry) < 0) {
diff --git a/sound/pci/cs5535audio/Makefile b/sound/pci/cs5535audio/Makefile
index 08d8ee6547d3..2911a8adc1f2 100644
--- a/sound/pci/cs5535audio/Makefile
+++ b/sound/pci/cs5535audio/Makefile
@@ -4,5 +4,9 @@
 
 snd-cs5535audio-objs := cs5535audio.o cs5535audio_pcm.o
 
+ifdef CONFIG_PM
+snd-cs5535audio-objs += cs5535audio_pm.o
+endif
+
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_CS5535AUDIO) += snd-cs5535audio.o
diff --git a/sound/pci/cs5535audio/cs5535audio.c b/sound/pci/cs5535audio/cs5535audio.c
index 2c1213a35dcc..91c18a11fe87 100644
--- a/sound/pci/cs5535audio/cs5535audio.c
+++ b/sound/pci/cs5535audio/cs5535audio.c
@@ -1,5 +1,5 @@
 /*
- * Driver for audio on multifunction CS5535 companion device
+ * Driver for audio on multifunction CS5535/6 companion device
  * Copyright (C) Jaya Kumar
  *
  * Based on Jaroslav Kysela and Takashi Iwai's examples.
@@ -40,16 +40,36 @@
 
 #define DRIVER_NAME "cs5535audio"
 
+static char *ac97_quirk;
+module_param(ac97_quirk, charp, 0444);
+MODULE_PARM_DESC(ac97_quirk, "AC'97 board specific workarounds.");
+
+static struct ac97_quirk ac97_quirks[] __devinitdata = {
+#if 0 /* Not yet confirmed if all 5536 boards are HP only */
+        {
+                .subvendor = PCI_VENDOR_ID_AMD, 
+                .subdevice = PCI_DEVICE_ID_AMD_CS5536_AUDIO, 
+                .name = "AMD RDK",     
+                .type = AC97_TUNE_HP_ONLY
+        },
+#endif
+        {}
+};
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
 
+module_param_array(index, int, NULL, 0444);
+MODULE_PARM_DESC(index, "Index value for " DRIVER_NAME);
+module_param_array(id, charp, NULL, 0444);
+MODULE_PARM_DESC(id, "ID string for " DRIVER_NAME);
+module_param_array(enable, bool, NULL, 0444);
+MODULE_PARM_DESC(enable, "Enable " DRIVER_NAME);
+
 static struct pci_device_id snd_cs5535audio_ids[] __devinitdata = {
-        { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_AUDIO,
-          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
-        { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_AUDIO,
-          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
+        { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_AUDIO) },
+        { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_AUDIO) },
         {}
 };
 
@@ -90,7 +110,8 @@ static unsigned short snd_cs5535audio_codec_read(struct cs5535audio *cs5535au,
                 udelay(1);
         } while (--timeout);
         if (!timeout)
-                snd_printk(KERN_ERR "Failure reading cs5535 codec\n");
+                snd_printk(KERN_ERR "Failure reading codec reg 0x%x,"
+                                        "Last value=0x%x\n", reg, val);
 
         return (unsigned short) val;
 }
@@ -148,6 +169,8 @@ static int snd_cs5535audio_mixer(struct cs5535audio *cs5535au)
                 return err;
         }
 
+        snd_ac97_tune_hardware(cs5535au->ac97, ac97_quirks, ac97_quirk);
+
         return 0;
 }
 
@@ -347,6 +370,8 @@ static int __devinit snd_cs5535audio_probe(struct pci_dev *pci,
         if ((err = snd_cs5535audio_create(card, pci, &cs5535au)) < 0)
                 goto probefail_out;
 
+        card->private_data = cs5535au;
+
         if ((err = snd_cs5535audio_mixer(cs5535au)) < 0)
                 goto probefail_out;
 
@@ -383,6 +408,10 @@ static struct pci_driver driver = {
         .id_table = snd_cs5535audio_ids,
         .probe = snd_cs5535audio_probe,
         .remove = __devexit_p(snd_cs5535audio_remove),
+#ifdef CONFIG_PM
+        .suspend = snd_cs5535audio_suspend,
+        .resume = snd_cs5535audio_resume,
+#endif
 };
 
 static int __init alsa_card_cs5535audio_init(void)
diff --git a/sound/pci/cs5535audio/cs5535audio.h b/sound/pci/cs5535audio/cs5535audio.h
index 5e55a1a1ed65..4fd1f31a6cf9 100644
--- a/sound/pci/cs5535audio/cs5535audio.h
+++ b/sound/pci/cs5535audio/cs5535audio.h
@@ -74,6 +74,8 @@
 #define PRM_RDY_STS                     0x00800000
 #define ACC_CODEC_CNTL_WR_CMD           (~0x80000000)
 #define ACC_CODEC_CNTL_RD_CMD           0x80000000
+#define ACC_CODEC_CNTL_LNK_SHUTDOWN     0x00040000
+#define ACC_CODEC_CNTL_LNK_WRM_RST      0x00020000
 #define PRD_JMP                         0x2000
 #define PRD_EOP                         0x4000
 #define PRD_EOT                         0x8000
@@ -88,6 +90,7 @@ struct cs5535audio_dma_ops {
         void (*disable_dma)(struct cs5535audio *cs5535au);
         void (*pause_dma)(struct cs5535audio *cs5535au);
         void (*setup_prd)(struct cs5535audio *cs5535au, u32 prd_addr);
+        u32 (*read_prd)(struct cs5535audio *cs5535au);
         u32 (*read_dma_pntr)(struct cs5535audio *cs5535au);
 };
 
@@ -103,11 +106,14 @@ struct cs5535audio_dma {
         struct snd_pcm_substream *substream;
         unsigned int buf_addr, buf_bytes;
         unsigned int period_bytes, periods;
+        int suspended;
+        u32 saved_prd;
 };
 
 struct cs5535audio {
         struct snd_card *card;
         struct snd_ac97 *ac97;
+        struct snd_pcm *pcm;
         int irq;
         struct pci_dev *pci;
         unsigned long port;
@@ -117,6 +123,8 @@ struct cs5535audio {
         struct cs5535audio_dma dmas[NUM_CS5535AUDIO_DMAS];
 };
 
+int snd_cs5535audio_suspend(struct pci_dev *pci, pm_message_t state);
+int snd_cs5535audio_resume(struct pci_dev *pci);
 int __devinit snd_cs5535audio_pcm(struct cs5535audio *cs5535audio);
 
 #endif /* __SOUND_CS5535AUDIO_H */
diff --git a/sound/pci/cs5535audio/cs5535audio_pcm.c b/sound/pci/cs5535audio/cs5535audio_pcm.c
index 60bb82b2ff47..f0a48693d687 100644
--- a/sound/pci/cs5535audio/cs5535audio_pcm.c
+++ b/sound/pci/cs5535audio/cs5535audio_pcm.c
@@ -43,7 +43,8 @@ static struct snd_pcm_hardware snd_cs5535audio_playback =
                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
                                 SNDRV_PCM_INFO_MMAP_VALID |
                                 SNDRV_PCM_INFO_PAUSE |
-                                SNDRV_PCM_INFO_SYNC_START
+                                SNDRV_PCM_INFO_SYNC_START |
+                                SNDRV_PCM_INFO_RESUME
                                 ),
         .formats =              (
                                 SNDRV_PCM_FMTBIT_S16_LE
@@ -193,6 +194,11 @@ static void cs5535audio_playback_setup_prd(struct cs5535audio *cs5535au,
         cs_writel(cs5535au, ACC_BM0_PRD, prd_addr);
 }
 
+static u32 cs5535audio_playback_read_prd(struct cs5535audio *cs5535au)
+{
+        return cs_readl(cs5535au, ACC_BM0_PRD);
+}
+
 static u32 cs5535audio_playback_read_dma_pntr(struct cs5535audio *cs5535au)
 {
         return cs_readl(cs5535au, ACC_BM0_PNTR);
@@ -219,6 +225,11 @@ static void cs5535audio_capture_setup_prd(struct cs5535audio *cs5535au,
         cs_writel(cs5535au, ACC_BM1_PRD, prd_addr);
 }
 
+static u32 cs5535audio_capture_read_prd(struct cs5535audio *cs5535au)
+{
+        return cs_readl(cs5535au, ACC_BM1_PRD);
+}
+
 static u32 cs5535audio_capture_read_dma_pntr(struct cs5535audio *cs5535au)
 {
         return cs_readl(cs5535au, ACC_BM1_PNTR);
@@ -285,9 +296,17 @@ static int snd_cs5535audio_trigger(struct snd_pcm_substream *substream, int cmd)
         case SNDRV_PCM_TRIGGER_START:
                 dma->ops->enable_dma(cs5535au);
                 break;
+        case SNDRV_PCM_TRIGGER_RESUME:
+                dma->ops->enable_dma(cs5535au);
+                dma->suspended = 0;
+                break;
         case SNDRV_PCM_TRIGGER_STOP:
                 dma->ops->disable_dma(cs5535au);
                 break;
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                dma->ops->disable_dma(cs5535au);
+                dma->suspended = 1;
+                break;
         default:
                 snd_printk(KERN_ERR "unhandled trigger\n");
                 err = -EINVAL;
@@ -375,6 +394,7 @@ static struct cs5535audio_dma_ops snd_cs5535audio_playback_dma_ops = {
         .enable_dma = cs5535audio_playback_enable_dma,
         .disable_dma = cs5535audio_playback_disable_dma,
         .setup_prd = cs5535audio_playback_setup_prd,
+        .read_prd = cs5535audio_playback_read_prd,
         .pause_dma = cs5535audio_playback_pause_dma,
         .read_dma_pntr = cs5535audio_playback_read_dma_pntr,
 };
@@ -384,6 +404,7 @@ static struct cs5535audio_dma_ops snd_cs5535audio_capture_dma_ops = {
         .enable_dma = cs5535audio_capture_enable_dma,
         .disable_dma = cs5535audio_capture_disable_dma,
         .setup_prd = cs5535audio_capture_setup_prd,
+        .read_prd = cs5535audio_capture_read_prd,
         .pause_dma = cs5535audio_capture_pause_dma,
         .read_dma_pntr = cs5535audio_capture_read_dma_pntr,
 };
@@ -413,6 +434,7 @@ int __devinit snd_cs5535audio_pcm(struct cs5535audio *cs5535au)
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                         snd_dma_pci_data(cs5535au->pci),
                                         64*1024, 128*1024);
+        cs5535au->pcm = pcm;
 
         return 0;
 }
diff --git a/sound/pci/cs5535audio/cs5535audio_pm.c b/sound/pci/cs5535audio/cs5535audio_pm.c
new file mode 100644
index 000000000000..aad0e69db9c1
--- /dev/null
+++ b/sound/pci/cs5535audio/cs5535audio_pm.c
@@ -0,0 +1,123 @@
+/*
+ * Power management for audio on multifunction CS5535 companion device
+ * Copyright (C) Jaya Kumar
+ *
+ * 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/slab.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <sound/driver.h>
+#include <sound/core.h>
+#include <sound/control.h>
+#include <sound/initval.h>
+#include <sound/asoundef.h>
+#include <sound/pcm.h>
+#include <sound/ac97_codec.h>
+#include "cs5535audio.h"
+
+static void snd_cs5535audio_stop_hardware(struct cs5535audio *cs5535au)
+{
+        /* 
+        we depend on snd_ac97_suspend to tell the
+        AC97 codec to shutdown. the amd spec suggests
+        that the LNK_SHUTDOWN be done at the same time
+        that the codec power-down is issued. instead,
+        we do it just after rather than at the same 
+        time. excluding codec specific build_ops->suspend
+        ac97 powerdown hits:
+        0x8000 EAPD 
+        0x4000 Headphone amplifier 
+        0x0300 ADC & DAC 
+        0x0400 Analog Mixer powerdown (Vref on) 
+        I am not sure if this is the best that we can do.
+        The remainder to be investigated are:
+        - analog mixer (vref off) 0x0800
+        - AC-link powerdown 0x1000
+        - codec internal clock 0x2000
+        */
+
+        /* set LNK_SHUTDOWN to shutdown AC link */
+        cs_writel(cs5535au, ACC_CODEC_CNTL, ACC_CODEC_CNTL_LNK_SHUTDOWN);
+
+}
+
+int snd_cs5535audio_suspend(struct pci_dev *pci, pm_message_t state)
+{
+        struct snd_card *card = pci_get_drvdata(pci);
+        struct cs5535audio *cs5535au = card->private_data;
+        int i;
+
+        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
+        for (i = 0; i < NUM_CS5535AUDIO_DMAS; i++) {
+                struct cs5535audio_dma *dma = &cs5535au->dmas[i];
+                if (dma && dma->substream && !dma->suspended) 
+                        dma->saved_prd = dma->ops->read_prd(cs5535au);
+        }
+        snd_pcm_suspend_all(cs5535au->pcm);
+        snd_ac97_suspend(cs5535au->ac97);
+        /* save important regs, then disable aclink in hw */
+        snd_cs5535audio_stop_hardware(cs5535au);
+        pci_disable_device(pci);
+        pci_save_state(pci);
+
+        return 0;
+}
+
+int snd_cs5535audio_resume(struct pci_dev *pci)
+{
+        struct snd_card *card = pci_get_drvdata(pci);
+        struct cs5535audio *cs5535au = card->private_data;
+        u32 tmp;
+        int timeout;
+        int i;
+
+        pci_restore_state(pci);
+        pci_enable_device(pci);
+        pci_set_master(pci);
+
+        /* set LNK_WRM_RST to reset AC link */
+        cs_writel(cs5535au, ACC_CODEC_CNTL, ACC_CODEC_CNTL_LNK_WRM_RST);
+
+        timeout = 50;
+        do {
+                tmp = cs_readl(cs5535au, ACC_CODEC_STATUS);
+                if (tmp & PRM_RDY_STS)
+                        break;
+                udelay(1);
+        } while (--timeout);
+
+        if (!timeout)
+                snd_printk(KERN_ERR "Failure getting AC Link ready\n");
+
+        /* we depend on ac97 to perform the codec power up */
+        snd_ac97_resume(cs5535au->ac97);
+        /* set up rate regs, dma. actual initiation is done in trig */
+        for (i = 0; i < NUM_CS5535AUDIO_DMAS; i++) {
+                struct cs5535audio_dma *dma = &cs5535au->dmas[i];
+                if (dma && dma->substream && dma->suspended) {
+                        dma->substream->ops->prepare(dma->substream);
+                        dma->ops->setup_prd(cs5535au, dma->saved_prd);
+                }
+        }
+                
+        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
+
+        return 0;
+}
+
diff --git a/sound/pci/emu10k1/emu10k1.c b/sound/pci/emu10k1/emu10k1.c
index 42b11ba1d210..549673ea14a9 100644
--- a/sound/pci/emu10k1/emu10k1.c
+++ b/sound/pci/emu10k1/emu10k1.c
@@ -46,13 +46,13 @@ MODULE_SUPPORTED_DEVICE("{{Creative Labs,SB Live!/PCI512/E-mu APS},"
 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_PNP;      /* Enable this card */
-static int extin[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0};
-static int extout[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0};
+static int extin[SNDRV_CARDS];
+static int extout[SNDRV_CARDS];
 static int seq_ports[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 4};
 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] = {[0 ... (SNDRV_CARDS - 1)] = 0};
-static uint subsystem[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0}; /* Force card subsystem model */
+static int enable_ir[SNDRV_CARDS];
+static uint subsystem[SNDRV_CARDS]; /* Force card subsystem model */
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for the EMU10K1 soundcard.");
diff --git a/sound/pci/emu10k1/emu10k1_main.c b/sound/pci/emu10k1/emu10k1_main.c
index 6bfa08436efa..42a358f989c3 100644
--- a/sound/pci/emu10k1/emu10k1_main.c
+++ b/sound/pci/emu10k1/emu10k1_main.c
@@ -777,14 +777,6 @@ static int snd_emu10k1_dev_free(struct snd_device *device)
 
 static struct snd_emu_chip_details emu_chip_details[] = {
         /* Audigy 2 Value AC3 out does not work yet. Need to find out how to turn off interpolators.*/
-        /* Audigy4 SB0400 */
-        {.vendor = 0x1102, .device = 0x0008, .subsystem = 0x10211102,
-         .driver = "Audigy2", .name = "Audigy 4 [SB0400]", 
-         .id = "Audigy2",
-         .emu10k2_chip = 1,
-         .ca0108_chip = 1,
-         .spk71 = 1,
-         .ac97_chip = 1} ,
         /* Tested by James@superbug.co.uk 3rd July 2005 */
         /* DSP: CA0108-IAT
          * DAC: CS4382-KQ
@@ -799,13 +791,59 @@ static struct snd_emu_chip_details emu_chip_details[] = {
          .ca0108_chip = 1,
          .spk71 = 1,
          .ac97_chip = 1} ,
+        /* Audigy4 (Not PRO) SB0610 */
+        /* Tested by James@superbug.co.uk 4th April 2006 */
+        /* A_IOCFG bits
+         * Output
+         * 0: ?
+         * 1: ?
+         * 2: ?
+         * 3: 0 - Digital Out, 1 - Line in
+         * 4: ?
+         * 5: ?
+         * 6: ?
+         * 7: ?
+         * Input
+         * 8: ?
+         * 9: ?
+         * A: Green jack sense (Front)
+         * B: ?
+         * C: Black jack sense (Rear/Side Right)
+         * D: Yellow jack sense (Center/LFE/Side Left)
+         * E: ?
+         * F: ?
+         *
+         * Digital Out/Line in switch using A_IOCFG bit 3 (0x08)
+         * 0 - Digital Out
+         * 1 - Line in
+         */
+        /* Mic input not tested.
+         * Analog CD input not tested
+         * Digital Out not tested.
+         * Line in working.
+         * Audio output 5.1 working. Side outputs not working.
+         */
+        /* DSP: CA10300-IAT LF
+         * DAC: Cirrus Logic CS4382-KQZ
+         * ADC: Philips 1361T
+         * AC97: Sigmatel STAC9750
+         * CA0151: None
+         */
+        {.vendor = 0x1102, .device = 0x0008, .subsystem = 0x10211102,
+         .driver = "Audigy2", .name = "Audigy 4 [SB0610]", 
+         .id = "Audigy2",
+         .emu10k2_chip = 1,
+         .ca0108_chip = 1,
+         .spk71 = 1,
+         .adc_1361t = 1,  /* 24 bit capture instead of 16bit */
+         .ac97_chip = 1} ,
         /* Audigy 2 ZS Notebook Cardbus card.*/
         /* Tested by James@superbug.co.uk 22th December 2005 */
         /* Audio output 7.1/Headphones working.
          * Digital output working. (AC3 not checked, only PCM)
          * Audio inputs not tested.
          */ 
-        /* DSP: Tiny2
+        /* DSP: Tina2
          * DAC: Wolfson WM8768/WM8568
          * ADC: Wolfson WM8775
          * AC97: None
@@ -1421,16 +1459,3 @@ void snd_emu10k1_resume_regs(struct snd_emu10k1 *emu)
         }
 }
 #endif
-
-/* memory.c */
-EXPORT_SYMBOL(snd_emu10k1_synth_alloc);
-EXPORT_SYMBOL(snd_emu10k1_synth_free);
-EXPORT_SYMBOL(snd_emu10k1_synth_bzero);
-EXPORT_SYMBOL(snd_emu10k1_synth_copy_from_user);
-EXPORT_SYMBOL(snd_emu10k1_memblk_map);
-/* voice.c */
-EXPORT_SYMBOL(snd_emu10k1_voice_alloc);
-EXPORT_SYMBOL(snd_emu10k1_voice_free);
-/* io.c */
-EXPORT_SYMBOL(snd_emu10k1_ptr_read);
-EXPORT_SYMBOL(snd_emu10k1_ptr_write);
diff --git a/sound/pci/emu10k1/emu10k1x.c b/sound/pci/emu10k1/emu10k1x.c
index d51290c18167..0fb27e4be07b 100644
--- a/sound/pci/emu10k1/emu10k1x.c
+++ b/sound/pci/emu10k1/emu10k1x.c
@@ -1055,8 +1055,7 @@ static int __devinit snd_emu10k1x_proc_init(struct emu10k1x * emu)
         struct snd_info_entry *entry;
         
         if(! snd_card_proc_new(emu->card, "emu10k1x_regs", &entry)) {
-                snd_info_set_text_ops(entry, emu, 1024, snd_emu10k1x_proc_reg_read);
-                entry->c.text.write_size = 64;
+                snd_info_set_text_ops(entry, emu, snd_emu10k1x_proc_reg_read);
                 entry->c.text.write = snd_emu10k1x_proc_reg_write;
                 entry->mode |= S_IWUSR;
                 entry->private_data = emu;
diff --git a/sound/pci/emu10k1/emumixer.c b/sound/pci/emu10k1/emumixer.c
index 2a9d12d10680..c31f3d0877fa 100644
--- a/sound/pci/emu10k1/emumixer.c
+++ b/sound/pci/emu10k1/emumixer.c
@@ -777,6 +777,8 @@ int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu,
         };
         static char *audigy_remove_ctls[] = {
                 /* Master/PCM controls on ac97 of Audigy has no effect */
+                /* On the Audigy2 the AC97 playback is piped into
+                 * the Philips ADC for 24bit capture */
                 "PCM Playback Switch",
                 "PCM Playback Volume",
                 "Master Mono Playback Switch",
@@ -804,6 +806,47 @@ int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu,
                 "AMic Playback Volume", "Mic Playback Volume",
                 NULL
         };
+        static char *audigy_remove_ctls_1361t_adc[] = {
+                /* On the Audigy2 the AC97 playback is piped into
+                 * the Philips ADC for 24bit capture */
+                "PCM Playback Switch",
+                "PCM Playback Volume",
+                "Master Mono Playback Switch",
+                "Master Mono Playback Volume",
+                "Capture Source",
+                "Capture Switch",
+                "Capture Volume",
+                "Mic Capture Volume",
+                "Headphone Playback Switch",
+                "Headphone Playback Volume",
+                "3D Control - Center",
+                "3D Control - Depth",
+                "3D Control - Switch",
+                "Line2 Playback Volume",
+                "Line2 Capture Volume",
+                NULL
+        };
+        static char *audigy_rename_ctls_1361t_adc[] = {
+                "Master Playback Switch", "Master Capture Switch",
+                "Master Playback Volume", "Master Capture Volume",
+                "Wave Master Playback Volume", "Master Playback Volume",
+                "PC Speaker Playback Switch", "PC Speaker Capture Switch",
+                "PC Speaker Playback Volume", "PC Speaker Capture Volume",
+                "Phone Playback Switch", "Phone Capture Switch",
+                "Phone Playback Volume", "Phone Capture Volume",
+                "Mic Playback Switch", "Mic Capture Switch",
+                "Mic Playback Volume", "Mic Capture Volume",
+                "Line Playback Switch", "Line Capture Switch",
+                "Line Playback Volume", "Line Capture Volume",
+                "CD Playback Switch", "CD Capture Switch",
+                "CD Playback Volume", "CD Capture Volume",
+                "Aux Playback Switch", "Aux Capture Switch",
+                "Aux Playback Volume", "Aux Capture Volume",
+                "Video Playback Switch", "Video Capture Switch",
+                "Video Playback Volume", "Video Capture Volume",
+
+                NULL
+        };
 
         if (emu->card_capabilities->ac97_chip) {
                 struct snd_ac97_bus *pbus;
@@ -834,7 +877,10 @@ int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu,
                         snd_ac97_write_cache(emu->ac97, AC97_MASTER, 0x0000);
                         /* set capture source to mic */
                         snd_ac97_write_cache(emu->ac97, AC97_REC_SEL, 0x0000);
-                        c = audigy_remove_ctls;
+                        if (emu->card_capabilities->adc_1361t)
+                                c = audigy_remove_ctls_1361t_adc;
+                        else 
+                                c = audigy_remove_ctls;
                 } else {
                         /*
                          * Credits for cards based on STAC9758:
@@ -863,11 +909,15 @@ int __devinit snd_emu10k1_mixer(struct snd_emu10k1 *emu,
         }
 
         if (emu->audigy)
-                c = audigy_rename_ctls;
+                if (emu->card_capabilities->adc_1361t)
+                        c = audigy_rename_ctls_1361t_adc;
+                else
+                        c = audigy_rename_ctls;
         else
                 c = emu10k1_rename_ctls;
         for (; *c; c += 2)
                 rename_ctl(card, c[0], c[1]);
+
         if (emu->card_capabilities->subsystem == 0x20071102) {  /* Audigy 4 Pro */
                 rename_ctl(card, "Line2 Capture Volume", "Line1/Mic Capture Volume");
                 rename_ctl(card, "Analog Mix Capture Volume", "Line2 Capture Volume");
diff --git a/sound/pci/emu10k1/emuproc.c b/sound/pci/emu10k1/emuproc.c
index 90f1c52703a1..b939e03aaedf 100644
--- a/sound/pci/emu10k1/emuproc.c
+++ b/sound/pci/emu10k1/emuproc.c
@@ -532,57 +532,51 @@ int __devinit snd_emu10k1_proc_init(struct snd_emu10k1 * emu)
         struct snd_info_entry *entry;
 #ifdef CONFIG_SND_DEBUG
         if (! snd_card_proc_new(emu->card, "io_regs", &entry)) {
-                snd_info_set_text_ops(entry, emu, 1024, snd_emu_proc_io_reg_read);
-                entry->c.text.write_size = 64;
+                snd_info_set_text_ops(entry, emu, snd_emu_proc_io_reg_read);
                 entry->c.text.write = snd_emu_proc_io_reg_write;
                 entry->mode |= S_IWUSR;
         }
         if (! snd_card_proc_new(emu->card, "ptr_regs00a", &entry)) {
-                snd_info_set_text_ops(entry, emu, 65536, snd_emu_proc_ptr_reg_read00a);
-                entry->c.text.write_size = 64;
+                snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read00a);
                 entry->c.text.write = snd_emu_proc_ptr_reg_write00;
                 entry->mode |= S_IWUSR;
         }
         if (! snd_card_proc_new(emu->card, "ptr_regs00b", &entry)) {
-                snd_info_set_text_ops(entry, emu, 65536, snd_emu_proc_ptr_reg_read00b);
-                entry->c.text.write_size = 64;
+                snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read00b);
                 entry->c.text.write = snd_emu_proc_ptr_reg_write00;
                 entry->mode |= S_IWUSR;
         }
         if (! snd_card_proc_new(emu->card, "ptr_regs20a", &entry)) {
-                snd_info_set_text_ops(entry, emu, 65536, snd_emu_proc_ptr_reg_read20a);
-                entry->c.text.write_size = 64;
+                snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read20a);
                 entry->c.text.write = snd_emu_proc_ptr_reg_write20;
                 entry->mode |= S_IWUSR;
         }
         if (! snd_card_proc_new(emu->card, "ptr_regs20b", &entry)) {
-                snd_info_set_text_ops(entry, emu, 65536, snd_emu_proc_ptr_reg_read20b);
-                entry->c.text.write_size = 64;
+                snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read20b);
                 entry->c.text.write = snd_emu_proc_ptr_reg_write20;
                 entry->mode |= S_IWUSR;
         }
         if (! snd_card_proc_new(emu->card, "ptr_regs20c", &entry)) {
-                snd_info_set_text_ops(entry, emu, 65536, snd_emu_proc_ptr_reg_read20c);
-                entry->c.text.write_size = 64;
+                snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read20c);
                 entry->c.text.write = snd_emu_proc_ptr_reg_write20;
                 entry->mode |= S_IWUSR;
         }
 #endif
         
         if (! snd_card_proc_new(emu->card, "emu10k1", &entry))
-                snd_info_set_text_ops(entry, emu, 2048, snd_emu10k1_proc_read);
+                snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_read);
 
         if (emu->card_capabilities->emu10k2_chip) {
                 if (! snd_card_proc_new(emu->card, "spdif-in", &entry))
-                        snd_info_set_text_ops(entry, emu, 2048, snd_emu10k1_proc_spdif_read);
+                        snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_spdif_read);
         }
         if (emu->card_capabilities->ca0151_chip) {
                 if (! snd_card_proc_new(emu->card, "capture-rates", &entry))
-                        snd_info_set_text_ops(entry, emu, 2048, snd_emu10k1_proc_rates_read);
+                        snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_rates_read);
         }
 
         if (! snd_card_proc_new(emu->card, "voices", &entry))
-                snd_info_set_text_ops(entry, emu, 2048, snd_emu10k1_proc_voices_read);
+                snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_voices_read);
 
         if (! snd_card_proc_new(emu->card, "fx8010_gpr", &entry)) {
                 entry->content = SNDRV_INFO_CONTENT_DATA;
@@ -616,7 +610,6 @@ int __devinit snd_emu10k1_proc_init(struct snd_emu10k1 * emu)
                 entry->content = SNDRV_INFO_CONTENT_TEXT;
                 entry->private_data = emu;
                 entry->mode = S_IFREG | S_IRUGO /*| S_IWUSR*/;
-                entry->c.text.read_size = 128*1024;
                 entry->c.text.read = snd_emu10k1_proc_acode_read;
         }
         return 0;
diff --git a/sound/pci/emu10k1/io.c b/sound/pci/emu10k1/io.c
index ef5304df8c11..029e7856c43b 100644
--- a/sound/pci/emu10k1/io.c
+++ b/sound/pci/emu10k1/io.c
@@ -62,6 +62,8 @@ unsigned int snd_emu10k1_ptr_read(struct snd_emu10k1 * emu, unsigned int reg, un
         }
 }
 
+EXPORT_SYMBOL(snd_emu10k1_ptr_read);
+
 void snd_emu10k1_ptr_write(struct snd_emu10k1 *emu, unsigned int reg, unsigned int chn, unsigned int data)
 {
         unsigned int regptr;
@@ -92,6 +94,8 @@ void snd_emu10k1_ptr_write(struct snd_emu10k1 *emu, unsigned int reg, unsigned i
         }
 }
 
+EXPORT_SYMBOL(snd_emu10k1_ptr_write);
+
 unsigned int snd_emu10k1_ptr20_read(struct snd_emu10k1 * emu, 
                                           unsigned int reg, 
                                           unsigned int chn)
diff --git a/sound/pci/emu10k1/memory.c b/sound/pci/emu10k1/memory.c
index e7ec98649f04..4fcaefe5a3c5 100644
--- a/sound/pci/emu10k1/memory.c
+++ b/sound/pci/emu10k1/memory.c
@@ -287,6 +287,8 @@ int snd_emu10k1_memblk_map(struct snd_emu10k1 *emu, struct snd_emu10k1_memblk *b
         return err;
 }
 
+EXPORT_SYMBOL(snd_emu10k1_memblk_map);
+
 /*
  * page allocation for DMA
  */
@@ -387,6 +389,7 @@ snd_emu10k1_synth_alloc(struct snd_emu10k1 *hw, unsigned int size)
         return (struct snd_util_memblk *)blk;
 }
 
+EXPORT_SYMBOL(snd_emu10k1_synth_alloc);
 
 /*
  * free a synth sample area
@@ -409,6 +412,7 @@ snd_emu10k1_synth_free(struct snd_emu10k1 *emu, struct snd_util_memblk *memblk)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_emu10k1_synth_free);
 
 /* check new allocation range */
 static void get_single_page_range(struct snd_util_memhdr *hdr,
@@ -540,6 +544,8 @@ int snd_emu10k1_synth_bzero(struct snd_emu10k1 *emu, struct snd_util_memblk *blk
         return 0;
 }
 
+EXPORT_SYMBOL(snd_emu10k1_synth_bzero);
+
 /*
  * copy_from_user(blk + offset, data, size)
  */
@@ -568,3 +574,5 @@ int snd_emu10k1_synth_copy_from_user(struct snd_emu10k1 *emu, struct snd_util_me
         } while (offset < end_offset);
         return 0;
 }
+
+EXPORT_SYMBOL(snd_emu10k1_synth_copy_from_user);
diff --git a/sound/pci/emu10k1/p17v.h b/sound/pci/emu10k1/p17v.h
new file mode 100644
index 000000000000..7ddb5be632cf
--- /dev/null
+++ b/sound/pci/emu10k1/p17v.h
@@ -0,0 +1,111 @@
+/*
+ *  Copyright (c) by James Courtier-Dutton <James@superbug.demon.co.uk>
+ *  Driver p17v chips
+ *  Version: 0.01
+ *
+ *   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
+ *
+ */
+
+/******************************************************************************/
+/* Audigy2Value Tina (P17V) pointer-offset register set,
+ * accessed through the PTR20 and DATA24 registers  */
+/******************************************************************************/
+
+/* 00 - 07: Not used */
+#define P17V_PLAYBACK_FIFO_PTR  0x08    /* Current playback fifo pointer
+                                         * and number of sound samples in cache.
+                                         */  
+/* 09 - 12: Not used */
+#define P17V_CAPTURE_FIFO_PTR   0x13    /* Current capture fifo pointer
+                                         * and number of sound samples in cache.
+                                         */  
+/* 14 - 17: Not used */
+#define P17V_PB_CHN_SEL         0x18    /* P17v playback channel select */
+#define P17V_SE_SLOT_SEL_L      0x19    /* Sound Engine slot select low */
+#define P17V_SE_SLOT_SEL_H      0x1a    /* Sound Engine slot select high */
+/* 1b - 1f: Not used */
+/* 20 - 2f: Not used */
+/* 30 - 3b: Not used */
+#define P17V_SPI                0x3c    /* SPI interface register */
+#define P17V_I2C_ADDR           0x3d    /* I2C Address */
+#define P17V_I2C_0              0x3e    /* I2C Data */
+#define P17V_I2C_1              0x3f    /* I2C Data */
+
+#define P17V_START_AUDIO        0x40    /* Start Audio bit */
+/* 41 - 47: Reserved */
+#define P17V_START_CAPTURE      0x48    /* Start Capture bit */
+#define P17V_CAPTURE_FIFO_BASE  0x49    /* Record FIFO base address */
+#define P17V_CAPTURE_FIFO_SIZE  0x4a    /* Record FIFO buffer size */
+#define P17V_CAPTURE_FIFO_INDEX 0x4b    /* Record FIFO capture index */
+#define P17V_CAPTURE_VOL_H      0x4c    /* P17v capture volume control */
+#define P17V_CAPTURE_VOL_L      0x4d    /* P17v capture volume control */
+/* 4e - 4f: Not used */
+/* 50 - 5f: Not used */
+#define P17V_SRCSel             0x60    /* SRC48 and SRCMulti sample rate select
+                                         * and output select
+                                         */
+#define P17V_MIXER_AC97_10K1_VOL_L      0x61    /* 10K to Mixer_AC97 input volume control */
+#define P17V_MIXER_AC97_10K1_VOL_H      0x62    /* 10K to Mixer_AC97 input volume control */
+#define P17V_MIXER_AC97_P17V_VOL_L      0x63    /* P17V to Mixer_AC97 input volume control */
+#define P17V_MIXER_AC97_P17V_VOL_H      0x64    /* P17V to Mixer_AC97 input volume control */
+#define P17V_MIXER_AC97_SRP_REC_VOL_L   0x65    /* SRP Record to Mixer_AC97 input volume control */
+#define P17V_MIXER_AC97_SRP_REC_VOL_H   0x66    /* SRP Record to Mixer_AC97 input volume control */
+/* 67 - 68: Reserved */
+#define P17V_MIXER_Spdif_10K1_VOL_L     0x69    /* 10K to Mixer_Spdif input volume control */
+#define P17V_MIXER_Spdif_10K1_VOL_H     0x6A    /* 10K to Mixer_Spdif input volume control */
+#define P17V_MIXER_Spdif_P17V_VOL_L     0x6B    /* P17V to Mixer_Spdif input volume control */
+#define P17V_MIXER_Spdif_P17V_VOL_H     0x6C    /* P17V to Mixer_Spdif input volume control */
+#define P17V_MIXER_Spdif_SRP_REC_VOL_L  0x6D    /* SRP Record to Mixer_Spdif input volume control */
+#define P17V_MIXER_Spdif_SRP_REC_VOL_H  0x6E    /* SRP Record to Mixer_Spdif input volume control */
+/* 6f - 70: Reserved */
+#define P17V_MIXER_I2S_10K1_VOL_L       0x71    /* 10K to Mixer_I2S input volume control */
+#define P17V_MIXER_I2S_10K1_VOL_H       0x72    /* 10K to Mixer_I2S input volume control */
+#define P17V_MIXER_I2S_P17V_VOL_L       0x73    /* P17V to Mixer_I2S input volume control */
+#define P17V_MIXER_I2S_P17V_VOL_H       0x74    /* P17V to Mixer_I2S input volume control */
+#define P17V_MIXER_I2S_SRP_REC_VOL_L    0x75    /* SRP Record to Mixer_I2S input volume control */
+#define P17V_MIXER_I2S_SRP_REC_VOL_H    0x76    /* SRP Record to Mixer_I2S input volume control */
+/* 77 - 78: Reserved */
+#define P17V_MIXER_AC97_ENABLE          0x79    /* Mixer AC97 input audio enable */
+#define P17V_MIXER_SPDIF_ENABLE         0x7A    /* Mixer SPDIF input audio enable */
+#define P17V_MIXER_I2S_ENABLE           0x7B    /* Mixer I2S input audio enable */
+#define P17V_AUDIO_OUT_ENABLE           0x7C    /* Audio out enable */
+#define P17V_MIXER_ATT                  0x7D    /* SRP Mixer Attenuation Select */
+#define P17V_SRP_RECORD_SRR             0x7E    /* SRP Record channel source Select */
+#define P17V_SOFT_RESET_SRP_MIXER       0x7F    /* SRP and mixer soft reset */
+
+#define P17V_AC97_OUT_MASTER_VOL_L      0x80    /* AC97 Output master volume control */
+#define P17V_AC97_OUT_MASTER_VOL_H      0x81    /* AC97 Output master volume control */
+#define P17V_SPDIF_OUT_MASTER_VOL_L     0x82    /* SPDIF Output master volume control */
+#define P17V_SPDIF_OUT_MASTER_VOL_H     0x83    /* SPDIF Output master volume control */
+#define P17V_I2S_OUT_MASTER_VOL_L       0x84    /* I2S Output master volume control */
+#define P17V_I2S_OUT_MASTER_VOL_H       0x85    /* I2S Output master volume control */
+/* 86 - 87: Not used */
+#define P17V_I2S_CHANNEL_SWAP_PHASE_INVERSE     0x88    /* I2S out mono channel swap
+                                                         * and phase inverse */
+#define P17V_SPDIF_CHANNEL_SWAP_PHASE_INVERSE   0x89    /* SPDIF out mono channel swap
+                                                         * and phase inverse */
+/* 8A: Not used */
+#define P17V_SRP_P17V_ESR               0x8B    /* SRP_P17V estimated sample rate and rate lock */
+#define P17V_SRP_REC_ESR                0x8C    /* SRP_REC estimated sample rate and rate lock */
+#define P17V_SRP_BYPASS                 0x8D    /* srps channel bypass and srps bypass */
+/* 8E - 92: Not used */
+#define P17V_I2S_SRC_SEL                0x93    /* I2SIN mode sel */
+
+
+
+
+
+
diff --git a/sound/pci/emu10k1/tina2.h b/sound/pci/emu10k1/tina2.h
index 5c43abf03e89..f2d8eb6c89e1 100644
--- a/sound/pci/emu10k1/tina2.h
+++ b/sound/pci/emu10k1/tina2.h
@@ -1,11 +1,7 @@
 /*
  *  Copyright (c) by James Courtier-Dutton <James@superbug.demon.co.uk>
- *  Driver p16v chips
- *  Version: 0.21
- *
- *
- *  This code was initally based on code from ALSA's emu10k1x.c which is:
- *  Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
+ *  Driver tina2 chips
+ *  Version: 0.1
  *
  *   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
diff --git a/sound/pci/emu10k1/voice.c b/sound/pci/emu10k1/voice.c
index 56ffb7dc3ee2..94eca82dd4fc 100644
--- a/sound/pci/emu10k1/voice.c
+++ b/sound/pci/emu10k1/voice.c
@@ -139,6 +139,8 @@ int snd_emu10k1_voice_alloc(struct snd_emu10k1 *emu, int type, int number,
         return result;
 }
 
+EXPORT_SYMBOL(snd_emu10k1_voice_alloc);
+
 int snd_emu10k1_voice_free(struct snd_emu10k1 *emu,
                            struct snd_emu10k1_voice *pvoice)
 {
@@ -153,3 +155,5 @@ int snd_emu10k1_voice_free(struct snd_emu10k1 *emu,
         spin_unlock_irqrestore(&emu->voice_lock, flags);
         return 0;
 }
+
+EXPORT_SYMBOL(snd_emu10k1_voice_free);
diff --git a/sound/pci/ens1370.c b/sound/pci/ens1370.c
index ca9e34e88f62..9d46bbee2a40 100644
--- a/sound/pci/ens1370.c
+++ b/sound/pci/ens1370.c
@@ -1915,7 +1915,7 @@ static void __devinit snd_ensoniq_proc_init(struct ensoniq * ensoniq)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(ensoniq->card, "audiopci", &entry))
-                snd_info_set_text_ops(entry, ensoniq, 1024, snd_ensoniq_proc_read);
+                snd_info_set_text_ops(entry, ensoniq, snd_ensoniq_proc_read);
 }
 
 /*
diff --git a/sound/pci/es1938.c b/sound/pci/es1938.c
index 6f9094ca4fb4..ca6603fe0b11 100644
--- a/sound/pci/es1938.c
+++ b/sound/pci/es1938.c
@@ -1756,7 +1756,8 @@ static int __devinit snd_es1938_probe(struct pci_dev *pci,
                 }
         }
         if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
-                                chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) {
+                                chip->mpu_port, MPU401_INFO_INTEGRATED,
+                                chip->irq, 0, &chip->rmidi) < 0) {
                 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
         } else {
                 // this line is vital for MIDI interrupt handling on ess-solo1
diff --git a/sound/pci/es1968.c b/sound/pci/es1968.c
index 5ff4175c7b6d..bfa0876e715e 100644
--- a/sound/pci/es1968.c
+++ b/sound/pci/es1968.c
@@ -132,7 +132,7 @@ static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;	/* Enable this card *
 static int total_bufsize[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1024 };
 static int pcm_substreams_p[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 4 };
 static int pcm_substreams_c[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1 };
-static int clock[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0};
+static int clock[SNDRV_CARDS];
 static int use_pm[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
 static int enable_mpu[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2};
 #ifdef SUPPORT_JOYSTICK
@@ -2727,7 +2727,8 @@ static int __devinit snd_es1968_probe(struct pci_dev *pci,
         }
         if (enable_mpu[dev]) {
                 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
-                                               chip->io_port + ESM_MPU401_PORT, 1,
+                                               chip->io_port + ESM_MPU401_PORT,
+                                               MPU401_INFO_INTEGRATED,
                                                chip->irq, 0, &chip->rmidi)) < 0) {
                         printk(KERN_WARNING "es1968: skipping MPU-401 MIDI support..\n");
                 }
diff --git a/sound/pci/fm801.c b/sound/pci/fm801.c
index d72fc28c580e..0afa573dd244 100644
--- a/sound/pci/fm801.c
+++ b/sound/pci/fm801.c
@@ -56,7 +56,7 @@ static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;	/* Enable this card *
  *    3 = MediaForte 64-PCR
  *  High 16-bits are video (radio) device number + 1
  */
-static int tea575x_tuner[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0 };
+static int tea575x_tuner[SNDRV_CARDS];
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for the FM801 soundcard.");
@@ -1448,7 +1448,8 @@ static int __devinit snd_card_fm801_probe(struct pci_dev *pci,
                 return err;
         }
         if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_FM801,
-                                       FM801_REG(chip, MPU401_DATA), 1,
+                                       FM801_REG(chip, MPU401_DATA),
+                                       MPU401_INFO_INTEGRATED,
                                        chip->irq, 0, &chip->rmidi)) < 0) {
                 snd_card_free(card);
                 return err;
diff --git a/sound/pci/hda/Makefile b/sound/pci/hda/Makefile
index ddfb5ff7fb8f..dbacba6177db 100644
--- a/sound/pci/hda/Makefile
+++ b/sound/pci/hda/Makefile
@@ -1,5 +1,5 @@
 snd-hda-intel-objs := hda_intel.o
-snd-hda-codec-objs := hda_codec.o hda_generic.o patch_realtek.o patch_cmedia.o patch_analog.o patch_sigmatel.o patch_si3054.o
+snd-hda-codec-objs := hda_codec.o hda_generic.o patch_realtek.o patch_cmedia.o patch_analog.o patch_sigmatel.o patch_si3054.o patch_atihdmi.o
 ifdef CONFIG_PROC_FS
 snd-hda-codec-objs += hda_proc.o
 endif
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index 5bee3b536478..8c2a8174ece1 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -86,6 +86,8 @@ unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid, int dire
         return res;
 }
 
+EXPORT_SYMBOL(snd_hda_codec_read);
+
 /**
  * snd_hda_codec_write - send a single command without waiting for response
  * @codec: the HDA codec
@@ -108,6 +110,8 @@ int snd_hda_codec_write(struct hda_codec *codec, hda_nid_t nid, int direct,
         return err;
 }
 
+EXPORT_SYMBOL(snd_hda_codec_write);
+
 /**
  * snd_hda_sequence_write - sequence writes
  * @codec: the HDA codec
@@ -122,6 +126,8 @@ void snd_hda_sequence_write(struct hda_codec *codec, const struct hda_verb *seq)
                 snd_hda_codec_write(codec, seq->nid, 0, seq->verb, seq->param);
 }
 
+EXPORT_SYMBOL(snd_hda_sequence_write);
+
 /**
  * snd_hda_get_sub_nodes - get the range of sub nodes
  * @codec: the HDA codec
@@ -140,6 +146,8 @@ int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid, hda_nid_t *sta
         return (int)(parm & 0x7fff);
 }
 
+EXPORT_SYMBOL(snd_hda_get_sub_nodes);
+
 /**
  * snd_hda_get_connections - get connection list
  * @codec: the HDA codec
@@ -256,6 +264,8 @@ int snd_hda_queue_unsol_event(struct hda_bus *bus, u32 res, u32 res_ex)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_hda_queue_unsol_event);
+
 /*
  * process queueud unsolicited events
  */
@@ -384,6 +394,7 @@ int snd_hda_bus_new(struct snd_card *card, const struct hda_bus_template *temp,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_hda_bus_new);
 
 /*
  * find a matching codec preset
@@ -587,6 +598,8 @@ int snd_hda_codec_new(struct hda_bus *bus, unsigned int codec_addr,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_hda_codec_new);
+
 /**
  * snd_hda_codec_setup_stream - set up the codec for streaming
  * @codec: the CODEC to set up
@@ -609,6 +622,7 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid, u32 stre
         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, format);
 }
 
+EXPORT_SYMBOL(snd_hda_codec_setup_stream);
 
 /*
  * amp access functions
@@ -1294,6 +1308,7 @@ int snd_hda_build_controls(struct hda_bus *bus)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_hda_build_controls);
 
 /*
  * stream formats
@@ -1382,6 +1397,8 @@ unsigned int snd_hda_calc_stream_format(unsigned int rate,
         return val;
 }
 
+EXPORT_SYMBOL(snd_hda_calc_stream_format);
+
 /**
  * snd_hda_query_supported_pcm - query the supported PCM rates and formats
  * @codec: the HDA codec
@@ -1663,6 +1680,7 @@ int snd_hda_build_pcms(struct hda_bus *bus)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_hda_build_pcms);
 
 /**
  * snd_hda_check_board_config - compare the current codec with the config table
@@ -2165,6 +2183,8 @@ int snd_hda_suspend(struct hda_bus *bus, pm_message_t state)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_hda_suspend);
+
 /**
  * snd_hda_resume - resume the codecs
  * @bus: the HDA bus
@@ -2187,6 +2207,8 @@ int snd_hda_resume(struct hda_bus *bus)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_hda_resume);
+
 /**
  * snd_hda_resume_ctls - resume controls in the new control list
  * @codec: the HDA codec
@@ -2247,25 +2269,6 @@ int snd_hda_resume_spdif_in(struct hda_codec *codec)
 #endif
 
 /*
- * symbols exported for controller modules
- */
-EXPORT_SYMBOL(snd_hda_codec_read);
-EXPORT_SYMBOL(snd_hda_codec_write);
-EXPORT_SYMBOL(snd_hda_sequence_write);
-EXPORT_SYMBOL(snd_hda_get_sub_nodes);
-EXPORT_SYMBOL(snd_hda_queue_unsol_event);
-EXPORT_SYMBOL(snd_hda_bus_new);
-EXPORT_SYMBOL(snd_hda_codec_new);
-EXPORT_SYMBOL(snd_hda_codec_setup_stream);
-EXPORT_SYMBOL(snd_hda_calc_stream_format);
-EXPORT_SYMBOL(snd_hda_build_pcms);
-EXPORT_SYMBOL(snd_hda_build_controls);
-#ifdef CONFIG_PM
-EXPORT_SYMBOL(snd_hda_suspend);
-EXPORT_SYMBOL(snd_hda_resume);
-#endif
-
-/*
  *  INIT part
  */
 
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index e821d65afa11..4070b5cd9b6b 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -82,6 +82,7 @@ MODULE_SUPPORTED_DEVICE("{{Intel, ICH6},"
                          "{Intel, ICH8},"
                          "{ATI, SB450},"
                          "{ATI, SB600},"
+                         "{ATI, RS600},"
                          "{VIA, VT8251},"
                          "{VIA, VT8237A},"
                          "{SiS, SIS966},"
@@ -167,6 +168,12 @@ enum { SDI0, SDI1, SDI2, SDI3, SDO0, SDO1, SDO2, SDO3 };
 #define ULI_PLAYBACK_INDEX      5
 #define ULI_NUM_PLAYBACK        6
 
+/* ATI HDMI has 1 playback and 0 capture */
+#define ATIHDMI_CAPTURE_INDEX   0
+#define ATIHDMI_NUM_CAPTURE     0
+#define ATIHDMI_PLAYBACK_INDEX  0
+#define ATIHDMI_NUM_PLAYBACK    1
+
 /* this number is statically defined for simplicity */
 #define MAX_AZX_DEV             16
 
@@ -331,6 +338,7 @@ struct azx {
 enum {
         AZX_DRIVER_ICH,
         AZX_DRIVER_ATI,
+        AZX_DRIVER_ATIHDMI,
         AZX_DRIVER_VIA,
         AZX_DRIVER_SIS,
         AZX_DRIVER_ULI,
@@ -340,6 +348,7 @@ enum {
 static char *driver_short_names[] __devinitdata = {
         [AZX_DRIVER_ICH] = "HDA Intel",
         [AZX_DRIVER_ATI] = "HDA ATI SB",
+        [AZX_DRIVER_ATIHDMI] = "HDA ATI HDMI",
         [AZX_DRIVER_VIA] = "HDA VIA VT82xx",
         [AZX_DRIVER_SIS] = "HDA SIS966",
         [AZX_DRIVER_ULI] = "HDA ULI M5461",
@@ -1393,10 +1402,10 @@ static int azx_free(struct azx *chip)
                 msleep(1);
         }
 
-        if (chip->remap_addr)
-                iounmap(chip->remap_addr);
         if (chip->irq >= 0)
                 free_irq(chip->irq, (void*)chip);
+        if (chip->remap_addr)
+                iounmap(chip->remap_addr);
 
         if (chip->bdl.area)
                 snd_dma_free_pages(&chip->bdl);
@@ -1495,6 +1504,12 @@ static int __devinit azx_create(struct snd_card *card, struct pci_dev *pci,
                 chip->playback_index_offset = ULI_PLAYBACK_INDEX;
                 chip->capture_index_offset = ULI_CAPTURE_INDEX;
                 break;
+        case AZX_DRIVER_ATIHDMI:
+                chip->playback_streams = ATIHDMI_NUM_PLAYBACK;
+                chip->capture_streams = ATIHDMI_NUM_CAPTURE;
+                chip->playback_index_offset = ATIHDMI_PLAYBACK_INDEX;
+                chip->capture_index_offset = ATIHDMI_CAPTURE_INDEX;
+                break;
         default:
                 chip->playback_streams = ICH6_NUM_PLAYBACK;
                 chip->capture_streams = ICH6_NUM_CAPTURE;
@@ -1621,6 +1636,7 @@ static struct pci_device_id azx_ids[] __devinitdata = {
         { 0x8086, 0x284b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ICH }, /* ICH8 */
         { 0x1002, 0x437b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ATI }, /* ATI SB450 */
         { 0x1002, 0x4383, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ATI }, /* ATI SB600 */
+        { 0x1002, 0x793b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ATIHDMI }, /* ATI RS600 HDMI */
         { 0x1106, 0x3288, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_VIA }, /* VIA VT8251/VT8237A */
         { 0x1039, 0x7502, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_SIS }, /* SIS966 */
         { 0x10b9, 0x5461, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AZX_DRIVER_ULI }, /* ULI M5461 */
diff --git a/sound/pci/hda/hda_patch.h b/sound/pci/hda/hda_patch.h
index acaef3c811b8..0b668793face 100644
--- a/sound/pci/hda/hda_patch.h
+++ b/sound/pci/hda/hda_patch.h
@@ -12,6 +12,8 @@ extern struct hda_codec_preset snd_hda_preset_analog[];
 extern struct hda_codec_preset snd_hda_preset_sigmatel[];
 /* SiLabs 3054/3055 modem codecs */
 extern struct hda_codec_preset snd_hda_preset_si3054[];
+/* ATI HDMI codecs */
+extern struct hda_codec_preset snd_hda_preset_atihdmi[];
 
 static const struct hda_codec_preset *hda_preset_tables[] = {
         snd_hda_preset_realtek,
@@ -19,5 +21,6 @@ static const struct hda_codec_preset *hda_preset_tables[] = {
         snd_hda_preset_analog,
         snd_hda_preset_sigmatel,
         snd_hda_preset_si3054,
+        snd_hda_preset_atihdmi,
         NULL
 };
diff --git a/sound/pci/hda/hda_proc.c b/sound/pci/hda/hda_proc.c
index ca514a6a5875..c2f0fe85bf35 100644
--- a/sound/pci/hda/hda_proc.c
+++ b/sound/pci/hda/hda_proc.c
@@ -182,6 +182,10 @@ static void print_pin_caps(struct snd_info_buffer *buffer,
                 snd_iprintf(buffer, " OUT");
         if (caps & AC_PINCAP_HP_DRV)
                 snd_iprintf(buffer, " HP");
+        if (caps & AC_PINCAP_EAPD)
+                snd_iprintf(buffer, " EAPD");
+        if (caps & AC_PINCAP_PRES_DETECT)
+                snd_iprintf(buffer, " Detect");
         snd_iprintf(buffer, "\n");
         caps = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
         snd_iprintf(buffer, "  Pin Default 0x%08x: [%s] %s at %s %s\n", caps,
@@ -318,7 +322,7 @@ int snd_hda_codec_proc_new(struct hda_codec *codec)
         if (err < 0)
                 return err;
 
-        snd_info_set_text_ops(entry, codec, 32 * 1024, print_codec_info);
+        snd_info_set_text_ops(entry, codec, print_codec_info);
         return 0;
 }
 
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index 40f000ba1362..dd4e00a82b55 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -789,6 +789,8 @@ static struct hda_board_config ad1986a_cfg_tbl[] = {
         { .modelname = "3stack",        .config = AD1986A_3STACK },
         { .pci_subvendor = 0x10de, .pci_subdevice = 0xcb84,
           .config = AD1986A_3STACK }, /* ASUS A8N-VM CSM */
+        { .pci_subvendor = 0x1043, .pci_subdevice = 0x81b3,
+          .config = AD1986A_3STACK }, /* ASUS P5RD2-VM / P5GPL-X SE */
         { .modelname = "laptop",        .config = AD1986A_LAPTOP },
         { .pci_subvendor = 0x144d, .pci_subdevice = 0xc01e,
           .config = AD1986A_LAPTOP }, /* FSC V2060 */
@@ -809,6 +811,8 @@ static struct hda_board_config ad1986a_cfg_tbl[] = {
           .config = AD1986A_LAPTOP_EAPD }, /* ASUS Z62F */
         { .pci_subvendor = 0x103c, .pci_subdevice = 0x30af,
           .config = AD1986A_LAPTOP_EAPD }, /* HP Compaq Presario B2800 */
+        { .pci_subvendor = 0x17aa, .pci_subdevice = 0x2066,
+          .config = AD1986A_LAPTOP_EAPD }, /* Lenovo 3000 N100-07684JU */
         {}
 };
 
@@ -963,7 +967,7 @@ static struct snd_kcontrol_new ad1983_mixers[] = {
         },
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Route",
+                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
                 .info = ad1983_spdif_route_info,
                 .get = ad1983_spdif_route_get,
                 .put = ad1983_spdif_route_put,
@@ -1103,7 +1107,7 @@ static struct snd_kcontrol_new ad1981_mixers[] = {
         /* identical with AD1983 */
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Route",
+                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
                 .info = ad1983_spdif_route_info,
                 .get = ad1983_spdif_route_get,
                 .put = ad1983_spdif_route_put,
@@ -1329,13 +1333,60 @@ static int ad1981_hp_init(struct hda_codec *codec)
         return 0;
 }
 
+/* configuration for Lenovo Thinkpad T60 */
+static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
+        HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
+        HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
+        HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
+        HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Capture Source",
+                .info = ad198x_mux_enum_info,
+                .get = ad198x_mux_enum_get,
+                .put = ad198x_mux_enum_put,
+        },
+        /* identical with AD1983 */
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
+                .info = ad1983_spdif_route_info,
+                .get = ad1983_spdif_route_get,
+                .put = ad1983_spdif_route_put,
+        },
+        { } /* end */
+};
+
+static struct hda_input_mux ad1981_thinkpad_capture_source = {
+        .num_items = 3,
+        .items = {
+                { "Mic", 0x0 },
+                { "Mix", 0x2 },
+                { "CD", 0x4 },
+        },
+};
+
 /* models */
-enum { AD1981_BASIC, AD1981_HP };
+enum { AD1981_BASIC, AD1981_HP, AD1981_THINKPAD };
 
 static struct hda_board_config ad1981_cfg_tbl[] = {
         { .modelname = "hp", .config = AD1981_HP },
         /* All HP models */
         { .pci_subvendor = 0x103c, .config = AD1981_HP },
+        { .pci_subvendor = 0x30b0, .pci_subdevice = 0x103c,
+          .config = AD1981_HP }, /* HP nx6320 (reversed SSID, H/W bug) */
+        { .modelname = "thinkpad", .config = AD1981_THINKPAD },
+        /* Lenovo Thinkpad T60/X60/Z6xx */
+        { .pci_subvendor = 0x17aa, .config = AD1981_THINKPAD },
+        { .pci_subvendor = 0x1014, .pci_subdevice = 0x0597,
+          .config = AD1981_THINKPAD }, /* Z60m/t */
         { .modelname = "basic", .config = AD1981_BASIC },
         {}
 };
@@ -1381,6 +1432,10 @@ static int patch_ad1981(struct hda_codec *codec)
                 codec->patch_ops.init = ad1981_hp_init;
                 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
                 break;
+        case AD1981_THINKPAD:
+                spec->mixers[0] = ad1981_thinkpad_mixers;
+                spec->input_mux = &ad1981_thinkpad_capture_source;
+                break;
         }
 
         return 0;
diff --git a/sound/pci/hda/patch_atihdmi.c b/sound/pci/hda/patch_atihdmi.c
new file mode 100644
index 000000000000..a27440ffd1c8
--- /dev/null
+++ b/sound/pci/hda/patch_atihdmi.c
@@ -0,0 +1,165 @@
+/*
+ * Universal Interface for Intel High Definition Audio Codec
+ *
+ * HD audio interface patch for ATI HDMI codecs
+ *
+ * Copyright (c) 2006 ATI Technologies Inc.
+ *
+ *
+ *  This driver 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 driver is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <sound/driver.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/pci.h>
+#include <sound/core.h>
+#include "hda_codec.h"
+#include "hda_local.h"
+
+struct atihdmi_spec {
+        struct hda_multi_out multiout;
+
+        struct hda_pcm pcm_rec;
+};
+
+static struct hda_verb atihdmi_basic_init[] = {
+        /* enable digital output on pin widget */
+        { 0x03, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
+        {} /* terminator */
+};
+
+/*
+ * Controls
+ */
+static int atihdmi_build_controls(struct hda_codec *codec)
+{
+        struct atihdmi_spec *spec = codec->spec;
+        int err;
+
+        err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
+        if (err < 0)
+                return err;
+
+        return 0;
+}
+
+static int atihdmi_init(struct hda_codec *codec)
+{
+        snd_hda_sequence_write(codec, atihdmi_basic_init);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+/*
+ * resume
+ */
+static int atihdmi_resume(struct hda_codec *codec)
+{
+        atihdmi_init(codec);
+        snd_hda_resume_spdif_out(codec);
+
+        return 0;
+}
+#endif
+
+/*
+ * Digital out
+ */
+static int atihdmi_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
+                                     struct hda_codec *codec,
+                                     struct snd_pcm_substream *substream)
+{
+        struct atihdmi_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_open(codec, &spec->multiout);
+}
+
+static int atihdmi_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
+                                      struct hda_codec *codec,
+                                      struct snd_pcm_substream *substream)
+{
+        struct atihdmi_spec *spec = codec->spec;
+        return snd_hda_multi_out_dig_close(codec, &spec->multiout);
+}
+
+static struct hda_pcm_stream atihdmi_pcm_digital_playback = {
+        .substreams = 1,
+        .channels_min = 2,
+        .channels_max = 2,
+        .nid = 0x2, /* NID to query formats and rates and setup streams */
+        .ops = {
+                .open = atihdmi_dig_playback_pcm_open,
+                .close = atihdmi_dig_playback_pcm_close
+        },
+};
+
+static int atihdmi_build_pcms(struct hda_codec *codec)
+{
+        struct atihdmi_spec *spec = codec->spec;
+        struct hda_pcm *info = &spec->pcm_rec;
+
+        codec->num_pcms = 1;
+        codec->pcm_info = info;
+
+        info->name = "ATI HDMI";
+        info->stream[SNDRV_PCM_STREAM_PLAYBACK] = atihdmi_pcm_digital_playback;
+
+        return 0;
+}
+
+static void atihdmi_free(struct hda_codec *codec)
+{
+        kfree(codec->spec);
+}
+
+static struct hda_codec_ops atihdmi_patch_ops = {
+        .build_controls = atihdmi_build_controls,
+        .build_pcms = atihdmi_build_pcms,
+        .init = atihdmi_init,
+        .free = atihdmi_free,
+#ifdef CONFIG_PM
+        .resume = atihdmi_resume,
+#endif
+};
+
+static int patch_atihdmi(struct hda_codec *codec)
+{
+        struct atihdmi_spec *spec;
+
+        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
+        if (spec == NULL)
+                return -ENOMEM;
+
+        codec->spec = spec;
+
+        spec->multiout.num_dacs = 0;      /* no analog */
+        spec->multiout.max_channels = 2;
+        spec->multiout.dig_out_nid = 0x2; /* NID for copying analog to digital,
+                                           * seems to be unused in pure-digital
+                                           * case. */
+
+        codec->patch_ops = atihdmi_patch_ops;
+
+        return 0;
+}
+
+/*
+ * patch entries
+ */
+struct hda_codec_preset snd_hda_preset_atihdmi[] = {
+        { .id = 0x1002793c, .name = "ATI RS600 HDMI", .patch = patch_atihdmi },
+        {} /* terminator */
+};
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index f0e9a9c90780..98b9f16c26ff 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -2174,6 +2174,7 @@ static struct hda_board_config alc880_cfg_tbl[] = {
 
         { .modelname = "lg", .config = ALC880_LG },
         { .pci_subvendor = 0x1854, .pci_subdevice = 0x003b, .config = ALC880_LG },
+        { .pci_subvendor = 0x1854, .pci_subdevice = 0x0068, .config = ALC880_LG },
 
         { .modelname = "lg-lw", .config = ALC880_LG_LW },
         { .pci_subvendor = 0x1854, .pci_subdevice = 0x0018, .config = ALC880_LG_LW },
@@ -3105,6 +3106,7 @@ static struct hda_verb alc260_init_verbs[] = {
         { }
 };
 
+#if 0 /* should be identical with alc260_init_verbs? */
 static struct hda_verb alc260_hp_init_verbs[] = {
         /* Headphone and output */
         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
@@ -3151,6 +3153,7 @@ static struct hda_verb alc260_hp_init_verbs[] = {
         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
         { }
 };
+#endif
 
 static struct hda_verb alc260_hp_3013_init_verbs[] = {
         /* Line out and output */
@@ -3822,12 +3825,16 @@ static struct hda_board_config alc260_cfg_tbl[] = {
         { .modelname = "basic", .config = ALC260_BASIC },
         { .pci_subvendor = 0x104d, .pci_subdevice = 0x81bb,
           .config = ALC260_BASIC }, /* Sony VAIO */
+        { .pci_subvendor = 0x104d, .pci_subdevice = 0x81cc,
+          .config = ALC260_BASIC }, /* Sony VAIO VGN-S3HP */
+        { .pci_subvendor = 0x104d, .pci_subdevice = 0x81cd,
+          .config = ALC260_BASIC }, /* Sony VAIO */
         { .pci_subvendor = 0x152d, .pci_subdevice = 0x0729,
           .config = ALC260_BASIC }, /* CTL Travel Master U553W */
         { .modelname = "hp", .config = ALC260_HP },
         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3010, .config = ALC260_HP },
         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3011, .config = ALC260_HP },
-        { .pci_subvendor = 0x103c, .pci_subdevice = 0x3012, .config = ALC260_HP },
+        { .pci_subvendor = 0x103c, .pci_subdevice = 0x3012, .config = ALC260_HP_3013 },
         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3013, .config = ALC260_HP_3013 },
         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3014, .config = ALC260_HP },
         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3015, .config = ALC260_HP },
@@ -3862,7 +3869,7 @@ static struct alc_config_preset alc260_presets[] = {
                 .mixers = { alc260_base_output_mixer,
                             alc260_input_mixer,
                             alc260_capture_alt_mixer },
-                .init_verbs = { alc260_hp_init_verbs },
+                .init_verbs = { alc260_init_verbs },
                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
                 .dac_nids = alc260_dac_nids,
                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
@@ -4094,21 +4101,6 @@ static struct snd_kcontrol_new alc882_base_mixer[] = {
         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
-        HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
-        HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
-        HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
-        {
-                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-                /* .name = "Capture Source", */
-                .name = "Input Source",
-                .count = 3,
-                .info = alc882_mux_enum_info,
-                .get = alc882_mux_enum_get,
-                .put = alc882_mux_enum_put,
-        },
         { } /* end */
 };
 
@@ -4342,8 +4334,6 @@ static struct alc_config_preset alc882_presets[] = {
                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
                 .dac_nids = alc882_dac_nids,
                 .dig_out_nid = ALC882_DIGOUT_NID,
-                .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
-                .adc_nids = alc882_adc_nids,
                 .dig_in_nid = ALC882_DIGIN_NID,
                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
                 .channel_mode = alc882_ch_modes,
@@ -4355,8 +4345,6 @@ static struct alc_config_preset alc882_presets[] = {
                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
                 .dac_nids = alc882_dac_nids,
                 .dig_out_nid = ALC882_DIGOUT_NID,
-                .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
-                .adc_nids = alc882_adc_nids,
                 .dig_in_nid = ALC882_DIGIN_NID,
                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
                 .channel_mode = alc882_sixstack_modes,
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index 8c440fb98603..36f199442fdc 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -41,6 +41,7 @@
 #define STAC_REF                0
 #define STAC_D945GTP3           1
 #define STAC_D945GTP5           2
+#define STAC_MACMINI            3
 
 struct sigmatel_spec {
         struct snd_kcontrol_new *mixers[4];
@@ -52,6 +53,7 @@ struct sigmatel_spec {
         unsigned int mic_switch: 1;
         unsigned int alt_switch: 1;
         unsigned int hp_detect: 1;
+        unsigned int gpio_mute: 1;
 
         /* playback */
         struct hda_multi_out multiout;
@@ -293,6 +295,7 @@ static unsigned int *stac922x_brd_tbl[] = {
         ref922x_pin_configs,
         d945gtp3_pin_configs,
         d945gtp5_pin_configs,
+        NULL,           /* STAC_MACMINI */
 };
 
 static struct hda_board_config stac922x_cfg_tbl[] = {
@@ -324,6 +327,9 @@ static struct hda_board_config stac922x_cfg_tbl[] = {
         { .pci_subvendor = PCI_VENDOR_ID_INTEL,
           .pci_subdevice = 0x0417,
           .config = STAC_D945GTP5 },    /* Intel D975XBK - 5 Stack */
+        { .pci_subvendor = 0x8384,
+          .pci_subdevice = 0x7680,
+          .config = STAC_MACMINI },     /* Apple Mac Mini (early 2006) */
         {} /* terminator */
 };
 
@@ -841,6 +847,19 @@ static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const
                 }
         }
 
+        if (imux->num_items == 1) {
+                /*
+                 * Set the current input for the muxes.
+                 * The STAC9221 has two input muxes with identical source
+                 * NID lists.  Hopefully this won't get confused.
+                 */
+                for (i = 0; i < spec->num_muxes; i++) {
+                        snd_hda_codec_write(codec, spec->mux_nids[i], 0,
+                                            AC_VERB_SET_CONNECT_SEL,
+                                            imux->items[0].index);
+                }
+        }
+
         return 0;
 }
 
@@ -946,6 +965,45 @@ static int stac9200_parse_auto_config(struct hda_codec *codec)
         return 1;
 }
 
+/*
+ * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
+ * funky external mute control using GPIO pins.
+ */
+
+static void stac922x_gpio_mute(struct hda_codec *codec, int pin, int muted)
+{
+        unsigned int gpiostate, gpiomask, gpiodir;
+
+        gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
+                                       AC_VERB_GET_GPIO_DATA, 0);
+
+        if (!muted)
+                gpiostate |= (1 << pin);
+        else
+                gpiostate &= ~(1 << pin);
+
+        gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
+                                      AC_VERB_GET_GPIO_MASK, 0);
+        gpiomask |= (1 << pin);
+
+        gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
+                                     AC_VERB_GET_GPIO_DIRECTION, 0);
+        gpiodir |= (1 << pin);
+
+        /* AppleHDA seems to do this -- WTF is this verb?? */
+        snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
+
+        snd_hda_codec_write(codec, codec->afg, 0,
+                            AC_VERB_SET_GPIO_MASK, gpiomask);
+        snd_hda_codec_write(codec, codec->afg, 0,
+                            AC_VERB_SET_GPIO_DIRECTION, gpiodir);
+
+        msleep(1);
+
+        snd_hda_codec_write(codec, codec->afg, 0,
+                            AC_VERB_SET_GPIO_DATA, gpiostate);
+}
+
 static int stac92xx_init(struct hda_codec *codec)
 {
         struct sigmatel_spec *spec = codec->spec;
@@ -982,6 +1040,11 @@ static int stac92xx_init(struct hda_codec *codec)
                 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
                                          AC_PINCTL_IN_EN);
 
+        if (spec->gpio_mute) {
+                stac922x_gpio_mute(codec, 0, 0);
+                stac922x_gpio_mute(codec, 1, 0);
+        }
+
         return 0;
 }
 
@@ -1132,7 +1195,7 @@ static int patch_stac922x(struct hda_codec *codec)
         spec->board_config = snd_hda_check_board_config(codec, stac922x_cfg_tbl);
         if (spec->board_config < 0)
                 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, using BIOS defaults\n");
-        else {
+        else if (stac922x_brd_tbl[spec->board_config] != NULL) {
                 spec->num_pins = 10;
                 spec->pin_nids = stac922x_pin_nids;
                 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
@@ -1154,6 +1217,9 @@ static int patch_stac922x(struct hda_codec *codec)
                 return err;
         }
 
+        if (spec->board_config == STAC_MACMINI)
+                spec->gpio_mute = 1;
+
         codec->patch_ops = stac92xx_patch_ops;
 
         return 0;
@@ -1262,13 +1328,13 @@ static int vaio_master_sw_put(struct snd_kcontrol *kcontrol,
         int change;
 
         change = snd_hda_codec_amp_update(codec, 0x02, 0, HDA_OUTPUT, 0,
-                                          0x80, valp[0] & 0x80);
+                                          0x80, (valp[0] ? 0 : 0x80));
         change |= snd_hda_codec_amp_update(codec, 0x02, 1, HDA_OUTPUT, 0,
-                                           0x80, valp[1] & 0x80);
+                                           0x80, (valp[1] ? 0 : 0x80));
         snd_hda_codec_amp_update(codec, 0x05, 0, HDA_OUTPUT, 0,
-                                 0x80, valp[0] & 0x80);
+                                 0x80, (valp[0] ? 0 : 0x80));
         snd_hda_codec_amp_update(codec, 0x05, 1, HDA_OUTPUT, 0,
-                                 0x80, valp[1] & 0x80);
+                                 0x80, (valp[1] ? 0 : 0x80));
         return change;
 }
 
@@ -1370,6 +1436,12 @@ struct hda_codec_preset snd_hda_preset_sigmatel[] = {
         { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
         { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
         { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
+        { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac922x },
+        { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac922x },
+        { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac922x },
+        { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac922x },
+        { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac922x },
+        { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac922x },
         { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
         { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
         { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
diff --git a/sound/pci/ice1712/aureon.c b/sound/pci/ice1712/aureon.c
index 336dc489aee1..ca74f5b85f42 100644
--- a/sound/pci/ice1712/aureon.c
+++ b/sound/pci/ice1712/aureon.c
@@ -1281,9 +1281,15 @@ static int aureon_set_headphone_amp(struct snd_ice1712 *ice, int enable)
 
         tmp2 = tmp = snd_ice1712_gpio_read(ice);
         if (enable)
-                tmp |= AUREON_HP_SEL;
+                if (ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71LT)
+                        tmp |= AUREON_HP_SEL;
+                else
+                        tmp |= PRODIGY_HP_SEL;
         else
-                tmp &= ~ AUREON_HP_SEL;
+                if (ice->eeprom.subvendor != VT1724_SUBDEVICE_PRODIGY71LT)
+                        tmp &= ~ AUREON_HP_SEL;
+                else
+                        tmp &= ~ PRODIGY_HP_SEL;
         if (tmp != tmp2) {
                 snd_ice1712_gpio_write(ice, tmp);
                 return 1;
@@ -2079,16 +2085,16 @@ static unsigned char prodigy71_eeprom[] __devinitdata = {
 };
 
 static unsigned char prodigy71lt_eeprom[] __devinitdata = {
-        0x0b,   /* SYSCINF: clock 512, spdif-in/ADC, 4DACs */
+        0x4b,   /* SYSCINF: clock 512, spdif-in/ADC, 4DACs */
         0x80,   /* ACLINK: I2S */
         0xfc,   /* I2S: vol, 96k, 24bit, 192k */
-        0xc3,   /* SPDUF: out-en, out-int */
-        0x00,   /* GPIO_DIR */
-        0x07,   /* GPIO_DIR1 */
-        0x00,   /* GPIO_DIR2 */
-        0xff,   /* GPIO_MASK */
-        0xf8,   /* GPIO_MASK1 */
-        0xff,   /* GPIO_MASK2 */
+        0xc3,   /* SPDIF: out-en, out-int, spdif-in */
+        0xff,   /* GPIO_DIR */
+        0xff,   /* GPIO_DIR1 */
+        0x5f,   /* GPIO_DIR2 */
+        0x00,   /* GPIO_MASK */
+        0x00,   /* GPIO_MASK1 */
+        0x00,   /* GPIO_MASK2 */
         0x00,   /* GPIO_STATE */
         0x00,   /* GPIO_STATE1 */
         0x00,   /* GPIO_STATE2 */
diff --git a/sound/pci/ice1712/aureon.h b/sound/pci/ice1712/aureon.h
index 98a6752280f2..3b7bea656c57 100644
--- a/sound/pci/ice1712/aureon.h
+++ b/sound/pci/ice1712/aureon.h
@@ -58,5 +58,6 @@ extern struct snd_ice1712_card_info  snd_vt1724_aureon_cards[];
 #define PRODIGY_WM_CS           (1 << 8)
 #define PRODIGY_SPI_MOSI        (1 << 10)
 #define PRODIGY_SPI_CLK         (1 << 9)
+#define PRODIGY_HP_SEL          (1 << 5)
 
 #endif /* __SOUND_AUREON_H */
diff --git a/sound/pci/ice1712/ews.c b/sound/pci/ice1712/ews.c
index 2c529e741384..b135389fec6c 100644
--- a/sound/pci/ice1712/ews.c
+++ b/sound/pci/ice1712/ews.c
@@ -1031,6 +1031,9 @@ struct snd_ice1712_card_info snd_ice1712_ews_cards[] __devinitdata = {
                 .model = "dmx6fire",
                 .chip_init = snd_ice1712_ews_init,
                 .build_controls = snd_ice1712_ews_add_controls,
+                .mpu401_1_name = "MIDI-Front DMX6fire",
+                .mpu401_2_name = "Wavetable DMX6fire",
+                .mpu401_2_info_flags = MPU401_INFO_OUTPUT,
         },
         { } /* terminator */
 };
diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c
index c56793b381e2..845907159b74 100644
--- a/sound/pci/ice1712/ice1712.c
+++ b/sound/pci/ice1712/ice1712.c
@@ -61,7 +61,6 @@
 #include <sound/core.h>
 #include <sound/cs8427.h>
 #include <sound/info.h>
-#include <sound/mpu401.h>
 #include <sound/initval.h>
 
 #include <sound/asoundef.h>
@@ -1596,7 +1595,7 @@ static void __devinit snd_ice1712_proc_init(struct snd_ice1712 * ice)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(ice->card, "ice1712", &entry))
-                snd_info_set_text_ops(entry, ice, 1024, snd_ice1712_proc_read);
+                snd_info_set_text_ops(entry, ice, snd_ice1712_proc_read);
 }
 
 /*
@@ -2398,13 +2397,14 @@ static int __devinit snd_ice1712_chip_init(struct snd_ice1712 *ice)
         udelay(200);
         outb(ICE1712_NATIVE, ICEREG(ice, CONTROL));
         udelay(200);
-        if (ice->eeprom.subvendor == ICE1712_SUBDEVICE_DMX6FIRE && !ice->dxr_enable) {
-                /* Limit active ADCs and DACs to 6;  */
-                /* Note: DXR extension not supported */
-                pci_write_config_byte(ice->pci, 0x60, 0x2a);
-        } else {
-                pci_write_config_byte(ice->pci, 0x60, ice->eeprom.data[ICE_EEP1_CODEC]);
-        }
+        if (ice->eeprom.subvendor == ICE1712_SUBDEVICE_DMX6FIRE &&
+            !ice->dxr_enable)
+                /*  Set eeprom value to limit active ADCs and DACs to 6;
+                 *  Also disable AC97 as no hardware in standard 6fire card/box
+                 *  Note: DXR extensions are not currently supported
+                 */
+                ice->eeprom.data[ICE_EEP1_CODEC] = 0x3a;
+        pci_write_config_byte(ice->pci, 0x60, ice->eeprom.data[ICE_EEP1_CODEC]);
         pci_write_config_byte(ice->pci, 0x61, ice->eeprom.data[ICE_EEP1_ACLINK]);
         pci_write_config_byte(ice->pci, 0x62, ice->eeprom.data[ICE_EEP1_I2SID]);
         pci_write_config_byte(ice->pci, 0x63, ice->eeprom.data[ICE_EEP1_SPDIF]);
@@ -2737,21 +2737,38 @@ static int __devinit snd_ice1712_probe(struct pci_dev *pci,
 
         if (! c->no_mpu401) {
                 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_ICE1712,
-                                               ICEREG(ice, MPU1_CTRL), 1,
+                                               ICEREG(ice, MPU1_CTRL),
+                                               (c->mpu401_1_info_flags |
+                                                MPU401_INFO_INTEGRATED),
                                                ice->irq, 0,
                                                &ice->rmidi[0])) < 0) {
                         snd_card_free(card);
                         return err;
                 }
-
-                if (ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_2xMPU401)
+                if (c->mpu401_1_name)
+                        /*  Prefered name available in card_info */
+                        snprintf(ice->rmidi[0]->name,
+                                 sizeof(ice->rmidi[0]->name),
+                                 "%s %d", c->mpu401_1_name, card->number);
+
+                if (ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_2xMPU401) {
+                        /*  2nd port used  */
                         if ((err = snd_mpu401_uart_new(card, 1, MPU401_HW_ICE1712,
-                                                       ICEREG(ice, MPU2_CTRL), 1,
+                                                       ICEREG(ice, MPU2_CTRL),
+                                                       (c->mpu401_2_info_flags |
+                                                        MPU401_INFO_INTEGRATED),
                                                        ice->irq, 0,
                                                        &ice->rmidi[1])) < 0) {
                                 snd_card_free(card);
                                 return err;
                         }
+                        if (c->mpu401_2_name)
+                                /*  Prefered name available in card_info */
+                                snprintf(ice->rmidi[1]->name,
+                                         sizeof(ice->rmidi[1]->name),
+                                         "%s %d", c->mpu401_2_name,
+                                         card->number);
+                }
         }
 
         snd_ice1712_set_input_clock_source(ice, 0);
diff --git a/sound/pci/ice1712/ice1712.h b/sound/pci/ice1712/ice1712.h
index 053f8e56fd68..ce27eac40d4e 100644
--- a/sound/pci/ice1712/ice1712.h
+++ b/sound/pci/ice1712/ice1712.h
@@ -29,6 +29,7 @@
 #include <sound/ak4xxx-adda.h>
 #include <sound/ak4114.h>
 #include <sound/pcm.h>
+#include <sound/mpu401.h>
 
 
 /*
@@ -495,6 +496,10 @@ struct snd_ice1712_card_info {
         int (*chip_init)(struct snd_ice1712 *);
         int (*build_controls)(struct snd_ice1712 *);
         unsigned int no_mpu401: 1;
+        unsigned int mpu401_1_info_flags;
+        unsigned int mpu401_2_info_flags;
+        const char *mpu401_1_name;
+        const char *mpu401_2_name;
         unsigned int eeprom_size;
         unsigned char *eeprom_data;
 };
diff --git a/sound/pci/ice1712/ice1724.c b/sound/pci/ice1712/ice1724.c
index b1c007e022d2..34a58c629f47 100644
--- a/sound/pci/ice1712/ice1724.c
+++ b/sound/pci/ice1712/ice1724.c
@@ -1293,7 +1293,7 @@ static void __devinit snd_vt1724_proc_init(struct snd_ice1712 * ice)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(ice->card, "ice1724", &entry))
-                snd_info_set_text_ops(entry, ice, 1024, snd_vt1724_proc_read);
+                snd_info_set_text_ops(entry, ice, snd_vt1724_proc_read);
 }
 
 /*
@@ -2388,7 +2388,8 @@ static int __devinit snd_vt1724_probe(struct pci_dev *pci,
         if (! c->no_mpu401) {
                 if (ice->eeprom.data[ICE_EEP2_SYSCONF] & VT1724_CFG_MPU401) {
                         if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_ICE1712,
-                                                       ICEREG1724(ice, MPU_CTRL), 1,
+                                                       ICEREG1724(ice, MPU_CTRL),
+                                                       MPU401_INFO_INTEGRATED,
                                                        ice->irq, 0,
                                                        &ice->rmidi[0])) < 0) {
                                 snd_card_free(card);
diff --git a/sound/pci/ice1712/pontis.c b/sound/pci/ice1712/pontis.c
index d23fb3fc2133..0efcad9260a5 100644
--- a/sound/pci/ice1712/pontis.c
+++ b/sound/pci/ice1712/pontis.c
@@ -680,9 +680,8 @@ static void wm_proc_init(struct snd_ice1712 *ice)
 {
         struct snd_info_entry *entry;
         if (! snd_card_proc_new(ice->card, "wm_codec", &entry)) {
-                snd_info_set_text_ops(entry, ice, 1024, wm_proc_regs_read);
+                snd_info_set_text_ops(entry, ice, wm_proc_regs_read);
                 entry->mode |= S_IWUSR;
-                entry->c.text.write_size = 1024;
                 entry->c.text.write = wm_proc_regs_write;
         }
 }
@@ -705,9 +704,8 @@ static void cs_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buff
 static void cs_proc_init(struct snd_ice1712 *ice)
 {
         struct snd_info_entry *entry;
-        if (! snd_card_proc_new(ice->card, "cs_codec", &entry)) {
-                snd_info_set_text_ops(entry, ice, 1024, cs_proc_regs_read);
-        }
+        if (! snd_card_proc_new(ice->card, "cs_codec", &entry))
+                snd_info_set_text_ops(entry, ice, cs_proc_regs_read);
 }
 
 
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index 0df7602568e2..edc14475ef82 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -66,7 +66,7 @@ MODULE_SUPPORTED_DEVICE("{{Intel,82801AA-ICH},"
 
 static int index = SNDRV_DEFAULT_IDX1;  /* Index 0-MAX */
 static char *id = SNDRV_DEFAULT_STR1;   /* ID for this card */
-static int ac97_clock = 0;
+static int ac97_clock;
 static char *ac97_quirk;
 static int buggy_semaphore;
 static int buggy_irq = -1; /* auto-check */
@@ -1807,6 +1807,12 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = {
         },
         {
                 .subvendor = 0x1028,
+                .subdevice = 0x014e,
+                .name = "Dell D800", /* STAC9750/51 */
+                .type = AC97_TUNE_HP_ONLY
+        },
+        {
+                .subvendor = 0x1028,
                 .subdevice = 0x0163,
                 .name = "Dell Unknown", /* STAC9750/51 */
                 .type = AC97_TUNE_HP_ONLY
@@ -2645,7 +2651,7 @@ static void __devinit snd_intel8x0_proc_init(struct intel8x0 * chip)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(chip->card, "intel8x0", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, snd_intel8x0_proc_read);
+                snd_info_set_text_ops(entry, chip, snd_intel8x0_proc_read);
 }
 #else
 #define snd_intel8x0_proc_init(x)
diff --git a/sound/pci/intel8x0m.c b/sound/pci/intel8x0m.c
index 720635f0cb81..24703d75b65a 100644
--- a/sound/pci/intel8x0m.c
+++ b/sound/pci/intel8x0m.c
@@ -59,7 +59,7 @@ MODULE_SUPPORTED_DEVICE("{{Intel,82801AA-ICH},"
 
 static int index = -2; /* Exclude the first card */
 static char *id = SNDRV_DEFAULT_STR1;   /* ID for this card */
-static int ac97_clock = 0;
+static int ac97_clock;
 
 module_param(index, int, 0444);
 MODULE_PARM_DESC(index, "Index value for Intel i8x0 modemcard.");
@@ -1092,7 +1092,7 @@ static void __devinit snd_intel8x0m_proc_init(struct intel8x0m * chip)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(chip->card, "intel8x0m", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, snd_intel8x0m_proc_read);
+                snd_info_set_text_ops(entry, chip, snd_intel8x0m_proc_read);
 }
 #else /* !CONFIG_PROC_FS */
 #define snd_intel8x0m_proc_init(chip)
diff --git a/sound/pci/korg1212/korg1212.c b/sound/pci/korg1212/korg1212.c
index e39fad1a4200..6e97932de34f 100644
--- a/sound/pci/korg1212/korg1212.c
+++ b/sound/pci/korg1212/korg1212.c
@@ -2085,7 +2085,7 @@ static void __devinit snd_korg1212_proc_init(struct snd_korg1212 *korg1212)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(korg1212->card, "korg1212", &entry))
-                snd_info_set_text_ops(entry, korg1212, 1024, snd_korg1212_proc_read);
+                snd_info_set_text_ops(entry, korg1212, snd_korg1212_proc_read);
 }
 
 static int
diff --git a/sound/pci/maestro3.c b/sound/pci/maestro3.c
index 1928e06b6d82..1c344fbd964d 100644
--- a/sound/pci/maestro3.c
+++ b/sound/pci/maestro3.c
@@ -2861,7 +2861,8 @@ snd_m3_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
 #if 0 /* TODO: not supported yet */
         /* TODO enable MIDI IRQ and I/O */
         err = snd_mpu401_uart_new(chip->card, 0, MPU401_HW_MPU401,
-                                  chip->iobase + MPU401_DATA_PORT, 1,
+                                  chip->iobase + MPU401_DATA_PORT,
+                                  MPU401_INFO_INTEGRATED,
                                   chip->irq, 0, &chip->rmidi);
         if (err < 0)
                 printk(KERN_WARNING "maestro3: no MIDI support.\n");
diff --git a/sound/pci/mixart/mixart.c b/sound/pci/mixart/mixart.c
index 09cc0786495a..366c4a7e65c6 100644
--- a/sound/pci/mixart/mixart.c
+++ b/sound/pci/mixart/mixart.c
@@ -1244,7 +1244,6 @@ static void __devinit snd_mixart_proc_init(struct snd_mixart *chip)
         /* text interface to read perf and temp meters */
         if (! snd_card_proc_new(chip->card, "board_info", &entry)) {
                 entry->private_data = chip;
-                entry->c.text.read_size = 1024;
                 entry->c.text.read = snd_mixart_proc_read;
         }
 
diff --git a/sound/pci/pcxhr/pcxhr.c b/sound/pci/pcxhr/pcxhr.c
index dafa2235abaa..8198884b51ee 100644
--- a/sound/pci/pcxhr/pcxhr.c
+++ b/sound/pci/pcxhr/pcxhr.c
@@ -1150,9 +1150,9 @@ static void __devinit pcxhr_proc_init(struct snd_pcxhr *chip)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(chip->card, "info", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, pcxhr_proc_info);
+                snd_info_set_text_ops(entry, chip, pcxhr_proc_info);
         if (! snd_card_proc_new(chip->card, "sync", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, pcxhr_proc_sync);
+                snd_info_set_text_ops(entry, chip, pcxhr_proc_sync);
 }
 /* end of proc interface */
 
diff --git a/sound/pci/riptide/riptide.c b/sound/pci/riptide/riptide.c
index d8cc985d7241..5618ec9740bd 100644
--- a/sound/pci/riptide/riptide.c
+++ b/sound/pci/riptide/riptide.c
@@ -1836,11 +1836,11 @@ static int snd_riptide_free(struct snd_riptide *chip)
                 UNSET_GRESET(cif->hwport);
                 kfree(chip->cif);
         }
+        if (chip->irq >= 0)
+                free_irq(chip->irq, chip);
         if (chip->fw_entry)
                 release_firmware(chip->fw_entry);
         release_and_free_resource(chip->res_port);
-        if (chip->irq >= 0)
-                free_irq(chip->irq, chip);
         kfree(chip);
         return 0;
 }
@@ -1992,7 +1992,7 @@ static void __devinit snd_riptide_proc_init(struct snd_riptide *chip)
         struct snd_info_entry *entry;
 
         if (!snd_card_proc_new(chip->card, "riptide", &entry))
-                snd_info_set_text_ops(entry, chip, 4096, snd_riptide_proc_read);
+                snd_info_set_text_ops(entry, chip, snd_riptide_proc_read);
 }
 
 static int __devinit snd_riptide_mixer(struct snd_riptide *chip)
diff --git a/sound/pci/rme32.c b/sound/pci/rme32.c
index 55b1d4838d97..2cb9fe98db2f 100644
--- a/sound/pci/rme32.c
+++ b/sound/pci/rme32.c
@@ -1368,18 +1368,18 @@ static int __devinit snd_rme32_create(struct rme32 * rme32)
                 return err;
         rme32->port = pci_resource_start(rme32->pci, 0);
 
-        if (request_irq(pci->irq, snd_rme32_interrupt, SA_INTERRUPT | SA_SHIRQ, "RME32", (void *) rme32)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
-                return -EBUSY;
-        }
-        rme32->irq = pci->irq;
-
         if ((rme32->iobase = ioremap_nocache(rme32->port, RME32_IO_SIZE)) == 0) {
                 snd_printk(KERN_ERR "unable to remap memory region 0x%lx-0x%lx\n",
                            rme32->port, rme32->port + RME32_IO_SIZE - 1);
                 return -ENOMEM;
         }
 
+        if (request_irq(pci->irq, snd_rme32_interrupt, SA_INTERRUPT | SA_SHIRQ, "RME32", (void *) rme32)) {
+                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                return -EBUSY;
+        }
+        rme32->irq = pci->irq;
+
         /* read the card's revision number */
         pci_read_config_byte(pci, 8, &rme32->rev);
 
@@ -1578,7 +1578,7 @@ static void __devinit snd_rme32_proc_init(struct rme32 * rme32)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(rme32->card, "rme32", &entry))
-                snd_info_set_text_ops(entry, rme32, 1024, snd_rme32_proc_read);
+                snd_info_set_text_ops(entry, rme32, snd_rme32_proc_read);
 }
 
 /*
diff --git a/sound/pci/rme96.c b/sound/pci/rme96.c
index 3c1bc533d511..991cb18c14f3 100644
--- a/sound/pci/rme96.c
+++ b/sound/pci/rme96.c
@@ -1151,6 +1151,25 @@ static struct snd_pcm_hw_constraint_list hw_constraints_period_bytes = {
         .mask = 0
 };
 
+static void
+rme96_set_buffer_size_constraint(struct rme96 *rme96,
+                                 struct snd_pcm_runtime *runtime)
+{
+        unsigned int size;
+
+        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
+                                     RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
+        if ((size = rme96->playback_periodsize) != 0 ||
+            (size = rme96->capture_periodsize) != 0)
+                snd_pcm_hw_constraint_minmax(runtime,
+                                             SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
+                                             size, size);
+        else
+                snd_pcm_hw_constraint_list(runtime, 0,
+                                           SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
+                                           &hw_constraints_period_bytes);
+}
+
 static int
 snd_rme96_playback_spdif_open(struct snd_pcm_substream *substream)
 {
@@ -1180,8 +1199,7 @@ snd_rme96_playback_spdif_open(struct snd_pcm_substream *substream)
                 runtime->hw.rate_min = rate;
                 runtime->hw.rate_max = rate;
         }        
-        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
-        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
+        rme96_set_buffer_size_constraint(rme96, runtime);
 
         rme96->wcreg_spdif_stream = rme96->wcreg_spdif;
         rme96->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
@@ -1219,9 +1237,7 @@ snd_rme96_capture_spdif_open(struct snd_pcm_substream *substream)
         rme96->capture_substream = substream;
         spin_unlock_irq(&rme96->lock);
         
-        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
-        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
-
+        rme96_set_buffer_size_constraint(rme96, runtime);
         return 0;
 }
 
@@ -1254,8 +1270,7 @@ snd_rme96_playback_adat_open(struct snd_pcm_substream *substream)
                 runtime->hw.rate_min = rate;
                 runtime->hw.rate_max = rate;
         }        
-        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
-        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
+        rme96_set_buffer_size_constraint(rme96, runtime);
         return 0;
 }
 
@@ -1291,8 +1306,7 @@ snd_rme96_capture_adat_open(struct snd_pcm_substream *substream)
         rme96->capture_substream = substream;
         spin_unlock_irq(&rme96->lock);
 
-        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
-        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
+        rme96_set_buffer_size_constraint(rme96, runtime);
         return 0;
 }
 
@@ -1569,17 +1583,17 @@ snd_rme96_create(struct rme96 *rme96)
                 return err;
         rme96->port = pci_resource_start(rme96->pci, 0);
 
+        if ((rme96->iobase = ioremap_nocache(rme96->port, RME96_IO_SIZE)) == 0) {
+                snd_printk(KERN_ERR "unable to remap memory region 0x%lx-0x%lx\n", rme96->port, rme96->port + RME96_IO_SIZE - 1);
+                return -ENOMEM;
+        }
+
         if (request_irq(pci->irq, snd_rme96_interrupt, SA_INTERRUPT|SA_SHIRQ, "RME96", (void *)rme96)) {
                 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                 return -EBUSY;
         }
         rme96->irq = pci->irq;
 
-        if ((rme96->iobase = ioremap_nocache(rme96->port, RME96_IO_SIZE)) == 0) {
-                snd_printk(KERN_ERR "unable to remap memory region 0x%lx-0x%lx\n", rme96->port, rme96->port + RME96_IO_SIZE - 1);
-                return -ENOMEM;
-        }
-
         /* read the card's revision number */
         pci_read_config_byte(pci, 8, &rme96->rev);      
         
@@ -1805,7 +1819,7 @@ snd_rme96_proc_init(struct rme96 *rme96)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(rme96->card, "rme96", &entry))
-                snd_info_set_text_ops(entry, rme96, 1024, snd_rme96_proc_read);
+                snd_info_set_text_ops(entry, rme96, snd_rme96_proc_read);
 }
 
 /*
diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c
index 61f82f0d5cc6..eaf3c22449ad 100644
--- a/sound/pci/rme9652/hdsp.c
+++ b/sound/pci/rme9652/hdsp.c
@@ -389,7 +389,7 @@ MODULE_SUPPORTED_DEVICE("{{RME Hammerfall-DSP},"
 
 /* use hotplug firmeare loader? */
 #if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE)
-#ifndef HDSP_USE_HWDEP_LOADER
+#if !defined(HDSP_USE_HWDEP_LOADER) && !defined(CONFIG_SND_HDSP)
 #define HDSP_FW_LOADER
 #endif
 #endif
@@ -3169,9 +3169,10 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
         char *clock_source;
         int x;
 
-        if (hdsp_check_for_iobox (hdsp))
+        if (hdsp_check_for_iobox (hdsp)) {
                 snd_iprintf(buffer, "No I/O box connected.\nPlease connect one and upload firmware.\n");
                 return;
+        }
 
         if (hdsp_check_for_firmware(hdsp, 0)) {
                 if (hdsp->state & HDSP_FirmwareCached) {
@@ -3470,7 +3471,7 @@ static void __devinit snd_hdsp_proc_init(struct hdsp *hdsp)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(hdsp->card, "hdsp", &entry))
-                snd_info_set_text_ops(entry, hdsp, 1024, snd_hdsp_proc_read);
+                snd_info_set_text_ops(entry, hdsp, snd_hdsp_proc_read);
 }
 
 static void snd_hdsp_free_buffers(struct hdsp *hdsp)
diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index 722b9e6ce54a..bba1615504d3 100644
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -2489,7 +2489,7 @@ static void __devinit snd_hdspm_proc_init(struct hdspm * hdspm)
         struct snd_info_entry *entry;
 
         if (!snd_card_proc_new(hdspm->card, "hdspm", &entry))
-                snd_info_set_text_ops(entry, hdspm, 1024,
+                snd_info_set_text_ops(entry, hdspm,
                                       snd_hdspm_proc_read);
 }
 
diff --git a/sound/pci/rme9652/rme9652.c b/sound/pci/rme9652/rme9652.c
index 75d6406303d3..3b945e8c1b15 100644
--- a/sound/pci/rme9652/rme9652.c
+++ b/sound/pci/rme9652/rme9652.c
@@ -41,7 +41,7 @@
 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_PNP;      /* Enable this card */
-static int precise_ptr[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0 }; /* Enable precise pointer */
+static int precise_ptr[SNDRV_CARDS];                    /* Enable precise pointer */
 
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for RME Digi9652 (Hammerfall) soundcard.");
@@ -1787,7 +1787,7 @@ static void __devinit snd_rme9652_proc_init(struct snd_rme9652 *rme9652)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(rme9652->card, "rme9652", &entry))
-                snd_info_set_text_ops(entry, rme9652, 1024, snd_rme9652_proc_read);
+                snd_info_set_text_ops(entry, rme9652, snd_rme9652_proc_read);
 }
 
 static void snd_rme9652_free_buffers(struct snd_rme9652 *rme9652)
diff --git a/sound/pci/sonicvibes.c b/sound/pci/sonicvibes.c
index 91f8bf3ae9fa..dcf402948347 100644
--- a/sound/pci/sonicvibes.c
+++ b/sound/pci/sonicvibes.c
@@ -54,8 +54,8 @@ MODULE_SUPPORTED_DEVICE("{{S3,SonicVibes PCI}}");
 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_PNP;      /* Enable this card */
-static int reverb[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0};
-static int mge[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0};
+static int reverb[SNDRV_CARDS];
+static int mge[SNDRV_CARDS];
 static unsigned int dmaio = 0x7a00;     /* DDMA i/o address */
 
 module_param_array(index, int, NULL, 0444);
@@ -1144,7 +1144,7 @@ static void __devinit snd_sonicvibes_proc_init(struct sonicvibes * sonic)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(sonic->card, "sonicvibes", &entry))
-                snd_info_set_text_ops(entry, sonic, 1024, snd_sonicvibes_proc_read);
+                snd_info_set_text_ops(entry, sonic, snd_sonicvibes_proc_read);
 }
 
 /*
@@ -1456,7 +1456,7 @@ static int __devinit snd_sonic_probe(struct pci_dev *pci,
                 return err;
         }
         if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_SONICVIBES,
-                                       sonic->midi_port, 1,
+                                       sonic->midi_port, MPU401_INFO_INTEGRATED,
                                        sonic->irq, 0,
                                        &midi_uart)) < 0) {
                 snd_card_free(card);
diff --git a/sound/pci/trident/trident.c b/sound/pci/trident/trident.c
index 9624a5f2b875..5629b7eba96d 100644
--- a/sound/pci/trident/trident.c
+++ b/sound/pci/trident/trident.c
@@ -148,7 +148,8 @@ static int __devinit snd_trident_probe(struct pci_dev *pci,
         }
         if (trident->device != TRIDENT_DEVICE_ID_SI7018 &&
             (err = snd_mpu401_uart_new(card, 0, MPU401_HW_TRID4DWAVE,
-                                       trident->midi_port, 1,
+                                       trident->midi_port,
+                                       MPU401_INFO_INTEGRATED,
                                        trident->irq, 0, &trident->rmidi)) < 0) {
                 snd_card_free(card);
                 return err;
diff --git a/sound/pci/trident/trident_main.c b/sound/pci/trident/trident_main.c
index 52178b8ad49d..d99ed7237750 100644
--- a/sound/pci/trident/trident_main.c
+++ b/sound/pci/trident/trident_main.c
@@ -306,6 +306,8 @@ void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)
         outl(mask, TRID_REG(trident, reg));
 }
 
+EXPORT_SYMBOL(snd_trident_start_voice);
+
 /*---------------------------------------------------------------------------
    void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
 
@@ -328,6 +330,8 @@ void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)
         outl(mask, TRID_REG(trident, reg));
 }
 
+EXPORT_SYMBOL(snd_trident_stop_voice);
+
 /*---------------------------------------------------------------------------
     int snd_trident_allocate_pcm_channel(struct snd_trident *trident)
   
@@ -502,6 +506,8 @@ void snd_trident_write_voice_regs(struct snd_trident * trident,
 #endif
 }
 
+EXPORT_SYMBOL(snd_trident_write_voice_regs);
+
 /*---------------------------------------------------------------------------
    snd_trident_write_cso_reg
   
@@ -3332,7 +3338,7 @@ static void __devinit snd_trident_proc_init(struct snd_trident * trident)
         if (trident->device == TRIDENT_DEVICE_ID_SI7018)
                 s = "sis7018";
         if (! snd_card_proc_new(trident->card, s, &entry))
-                snd_info_set_text_ops(entry, trident, 1024, snd_trident_proc_read);
+                snd_info_set_text_ops(entry, trident, snd_trident_proc_read);
 }
 
 static int snd_trident_dev_free(struct snd_device *device)
@@ -3884,6 +3890,8 @@ struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident,
         return NULL;
 }
 
+EXPORT_SYMBOL(snd_trident_alloc_voice);
+
 void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice)
 {
         unsigned long flags;
@@ -3912,6 +3920,8 @@ void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voi
                 private_free(voice);
 }
 
+EXPORT_SYMBOL(snd_trident_free_voice);
+
 static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max)
 {
         unsigned int i, val, mask[2] = { 0, 0 };
@@ -3993,13 +4003,3 @@ int snd_trident_resume(struct pci_dev *pci)
         return 0;
 }
 #endif /* CONFIG_PM */
-
-EXPORT_SYMBOL(snd_trident_alloc_voice);
-EXPORT_SYMBOL(snd_trident_free_voice);
-EXPORT_SYMBOL(snd_trident_start_voice);
-EXPORT_SYMBOL(snd_trident_stop_voice);
-EXPORT_SYMBOL(snd_trident_write_voice_regs);
-/* trident_memory.c symbols */
-EXPORT_SYMBOL(snd_trident_synth_alloc);
-EXPORT_SYMBOL(snd_trident_synth_free);
-EXPORT_SYMBOL(snd_trident_synth_copy_from_user);
diff --git a/sound/pci/trident/trident_memory.c b/sound/pci/trident/trident_memory.c
index 46c6982c9e88..aff3f874131c 100644
--- a/sound/pci/trident/trident_memory.c
+++ b/sound/pci/trident/trident_memory.c
@@ -349,6 +349,7 @@ snd_trident_synth_alloc(struct snd_trident *hw, unsigned int size)
         return blk;
 }
 
+EXPORT_SYMBOL(snd_trident_synth_alloc);
 
 /*
  * free a synth sample area
@@ -365,6 +366,7 @@ snd_trident_synth_free(struct snd_trident *hw, struct snd_util_memblk *blk)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_trident_synth_free);
 
 /*
  * reset TLB entry and free kernel page
@@ -486,3 +488,4 @@ int snd_trident_synth_copy_from_user(struct snd_trident *trident,
         return 0;
 }
 
+EXPORT_SYMBOL(snd_trident_synth_copy_from_user);
diff --git a/sound/pci/trident/trident_synth.c b/sound/pci/trident/trident_synth.c
index cc7af8bc55a0..9b7dee84743b 100644
--- a/sound/pci/trident/trident_synth.c
+++ b/sound/pci/trident/trident_synth.c
@@ -914,7 +914,9 @@ static int snd_trident_synth_create_port(struct snd_trident * trident, int idx)
                                                    &callbacks,
                                                    SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE,
                                                    SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE |
-                                                   SNDRV_SEQ_PORT_TYPE_SYNTH,
+                                                   SNDRV_SEQ_PORT_TYPE_SYNTH |
+                                                   SNDRV_SEQ_PORT_TYPE_HARDWARE |
+                                                   SNDRV_SEQ_PORT_TYPE_SYNTHESIZER,
                                                    16, 0,
                                                    name);
         if (p->chset->port < 0) {
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index 39daf62d2bad..2527bbd958c5 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -1775,6 +1775,12 @@ static struct ac97_quirk ac97_quirks[] = {
                 .name = "Targa Traveller 811",
                 .type = AC97_TUNE_HP_ONLY,
         },
+        {
+                .subvendor = 0x161f,
+                .subdevice = 0x2032,
+                .name = "m680x",
+                .type = AC97_TUNE_HP_ONLY, /* http://launchpad.net/bugs/38546 */
+        },
         { } /* terminator */
 };
 
@@ -1973,7 +1979,7 @@ static int __devinit snd_via686_init_misc(struct via82xx *chip)
         pci_write_config_byte(chip->pci, VIA_PNP_CONTROL, legacy_cfg);
         if (chip->mpu_res) {
                 if (snd_mpu401_uart_new(chip->card, 0, MPU401_HW_VIA686A,
-                                        mpu_port, 1,
+                                        mpu_port, MPU401_INFO_INTEGRATED,
                                         chip->irq, 0, &chip->rmidi) < 0) {
                         printk(KERN_WARNING "unable to initialize MPU-401"
                                " at 0x%lx, skipping\n", mpu_port);
@@ -2015,7 +2021,7 @@ static void __devinit snd_via82xx_proc_init(struct via82xx *chip)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(chip->card, "via82xx", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, snd_via82xx_proc_read);
+                snd_info_set_text_ops(entry, chip, snd_via82xx_proc_read);
 }
 
 /*
@@ -2365,7 +2371,7 @@ static int __devinit check_dxs_list(struct pci_dev *pci, int revision)
                 { .subvendor = 0x1462, .subdevice = 0x0470, .action = VIA_DXS_SRC }, /* MSI KT880 Delta-FSR */
                 { .subvendor = 0x1462, .subdevice = 0x3800, .action = VIA_DXS_ENABLE }, /* MSI KT266 */
                 { .subvendor = 0x1462, .subdevice = 0x5901, .action = VIA_DXS_NO_VRA }, /* MSI KT6 Delta-SR */
-                { .subvendor = 0x1462, .subdevice = 0x7023, .action = VIA_DXS_NO_VRA }, /* MSI K8T Neo2-FI */
+                { .subvendor = 0x1462, .subdevice = 0x7023, .action = VIA_DXS_SRC }, /* MSI K8T Neo2-FI */
                 { .subvendor = 0x1462, .subdevice = 0x7120, .action = VIA_DXS_ENABLE }, /* MSI KT4V */
                 { .subvendor = 0x1462, .subdevice = 0x7142, .action = VIA_DXS_ENABLE }, /* MSI K8MM-V */
                 { .subvendor = 0x1462, .subdevice = 0xb012, .action = VIA_DXS_SRC }, /* P4M800/VIA8237R */
diff --git a/sound/pci/via82xx_modem.c b/sound/pci/via82xx_modem.c
index ef97e50cd6c2..577a2b03759f 100644
--- a/sound/pci/via82xx_modem.c
+++ b/sound/pci/via82xx_modem.c
@@ -929,7 +929,7 @@ static void __devinit snd_via82xx_proc_init(struct via82xx_modem *chip)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(chip->card, "via82xx", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, snd_via82xx_proc_read);
+                snd_info_set_text_ops(entry, chip, snd_via82xx_proc_read);
 }
 
 /*
diff --git a/sound/pci/ymfpci/ymfpci.c b/sound/pci/ymfpci/ymfpci.c
index 65ebf5f1933a..26aa775b7b69 100644
--- a/sound/pci/ymfpci/ymfpci.c
+++ b/sound/pci/ymfpci/ymfpci.c
@@ -308,7 +308,8 @@ static int __devinit snd_card_ymfpci_probe(struct pci_dev *pci,
         }
         if (chip->mpu_res) {
                 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_YMFPCI,
-                                               mpu_port[dev], 1,
+                                               mpu_port[dev],
+                                               MPU401_INFO_INTEGRATED,
                                                pci->irq, 0, &chip->rawmidi)) < 0) {
                         printk(KERN_WARNING "ymfpci: cannot initialize MPU401 at 0x%lx, skipping...\n", mpu_port[dev]);
                         legacy_ctrl &= ~YMFPCI_LEGACY_MIEN; /* disable MPU401 irq */
diff --git a/sound/pci/ymfpci/ymfpci_main.c b/sound/pci/ymfpci/ymfpci_main.c
index 8ac5ab50b5c7..f894752523bb 100644
--- a/sound/pci/ymfpci/ymfpci_main.c
+++ b/sound/pci/ymfpci/ymfpci_main.c
@@ -1919,7 +1919,7 @@ static int __devinit snd_ymfpci_proc_init(struct snd_card *card, struct snd_ymfp
         struct snd_info_entry *entry;
         
         if (! snd_card_proc_new(card, "ymfpci", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, snd_ymfpci_proc_read);
+                snd_info_set_text_ops(entry, chip, snd_ymfpci_proc_read);
         return 0;
 }
 
diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf_core.c b/sound/pcmcia/pdaudiocf/pdaudiocf_core.c
index bd0d70ff3019..1dfe29b863d3 100644
--- a/sound/pcmcia/pdaudiocf/pdaudiocf_core.c
+++ b/sound/pcmcia/pdaudiocf/pdaudiocf_core.c
@@ -144,7 +144,7 @@ static void pdacf_proc_init(struct snd_pdacf *chip)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(chip->card, "pdaudiocf", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, pdacf_proc_read);
+                snd_info_set_text_ops(entry, chip, pdacf_proc_read);
 }
 
 struct snd_pdacf *snd_pdacf_create(struct snd_card *card)
diff --git a/sound/pcmcia/vx/vxp_ops.c b/sound/pcmcia/vx/vxp_ops.c
index 7f82f619f9f4..1ee0918c3b9f 100644
--- a/sound/pcmcia/vx/vxp_ops.c
+++ b/sound/pcmcia/vx/vxp_ops.c
@@ -202,7 +202,7 @@ static int vxp_load_xilinx_binary(struct vx_core *_chip, const struct firmware *
         c |= (int)vx_inb(chip, RXM) << 8;
         c |= vx_inb(chip, RXL);
 
-        snd_printdd(KERN_DEBUG "xilinx: dsp size received 0x%x, orig 0x%x\n", c, fw->size);
+        snd_printdd(KERN_DEBUG "xilinx: dsp size received 0x%x, orig 0x%Zx\n", c, fw->size);
 
         vx_outb(chip, ICR, ICR_HF0);
 
diff --git a/sound/pcmcia/vx/vxpocket.c b/sound/pcmcia/vx/vxpocket.c
index 7e0cda2b6ef9..cafe6640cc1a 100644
--- a/sound/pcmcia/vx/vxpocket.c
+++ b/sound/pcmcia/vx/vxpocket.c
@@ -261,7 +261,7 @@ static int vxpocket_config(struct pcmcia_device *link)
 
         link->dev_node = &vxp->node;
         kfree(parse);
-        return 9;
+        return 0;
 
 cs_failed:
         cs_error(link, last_fn, last_ret);
diff --git a/sound/ppc/Makefile b/sound/ppc/Makefile
index d6ba9959097b..4d95c652c8ca 100644
--- a/sound/ppc/Makefile
+++ b/sound/ppc/Makefile
@@ -3,7 +3,7 @@
 # Copyright (c) 2001 by Jaroslav Kysela <perex@suse.cz>
 #
 
-snd-powermac-objs := powermac.o pmac.o awacs.o burgundy.o daca.o tumbler.o toonie.o keywest.o beep.o
+snd-powermac-objs := powermac.o pmac.o awacs.o burgundy.o daca.o tumbler.o keywest.o beep.o
 
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_POWERMAC) += snd-powermac.o
diff --git a/sound/ppc/pmac.c b/sound/ppc/pmac.c
index f0794ef9d1ac..b678814975c9 100644
--- a/sound/ppc/pmac.c
+++ b/sound/ppc/pmac.c
@@ -867,8 +867,6 @@ static int __init snd_pmac_detect(struct snd_pmac *chip)
         unsigned int *prop, l;
         struct macio_chip* macio;
 
-        u32 layout_id = 0;
-
         if (!machine_is(powermac))
                 return -ENODEV;
 
@@ -929,8 +927,14 @@ static int __init snd_pmac_detect(struct snd_pmac *chip)
         if (prop && *prop < 16)
                 chip->subframe = *prop;
         prop = (unsigned int *) get_property(sound, "layout-id", NULL);
-        if (prop)
-                layout_id = *prop;
+        if (prop) {
+                /* partly deprecate snd-powermac, for those machines
+                 * that have a layout-id property for now */
+                printk(KERN_INFO "snd-powermac no longer handles any "
+                                 "machines with a layout-id property "
+                                 "in the device-tree, use snd-aoa.\n");
+                return -ENODEV;
+        }
         /* This should be verified on older screamers */
         if (device_is_compatible(sound, "screamer")) {
                 chip->model = PMAC_SCREAMER;
@@ -963,38 +967,6 @@ static int __init snd_pmac_detect(struct snd_pmac *chip)
                 chip->freq_table = tumbler_freqs;
                 chip->control_mask = MASK_IEPC | 0x11; /* disable IEE */
         }
-        if (device_is_compatible(sound, "AOAKeylargo") ||
-            device_is_compatible(sound, "AOAbase") ||
-            device_is_compatible(sound, "AOAK2")) {
-                /* For now, only support very basic TAS3004 based machines with
-                 * single frequency until proper i2s control is implemented
-                 */
-                switch(layout_id) {
-                case 0x24:
-                case 0x29:
-                case 0x33:
-                case 0x46:
-                case 0x48:
-                case 0x50:
-                case 0x5c:
-                        chip->num_freqs = ARRAY_SIZE(tumbler_freqs);
-                        chip->model = PMAC_SNAPPER;
-                        chip->can_byte_swap = 0; /* FIXME: check this */
-                        chip->control_mask = MASK_IEPC | 0x11;/* disable IEE */
-                        break;
-                case 0x3a:
-                        chip->num_freqs = ARRAY_SIZE(tumbler_freqs);
-                        chip->model = PMAC_TOONIE;
-                        chip->can_byte_swap = 0; /* FIXME: check this */
-                        chip->control_mask = MASK_IEPC | 0x11;/* disable IEE */
-                        break;
-                default:
-                        printk(KERN_ERR "snd: Unknown layout ID 0x%x\n",
-                               layout_id);
-                        return -ENODEV;
-
-                }
-        }
         prop = (unsigned int *)get_property(sound, "device-id", NULL);
         if (prop)
                 chip->device_id = *prop;
diff --git a/sound/ppc/pmac.h b/sound/ppc/pmac.h
index 3a9bd4dbb9a6..8394e66ceb00 100644
--- a/sound/ppc/pmac.h
+++ b/sound/ppc/pmac.h
@@ -85,7 +85,7 @@ struct pmac_stream {
 
 enum snd_pmac_model {
         PMAC_AWACS, PMAC_SCREAMER, PMAC_BURGUNDY, PMAC_DACA, PMAC_TUMBLER,
-        PMAC_SNAPPER, PMAC_TOONIE
+        PMAC_SNAPPER
 };
 
 struct snd_pmac {
@@ -188,7 +188,6 @@ int snd_pmac_burgundy_init(struct snd_pmac *chip);
 int snd_pmac_daca_init(struct snd_pmac *chip);
 int snd_pmac_tumbler_init(struct snd_pmac *chip);
 int snd_pmac_tumbler_post_init(void);
-int snd_pmac_toonie_init(struct snd_pmac *chip);
 
 /* i2c functions */
 struct pmac_keywest {
diff --git a/sound/ppc/powermac.c b/sound/ppc/powermac.c
index f4902a219e50..fa9a44ab487e 100644
--- a/sound/ppc/powermac.c
+++ b/sound/ppc/powermac.c
@@ -94,13 +94,6 @@ static int __init snd_pmac_probe(struct platform_device *devptr)
                 if ( snd_pmac_tumbler_init(chip) < 0 || snd_pmac_tumbler_post_init() < 0)
                         goto __error;
                 break;
-        case PMAC_TOONIE:
-                strcpy(card->driver, "PMac Toonie");
-                strcpy(card->shortname, "PowerMac Toonie");
-                strcpy(card->longname, card->shortname);
-                if ((err = snd_pmac_toonie_init(chip)) < 0)
-                        goto __error;
-                break;
         case PMAC_AWACS:
         case PMAC_SCREAMER:
                 name_ext = chip->model == PMAC_SCREAMER ? "Screamer" : "AWACS";
@@ -188,11 +181,15 @@ static int __init alsa_card_pmac_init(void)
         if ((err = platform_driver_register(&snd_pmac_driver)) < 0)
                 return err;
         device = platform_device_register_simple(SND_PMAC_DRIVER, -1, NULL, 0);
-        if (IS_ERR(device)) {
-                platform_driver_unregister(&snd_pmac_driver);
-                return PTR_ERR(device);
-        }
-        return 0;
+        if (!IS_ERR(device)) {
+                if (platform_get_drvdata(device))
+                        return 0;
+                platform_device_unregister(device);
+                err = -ENODEV;
+        } else
+                err = PTR_ERR(device);
+        platform_driver_unregister(&snd_pmac_driver);
+        return err;
 
 }
 
diff --git a/sound/ppc/toonie.c b/sound/ppc/toonie.c
index 1ac7c8552f50..e69de29bb2d1 100644
--- a/sound/ppc/toonie.c
+++ b/sound/ppc/toonie.c
@@ -1,378 +0,0 @@
-/*
- * Mac Mini "toonie" mixer control
- *
- * Copyright (c) 2005 by Benjamin Herrenschmidt <benh@kernel.crashing.org>
- *
- *   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 <sound/driver.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/kmod.h>
-#include <linux/slab.h>
-#include <linux/interrupt.h>
-#include <sound/core.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/machdep.h>
-#include <asm/pmac_feature.h>
-#include "pmac.h"
-
-#undef DEBUG
-
-#ifdef DEBUG
-#define DBG(fmt...) printk(fmt)
-#else
-#define DBG(fmt...)
-#endif
-
-struct pmac_gpio {
-        unsigned int addr;
-        u8 active_val;
-        u8 inactive_val;
-        u8 active_state;
-};
-
-struct pmac_toonie
-{
-        struct pmac_gpio        hp_detect_gpio;
-        struct pmac_gpio        hp_mute_gpio;
-        struct pmac_gpio        amp_mute_gpio;
-        int                     hp_detect_irq;
-        int                     auto_mute_notify;
-        struct work_struct      detect_work;
-};
-
-
-/*
- * gpio access
- */
-#define do_gpio_write(gp, val) \
-        pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, (gp)->addr, val)
-#define do_gpio_read(gp) \
-        pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, (gp)->addr, 0)
-#define tumbler_gpio_free(gp) /* NOP */
-
-static void write_audio_gpio(struct pmac_gpio *gp, int active)
-{
-        if (! gp->addr)
-                return;
-        active = active ? gp->active_val : gp->inactive_val;
-        do_gpio_write(gp, active);
-        DBG("(I) gpio %x write %d\n", gp->addr, active);
-}
-
-static int check_audio_gpio(struct pmac_gpio *gp)
-{
-        int ret;
-
-        if (! gp->addr)
-                return 0;
-
-        ret = do_gpio_read(gp);
-
-        return (ret & 0xd) == (gp->active_val & 0xd);
-}
-
-static int read_audio_gpio(struct pmac_gpio *gp)
-{
-        int ret;
-        if (! gp->addr)
-                return 0;
-        ret = ((do_gpio_read(gp) & 0x02) !=0);
-        return ret == gp->active_state;
-}
-
-
-enum { TOONIE_MUTE_HP, TOONIE_MUTE_AMP };
-
-static int toonie_get_mute_switch(struct snd_kcontrol *kcontrol,
-                                  struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
-        struct pmac_toonie *mix = chip->mixer_data;
-        struct pmac_gpio *gp;
-
-        if (mix == NULL)
-                return -ENODEV;
-        switch(kcontrol->private_value) {
-        case TOONIE_MUTE_HP:
-                gp = &mix->hp_mute_gpio;
-                break;
-        case TOONIE_MUTE_AMP:
-                gp = &mix->amp_mute_gpio;
-                break;
-        default:
-                return -EINVAL;
-        }
-        ucontrol->value.integer.value[0] = !check_audio_gpio(gp);
-        return 0;
-}
-
-static int toonie_put_mute_switch(struct snd_kcontrol *kcontrol,
-                                   struct snd_ctl_elem_value *ucontrol)
-{
-        struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
-        struct pmac_toonie *mix = chip->mixer_data;
-        struct pmac_gpio *gp;
-        int val;
-
-        if (chip->update_automute && chip->auto_mute)
-                return 0; /* don't touch in the auto-mute mode */
-
-        if (mix == NULL)
-                return -ENODEV;
-
-        switch(kcontrol->private_value) {
-        case TOONIE_MUTE_HP:
-                gp = &mix->hp_mute_gpio;
-                break;
-        case TOONIE_MUTE_AMP:
-                gp = &mix->amp_mute_gpio;
-                break;
-        default:
-                return -EINVAL;
-        }
-        val = ! check_audio_gpio(gp);
-        if (val != ucontrol->value.integer.value[0]) {
-                write_audio_gpio(gp, ! ucontrol->value.integer.value[0]);
-                return 1;
-        }
-        return 0;
-}
-
-static struct snd_kcontrol_new toonie_hp_sw __initdata = {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Headphone Playback Switch",
-        .info = snd_pmac_boolean_mono_info,
-        .get = toonie_get_mute_switch,
-        .put = toonie_put_mute_switch,
-        .private_value = TOONIE_MUTE_HP,
-};
-static struct snd_kcontrol_new toonie_speaker_sw __initdata = {
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "PC Speaker Playback Switch",
-        .info = snd_pmac_boolean_mono_info,
-        .get = toonie_get_mute_switch,
-        .put = toonie_put_mute_switch,
-        .private_value = TOONIE_MUTE_AMP,
-};
-
-/*
- * auto-mute stuffs
- */
-static int toonie_detect_headphone(struct snd_pmac *chip)
-{
-        struct pmac_toonie *mix = chip->mixer_data;
-        int detect = 0;
-
-        if (mix->hp_detect_gpio.addr)
-                detect |= read_audio_gpio(&mix->hp_detect_gpio);
-        return detect;
-}
-
-static void toonie_check_mute(struct snd_pmac *chip, struct pmac_gpio *gp, int val,
-                              int do_notify, struct snd_kcontrol *sw)
-{
-        if (check_audio_gpio(gp) != val) {
-                write_audio_gpio(gp, val);
-                if (do_notify)
-                        snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
-                                       &sw->id);
-        }
-}
-
-static void toonie_detect_handler(void *self)
-{
-        struct snd_pmac *chip = (struct snd_pmac *) self;
-        struct pmac_toonie *mix;
-        int headphone;
-
-        if (!chip)
-                return;
-
-        mix = chip->mixer_data;
-        snd_assert(mix, return);
-
-        headphone = toonie_detect_headphone(chip);
-
-        DBG("headphone: %d, lineout: %d\n", headphone, lineout);
-
-        if (headphone) {
-                /* unmute headphone/lineout & mute speaker */
-                toonie_check_mute(chip, &mix->hp_mute_gpio, 0,
-                                  mix->auto_mute_notify, chip->master_sw_ctl);
-                toonie_check_mute(chip, &mix->amp_mute_gpio, 1,
-                                  mix->auto_mute_notify, chip->speaker_sw_ctl);
-        } else {
-                /* unmute speaker, mute others */
-                toonie_check_mute(chip, &mix->amp_mute_gpio, 0,
-                                  mix->auto_mute_notify, chip->speaker_sw_ctl);
-                toonie_check_mute(chip, &mix->hp_mute_gpio, 1,
-                                  mix->auto_mute_notify, chip->master_sw_ctl);
-        }
-        if (mix->auto_mute_notify) {
-                snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
-                                       &chip->hp_detect_ctl->id);
-        }
-}
-
-static void toonie_update_automute(struct snd_pmac *chip, int do_notify)
-{
-        if (chip->auto_mute) {
-                struct pmac_toonie *mix;
-                mix = chip->mixer_data;
-                snd_assert(mix, return);
-                mix->auto_mute_notify = do_notify;
-                schedule_work(&mix->detect_work);
-        }
-}
-
-/* interrupt - headphone plug changed */
-static irqreturn_t toonie_hp_intr(int irq, void *devid, struct pt_regs *regs)
-{
-        struct snd_pmac *chip = devid;
-
-        if (chip->update_automute && chip->initialized) {
-                chip->update_automute(chip, 1);
-                return IRQ_HANDLED;
-        }
-        return IRQ_NONE;
-}
-
-/* look for audio gpio device */
-static int find_audio_gpio(const char *name, const char *platform,
-                           struct pmac_gpio *gp)
-{
-        struct device_node *np;
-        u32 *base, addr;
-
-        if (! (np = find_devices("gpio")))
-                return -ENODEV;
-
-        for (np = np->child; np; np = np->sibling) {
-                char *property = get_property(np, "audio-gpio", NULL);
-                if (property && strcmp(property, name) == 0)
-                        break;
-                if (device_is_compatible(np, name))
-                        break;
-        }
-        if (np == NULL)
-                return -ENODEV;
-
-        base = (u32 *)get_property(np, "AAPL,address", NULL);
-        if (! base) {
-                base = (u32 *)get_property(np, "reg", NULL);
-                if (!base) {
-                        DBG("(E) cannot find address for device %s !\n", name);
-                        return -ENODEV;
-                }
-                addr = *base;
-                if (addr < 0x50)
-                        addr += 0x50;
-        } else
-                addr = *base;
-
-        gp->addr = addr & 0x0000ffff;
-
-        /* Try to find the active state, default to 0 ! */
-        base = (u32 *)get_property(np, "audio-gpio-active-state", NULL);
-        if (base) {
-                gp->active_state = *base;
-                gp->active_val = (*base) ? 0x5 : 0x4;
-                gp->inactive_val = (*base) ? 0x4 : 0x5;
-        } else {
-                u32 *prop = NULL;
-                gp->active_state = 0;
-                gp->active_val = 0x4;
-                gp->inactive_val = 0x5;
-                /* Here are some crude hacks to extract the GPIO polarity and
-                 * open collector informations out of the do-platform script
-                 * as we don't yet have an interpreter for these things
-                 */
-                if (platform)
-                        prop = (u32 *)get_property(np, platform, NULL);
-                if (prop) {
-                        if (prop[3] == 0x9 && prop[4] == 0x9) {
-                                gp->active_val = 0xd;
-                                gp->inactive_val = 0xc;
-                        }
-                        if (prop[3] == 0x1 && prop[4] == 0x1) {
-                                gp->active_val = 0x5;
-                                gp->inactive_val = 0x4;
-                        }
-                }
-        }
-
-        DBG("(I) GPIO device %s found, offset: %x, active state: %d !\n",
-            name, gp->addr, gp->active_state);
-
-        return (np->n_intrs > 0) ? np->intrs[0].line : 0;
-}
-
-static void toonie_cleanup(struct snd_pmac *chip)
-{
-        struct pmac_toonie *mix = chip->mixer_data;
-        if (! mix)
-                return;
-        if (mix->hp_detect_irq >= 0)
-                free_irq(mix->hp_detect_irq, chip);
-        kfree(mix);
-        chip->mixer_data = NULL;
-}
-
-int __init snd_pmac_toonie_init(struct snd_pmac *chip)
-{
-        struct pmac_toonie *mix;
-
-        mix = kmalloc(sizeof(*mix), GFP_KERNEL);
-        if (! mix)
-                return -ENOMEM;
-
-        chip->mixer_data = mix;
-        chip->mixer_free = toonie_cleanup;
-
-        find_audio_gpio("headphone-mute", NULL, &mix->hp_mute_gpio);
-        find_audio_gpio("amp-mute", NULL, &mix->amp_mute_gpio);
-        mix->hp_detect_irq = find_audio_gpio("headphone-detect",
-                                             NULL, &mix->hp_detect_gpio);
-
-        strcpy(chip->card->mixername, "PowerMac Toonie");
-
-        chip->master_sw_ctl = snd_ctl_new1(&toonie_hp_sw, chip);
-        snd_ctl_add(chip->card, chip->master_sw_ctl);
-
-        chip->speaker_sw_ctl = snd_ctl_new1(&toonie_speaker_sw, chip);
-        snd_ctl_add(chip->card, chip->speaker_sw_ctl);
-
-        INIT_WORK(&mix->detect_work, toonie_detect_handler, (void *)chip);
-
-        if (mix->hp_detect_irq >= 0) {
-                snd_pmac_add_automute(chip);
-
-                chip->detect_headphone = toonie_detect_headphone;
-                chip->update_automute = toonie_update_automute;
-                toonie_update_automute(chip, 0);
-
-                if (request_irq(mix->hp_detect_irq, toonie_hp_intr, 0,
-                                "Sound Headphone Detection", chip) < 0)
-                        mix->hp_detect_irq = -1;
-        }
-
-        return 0;
-}
-
diff --git a/sound/sparc/amd7930.c b/sound/sparc/amd7930.c
index 55493340f467..dfe9bac7fa32 100644
--- a/sound/sparc/amd7930.c
+++ b/sound/sparc/amd7930.c
@@ -977,9 +977,9 @@ static int __init snd_amd7930_create(struct snd_card *card,
 
         if (request_irq(irq_prop->pri, snd_amd7930_interrupt,
                         SA_INTERRUPT | SA_SHIRQ, "amd7930", amd)) {
-                snd_printk("amd7930-%d: Unable to grab IRQ %s\n",
+                snd_printk("amd7930-%d: Unable to grab IRQ %d\n",
                            dev,
-                           __irq_itoa(irq_prop->pri));
+                           irq_prop->pri);
                 snd_amd7930_free(amd);
                 return -EBUSY;
         }
@@ -1063,11 +1063,11 @@ static int __init amd7930_attach(int prom_node, struct sbus_dev *sdev)
 
         strcpy(card->driver, "AMD7930");
         strcpy(card->shortname, "Sun AMD7930");
-        sprintf(card->longname, "%s at 0x%02lx:0x%08lx, irq %s",
+        sprintf(card->longname, "%s at 0x%02lx:0x%08lx, irq %d",
                 card->shortname,
                 rp->flags & 0xffL,
                 rp->start,
-                __irq_itoa(irq_prop.pri));
+                irq_prop.pri);
 
         if ((err = snd_amd7930_create(card, sdev, rp, reg_prop.reg_size,
                                           &irq_prop, dev, &amd)) < 0)
diff --git a/sound/sparc/cs4231.c b/sound/sparc/cs4231.c
index 8804f26ddb3a..b3efc9aa2916 100644
--- a/sound/sparc/cs4231.c
+++ b/sound/sparc/cs4231.c
@@ -2003,9 +2003,8 @@ static int __init snd_cs4231_sbus_create(struct snd_card *card,
 
         if (request_irq(sdev->irqs[0], snd_cs4231_sbus_interrupt,
                         SA_SHIRQ, "cs4231", chip)) {
-                snd_printdd("cs4231-%d: Unable to grab SBUS IRQ %s\n",
-                           dev,
-                           __irq_itoa(sdev->irqs[0]));
+                snd_printdd("cs4231-%d: Unable to grab SBUS IRQ %d\n",
+                            dev, sdev->irqs[0]);
                 snd_cs4231_sbus_free(chip);
                 return -EBUSY;
         }
@@ -2038,11 +2037,11 @@ static int __init cs4231_sbus_attach(struct sbus_dev *sdev)
         if (err)
                 return err;
 
-        sprintf(card->longname, "%s at 0x%02lx:0x%08lx, irq %s",
+        sprintf(card->longname, "%s at 0x%02lx:0x%08lx, irq %d",
                 card->shortname,
                 rp->flags & 0xffL,
                 rp->start,
-                __irq_itoa(sdev->irqs[0]));
+                sdev->irqs[0]);
 
         if ((err = snd_cs4231_sbus_create(card, sdev, dev, &cp)) < 0) {
                 snd_card_free(card);
@@ -2244,10 +2243,10 @@ static int __init cs4231_ebus_attach(struct linux_ebus_device *edev)
         if (err)
                 return err;
 
-        sprintf(card->longname, "%s at 0x%lx, irq %s",
+        sprintf(card->longname, "%s at 0x%lx, irq %d",
                 card->shortname,
                 edev->resource[0].start,
-                __irq_itoa(edev->irqs[0]));
+                edev->irqs[0]);
 
         if ((err = snd_cs4231_ebus_create(card, edev, dev, &chip)) < 0) {
                 snd_card_free(card);
diff --git a/sound/sparc/dbri.c b/sound/sparc/dbri.c
index 2164b7d290c7..5eecdd09a79d 100644
--- a/sound/sparc/dbri.c
+++ b/sound/sparc/dbri.c
@@ -92,7 +92,7 @@ MODULE_PARM_DESC(enable, "Enable Sun DBRI soundcard.");
 #define D_USR   (1<<4)
 #define D_DESC  (1<<5)
 
-static int dbri_debug = 0;
+static int dbri_debug;
 module_param(dbri_debug, int, 0644);
 MODULE_PARM_DESC(dbri_debug, "Debug value for Sun DBRI soundcard.");
 
@@ -593,7 +593,7 @@ struct snd_dbri {
 /* Return a pointer to dbri_streaminfo */
 #define DBRI_STREAM(dbri, substream)    &dbri->stream_info[DBRI_STREAMNO(substream)]
 
-static struct snd_dbri *dbri_list = NULL;       /* All DBRI devices */
+static struct snd_dbri *dbri_list;      /* All DBRI devices */
 
 /*
  * Short data pipes transmit LSB first. The CS4215 receives MSB first. Grrr.
@@ -2521,11 +2521,11 @@ void snd_dbri_proc(struct snd_dbri * dbri)
         struct snd_info_entry *entry;
 
         if (! snd_card_proc_new(dbri->card, "regs", &entry))
-                snd_info_set_text_ops(entry, dbri, 1024, dbri_regs_read);
+                snd_info_set_text_ops(entry, dbri, dbri_regs_read);
 
 #ifdef DBRI_DEBUG
         if (! snd_card_proc_new(dbri->card, "debug", &entry)) {
-                snd_info_set_text_ops(entry, dbri, 4096, dbri_debug_read);
+                snd_info_set_text_ops(entry, dbri, dbri_debug_read);
                 entry->mode = S_IFREG | S_IRUGO;        /* Readable only. */
         }
 #endif
@@ -2645,9 +2645,9 @@ static int __init dbri_attach(int prom_node, struct sbus_dev *sdev)
         strcpy(card->driver, "DBRI");
         strcpy(card->shortname, "Sun DBRI");
         rp = &sdev->resource[0];
-        sprintf(card->longname, "%s at 0x%02lx:0x%08lx, irq %s",
+        sprintf(card->longname, "%s at 0x%02lx:0x%08lx, irq %d",
                 card->shortname,
-                rp->flags & 0xffL, rp->start, __irq_itoa(irq.pri));
+                rp->flags & 0xffL, rp->start, irq.pri);
 
         if ((err = snd_dbri_create(card, sdev, &irq, dev)) < 0) {
                 snd_card_free(card);
diff --git a/sound/synth/emux/emux.c b/sound/synth/emux/emux.c
index fc733bbf4487..573e3701c14f 100644
--- a/sound/synth/emux/emux.c
+++ b/sound/synth/emux/emux.c
@@ -63,6 +63,7 @@ int snd_emux_new(struct snd_emux **remu)
         return 0;
 }
 
+EXPORT_SYMBOL(snd_emux_new);
 
 /*
  */
@@ -136,6 +137,7 @@ int snd_emux_register(struct snd_emux *emu, struct snd_card *card, int index, ch
         return 0;
 }
 
+EXPORT_SYMBOL(snd_emux_register);
 
 /*
  */
@@ -171,18 +173,8 @@ int snd_emux_free(struct snd_emux *emu)
         return 0;
 }
 
-
-EXPORT_SYMBOL(snd_emux_new);
-EXPORT_SYMBOL(snd_emux_register);
 EXPORT_SYMBOL(snd_emux_free);
 
-EXPORT_SYMBOL(snd_emux_terminate_all);
-EXPORT_SYMBOL(snd_emux_lock_voice);
-EXPORT_SYMBOL(snd_emux_unlock_voice);
-
-/* soundfont.c */
-EXPORT_SYMBOL(snd_sf_linear_to_log);
-
 
 /*
  *  INIT part
diff --git a/sound/synth/emux/emux_proc.c b/sound/synth/emux/emux_proc.c
index 1ba68ce30279..58b9601f3ad0 100644
--- a/sound/synth/emux/emux_proc.c
+++ b/sound/synth/emux/emux_proc.c
@@ -119,7 +119,6 @@ void snd_emux_proc_init(struct snd_emux *emu, struct snd_card *card, int device)
 
         entry->content = SNDRV_INFO_CONTENT_TEXT;
         entry->private_data = emu;
-        entry->c.text.read_size = 1024;
         entry->c.text.read = snd_emux_proc_info_read;
         if (snd_info_register(entry) < 0)
                 snd_info_free_entry(entry);
diff --git a/sound/synth/emux/emux_seq.c b/sound/synth/emux/emux_seq.c
index 8f00f07701c4..d176cc01742d 100644
--- a/sound/synth/emux/emux_seq.c
+++ b/sound/synth/emux/emux_seq.c
@@ -55,7 +55,8 @@ static struct snd_midi_op emux_ops = {
                                  SNDRV_SEQ_PORT_TYPE_MIDI_GM |\
                                  SNDRV_SEQ_PORT_TYPE_MIDI_GS |\
                                  SNDRV_SEQ_PORT_TYPE_MIDI_XG |\
-                                 SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE)
+                                 SNDRV_SEQ_PORT_TYPE_HARDWARE |\
+                                 SNDRV_SEQ_PORT_TYPE_SYNTHESIZER)
 
 /*
  * Initialise the EMUX Synth by creating a client and registering
diff --git a/sound/synth/emux/emux_synth.c b/sound/synth/emux/emux_synth.c
index 24705d15ebd8..3733118d39bb 100644
--- a/sound/synth/emux/emux_synth.c
+++ b/sound/synth/emux/emux_synth.c
@@ -434,6 +434,7 @@ snd_emux_terminate_all(struct snd_emux *emu)
         spin_unlock_irqrestore(&emu->voice_lock, flags);
 }
 
+EXPORT_SYMBOL(snd_emux_terminate_all);
 
 /*
  * Terminate all voices associated with the given port
@@ -951,6 +952,8 @@ void snd_emux_lock_voice(struct snd_emux *emu, int voice)
         spin_unlock_irqrestore(&emu->voice_lock, flags);
 }
 
+EXPORT_SYMBOL(snd_emux_lock_voice);
+
 /*
  */
 void snd_emux_unlock_voice(struct snd_emux *emu, int voice)
@@ -965,3 +968,5 @@ void snd_emux_unlock_voice(struct snd_emux *emu, int voice)
                            voice, emu->voices[voice].state);
         spin_unlock_irqrestore(&emu->voice_lock, flags);
 }
+
+EXPORT_SYMBOL(snd_emux_unlock_voice);
diff --git a/sound/synth/emux/soundfont.c b/sound/synth/emux/soundfont.c
index 32c27162dfb6..455e535933ec 100644
--- a/sound/synth/emux/soundfont.c
+++ b/sound/synth/emux/soundfont.c
@@ -195,7 +195,7 @@ snd_soundfont_load(struct snd_sf_list *sflist, const void __user *data,
                 break;
         case SNDRV_SFNT_REMOVE_INFO:
                 /* patch must be opened */
-                if (sflist->currsf) {
+                if (!sflist->currsf) {
                         snd_printk("soundfont: remove_info: patch not opened\n");
                         rc = -EINVAL;
                 } else {
@@ -810,6 +810,9 @@ snd_sf_linear_to_log(unsigned int amount, int offset, int ratio)
         return v;
 }
 
+EXPORT_SYMBOL(snd_sf_linear_to_log);
+
+
 #define OFFSET_MSEC             653117          /* base = 1000 */
 #define OFFSET_ABSCENT          851781          /* base = 8176 */
 #define OFFSET_SAMPLERATE       1011119         /* base = 44100 */
@@ -1485,4 +1488,3 @@ snd_soundfont_remove_unlocked(struct snd_sf_list *sflist)
         unlock_preset(sflist);
         return 0;
 }
-
diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
index 4e614ac39f21..627de9525a32 100644
--- a/sound/usb/usbaudio.c
+++ b/sound/usb/usbaudio.c
@@ -2138,7 +2138,7 @@ static void proc_pcm_format_add(struct snd_usb_stream *stream)
 
         sprintf(name, "stream%d", stream->pcm_index);
         if (! snd_card_proc_new(card, name, &entry))
-                snd_info_set_text_ops(entry, stream, 1024, proc_pcm_format_read);
+                snd_info_set_text_ops(entry, stream, proc_pcm_format_read);
 }
 
 #else
@@ -2627,9 +2627,10 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                 if (!csep && altsd->bNumEndpoints >= 2)
                         csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
                 if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
-                        snd_printk(KERN_ERR "%d:%u:%d : no or invalid class specific endpoint descriptor\n",
+                        snd_printk(KERN_WARNING "%d:%u:%d : no or invalid"
+                                   " class specific endpoint descriptor\n",
                                    dev->devnum, iface_no, altno);
-                        continue;
+                        csep = NULL;
                 }
 
                 fp = kmalloc(sizeof(*fp), GFP_KERNEL);
@@ -2648,7 +2649,7 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
                         fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
                                         * (fp->maxpacksize & 0x7ff);
-                fp->attributes = csep[3];
+                fp->attributes = csep ? csep[3] : 0;
 
                 /* some quirks for attributes here */
 
@@ -2980,7 +2981,7 @@ static int create_ua1000_quirk(struct snd_usb_audio *chip,
                 return -ENXIO;
         alts = &iface->altsetting[1];
         altsd = get_iface_desc(alts);
-        if (alts->extralen != 11 || alts->extra[1] != CS_AUDIO_INTERFACE ||
+        if (alts->extralen != 11 || alts->extra[1] != USB_DT_CS_INTERFACE ||
             altsd->bNumEndpoints != 1)
                 return -ENXIO;
 
@@ -3197,9 +3198,9 @@ static void snd_usb_audio_create_proc(struct snd_usb_audio *chip)
 {
         struct snd_info_entry *entry;
         if (! snd_card_proc_new(chip->card, "usbbus", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, proc_audio_usbbus_read);
+                snd_info_set_text_ops(entry, chip, proc_audio_usbbus_read);
         if (! snd_card_proc_new(chip->card, "usbid", &entry))
-                snd_info_set_text_ops(entry, chip, 1024, proc_audio_usbid_read);
+                snd_info_set_text_ops(entry, chip, proc_audio_usbid_read);
 }
 
 /*
diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h
index 88733524d0fb..0f4b2b8541d6 100644
--- a/sound/usb/usbaudio.h
+++ b/sound/usb/usbaudio.h
@@ -30,13 +30,6 @@
 #define USB_SUBCLASS_MIDI_STREAMING     0x03
 #define USB_SUBCLASS_VENDOR_SPEC        0xff
 
-#define CS_AUDIO_UNDEFINED              0x20
-#define CS_AUDIO_DEVICE                 0x21
-#define CS_AUDIO_CONFIGURATION          0x22
-#define CS_AUDIO_STRING                 0x23
-#define CS_AUDIO_INTERFACE              0x24
-#define CS_AUDIO_ENDPOINT               0x25
-
 #define HEADER                          0x01
 #define INPUT_TERMINAL                  0x02
 #define OUTPUT_TERMINAL                 0x03
diff --git a/sound/usb/usbmidi.c b/sound/usb/usbmidi.c
index 2b9d940c8064..5105b6b05748 100644
--- a/sound/usb/usbmidi.c
+++ b/sound/usb/usbmidi.c
@@ -48,6 +48,7 @@
 #include <linux/usb.h>
 #include <sound/core.h>
 #include <sound/rawmidi.h>
+#include <sound/asequencer.h>
 #include "usbaudio.h"
 
 
@@ -1010,97 +1011,157 @@ static struct snd_rawmidi_substream *snd_usbmidi_find_substream(struct snd_usb_m
  * "(product) MIDI (n)" schema because they aren't external MIDI ports,
  * such as internal control or synthesizer ports.
  */
-static struct {
+static struct port_info {
         u32 id;
-        int port;
-        const char *name_format;
-} snd_usbmidi_port_names[] = {
+        short int port;
+        short int voices;
+        const char *name;
+        unsigned int seq_flags;
+} snd_usbmidi_port_info[] = {
+#define PORT_INFO(vendor, product, num, name_, voices_, flags) \
+        { .id = USB_ID(vendor, product), \
+          .port = num, .voices = voices_, \
+          .name = name_, .seq_flags = flags }
+#define EXTERNAL_PORT(vendor, product, num, name) \
+        PORT_INFO(vendor, product, num, name, 0, \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
+                  SNDRV_SEQ_PORT_TYPE_HARDWARE | \
+                  SNDRV_SEQ_PORT_TYPE_PORT)
+#define CONTROL_PORT(vendor, product, num, name) \
+        PORT_INFO(vendor, product, num, name, 0, \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
+                  SNDRV_SEQ_PORT_TYPE_HARDWARE)
+#define ROLAND_SYNTH_PORT(vendor, product, num, name, voices) \
+        PORT_INFO(vendor, product, num, name, voices, \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_GM | \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_GM2 | \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_GS | \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_XG | \
+                  SNDRV_SEQ_PORT_TYPE_HARDWARE | \
+                  SNDRV_SEQ_PORT_TYPE_SYNTHESIZER)
+#define SOUNDCANVAS_PORT(vendor, product, num, name, voices) \
+        PORT_INFO(vendor, product, num, name, voices, \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_GM | \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_GM2 | \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_GS | \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_XG | \
+                  SNDRV_SEQ_PORT_TYPE_MIDI_MT32 | \
+                  SNDRV_SEQ_PORT_TYPE_HARDWARE | \
+                  SNDRV_SEQ_PORT_TYPE_SYNTHESIZER)
         /* Roland UA-100 */
-        { USB_ID(0x0582, 0x0000), 2, "%s Control" },
+        CONTROL_PORT(0x0582, 0x0000, 2, "%s Control"),
         /* Roland SC-8850 */
-        { USB_ID(0x0582, 0x0003), 0, "%s Part A" },
-        { USB_ID(0x0582, 0x0003), 1, "%s Part B" },
-        { USB_ID(0x0582, 0x0003), 2, "%s Part C" },
-        { USB_ID(0x0582, 0x0003), 3, "%s Part D" },
-        { USB_ID(0x0582, 0x0003), 4, "%s MIDI 1" },
-        { USB_ID(0x0582, 0x0003), 5, "%s MIDI 2" },
+        SOUNDCANVAS_PORT(0x0582, 0x0003, 0, "%s Part A", 128),
+        SOUNDCANVAS_PORT(0x0582, 0x0003, 1, "%s Part B", 128),
+        SOUNDCANVAS_PORT(0x0582, 0x0003, 2, "%s Part C", 128),
+        SOUNDCANVAS_PORT(0x0582, 0x0003, 3, "%s Part D", 128),
+        EXTERNAL_PORT(0x0582, 0x0003, 4, "%s MIDI 1"),
+        EXTERNAL_PORT(0x0582, 0x0003, 5, "%s MIDI 2"),
         /* Roland U-8 */
-        { USB_ID(0x0582, 0x0004), 0, "%s MIDI" },
-        { USB_ID(0x0582, 0x0004), 1, "%s Control" },
+        EXTERNAL_PORT(0x0582, 0x0004, 0, "%s MIDI"),
+        CONTROL_PORT(0x0582, 0x0004, 1, "%s Control"),
         /* Roland SC-8820 */
-        { USB_ID(0x0582, 0x0007), 0, "%s Part A" },
-        { USB_ID(0x0582, 0x0007), 1, "%s Part B" },
-        { USB_ID(0x0582, 0x0007), 2, "%s MIDI" },
+        SOUNDCANVAS_PORT(0x0582, 0x0007, 0, "%s Part A", 64),
+        SOUNDCANVAS_PORT(0x0582, 0x0007, 1, "%s Part B", 64),
+        EXTERNAL_PORT(0x0582, 0x0007, 2, "%s MIDI"),
         /* Roland SK-500 */
-        { USB_ID(0x0582, 0x000b), 0, "%s Part A" },
-        { USB_ID(0x0582, 0x000b), 1, "%s Part B" },
-        { USB_ID(0x0582, 0x000b), 2, "%s MIDI" },
+        SOUNDCANVAS_PORT(0x0582, 0x000b, 0, "%s Part A", 64),
+        SOUNDCANVAS_PORT(0x0582, 0x000b, 1, "%s Part B", 64),
+        EXTERNAL_PORT(0x0582, 0x000b, 2, "%s MIDI"),
         /* Roland SC-D70 */
-        { USB_ID(0x0582, 0x000c), 0, "%s Part A" },
-        { USB_ID(0x0582, 0x000c), 1, "%s Part B" },
-        { USB_ID(0x0582, 0x000c), 2, "%s MIDI" },
+        SOUNDCANVAS_PORT(0x0582, 0x000c, 0, "%s Part A", 64),
+        SOUNDCANVAS_PORT(0x0582, 0x000c, 1, "%s Part B", 64),
+        EXTERNAL_PORT(0x0582, 0x000c, 2, "%s MIDI"),
         /* Edirol UM-880 */
-        { USB_ID(0x0582, 0x0014), 8, "%s Control" },
+        CONTROL_PORT(0x0582, 0x0014, 8, "%s Control"),
         /* Edirol SD-90 */
-        { USB_ID(0x0582, 0x0016), 0, "%s Part A" },
-        { USB_ID(0x0582, 0x0016), 1, "%s Part B" },
-        { USB_ID(0x0582, 0x0016), 2, "%s MIDI 1" },
-        { USB_ID(0x0582, 0x0016), 3, "%s MIDI 2" },
+        ROLAND_SYNTH_PORT(0x0582, 0x0016, 0, "%s Part A", 128),
+        ROLAND_SYNTH_PORT(0x0582, 0x0016, 1, "%s Part B", 128),
+        EXTERNAL_PORT(0x0582, 0x0016, 2, "%s MIDI 1"),
+        EXTERNAL_PORT(0x0582, 0x0016, 3, "%s MIDI 2"),
         /* Edirol UM-550 */
-        { USB_ID(0x0582, 0x0023), 5, "%s Control" },
+        CONTROL_PORT(0x0582, 0x0023, 5, "%s Control"),
         /* Edirol SD-20 */
-        { USB_ID(0x0582, 0x0027), 0, "%s Part A" },
-        { USB_ID(0x0582, 0x0027), 1, "%s Part B" },
-        { USB_ID(0x0582, 0x0027), 2, "%s MIDI" },
+        ROLAND_SYNTH_PORT(0x0582, 0x0027, 0, "%s Part A", 64),
+        ROLAND_SYNTH_PORT(0x0582, 0x0027, 1, "%s Part B", 64),
+        EXTERNAL_PORT(0x0582, 0x0027, 2, "%s MIDI"),
         /* Edirol SD-80 */
-        { USB_ID(0x0582, 0x0029), 0, "%s Part A" },
-        { USB_ID(0x0582, 0x0029), 1, "%s Part B" },
-        { USB_ID(0x0582, 0x0029), 2, "%s MIDI 1" },
-        { USB_ID(0x0582, 0x0029), 3, "%s MIDI 2" },
+        ROLAND_SYNTH_PORT(0x0582, 0x0029, 0, "%s Part A", 128),
+        ROLAND_SYNTH_PORT(0x0582, 0x0029, 1, "%s Part B", 128),
+        EXTERNAL_PORT(0x0582, 0x0029, 2, "%s MIDI 1"),
+        EXTERNAL_PORT(0x0582, 0x0029, 3, "%s MIDI 2"),
         /* Edirol UA-700 */
-        { USB_ID(0x0582, 0x002b), 0, "%s MIDI" },
-        { USB_ID(0x0582, 0x002b), 1, "%s Control" },
+        EXTERNAL_PORT(0x0582, 0x002b, 0, "%s MIDI"),
+        CONTROL_PORT(0x0582, 0x002b, 1, "%s Control"),
         /* Roland VariOS */
-        { USB_ID(0x0582, 0x002f), 0, "%s MIDI" },
-        { USB_ID(0x0582, 0x002f), 1, "%s External MIDI" },
-        { USB_ID(0x0582, 0x002f), 2, "%s Sync" },
+        EXTERNAL_PORT(0x0582, 0x002f, 0, "%s MIDI"),
+        EXTERNAL_PORT(0x0582, 0x002f, 1, "%s External MIDI"),
+        EXTERNAL_PORT(0x0582, 0x002f, 2, "%s Sync"),
         /* Edirol PCR */
-        { USB_ID(0x0582, 0x0033), 0, "%s MIDI" },
-        { USB_ID(0x0582, 0x0033), 1, "%s 1" },
-        { USB_ID(0x0582, 0x0033), 2, "%s 2" },
+        EXTERNAL_PORT(0x0582, 0x0033, 0, "%s MIDI"),
+        EXTERNAL_PORT(0x0582, 0x0033, 1, "%s 1"),
+        EXTERNAL_PORT(0x0582, 0x0033, 2, "%s 2"),
         /* BOSS GS-10 */
-        { USB_ID(0x0582, 0x003b), 0, "%s MIDI" },
-        { USB_ID(0x0582, 0x003b), 1, "%s Control" },
+        EXTERNAL_PORT(0x0582, 0x003b, 0, "%s MIDI"),
+        CONTROL_PORT(0x0582, 0x003b, 1, "%s Control"),
         /* Edirol UA-1000 */
-        { USB_ID(0x0582, 0x0044), 0, "%s MIDI" },
-        { USB_ID(0x0582, 0x0044), 1, "%s Control" },
+        EXTERNAL_PORT(0x0582, 0x0044, 0, "%s MIDI"),
+        CONTROL_PORT(0x0582, 0x0044, 1, "%s Control"),
         /* Edirol UR-80 */
-        { USB_ID(0x0582, 0x0048), 0, "%s MIDI" },
-        { USB_ID(0x0582, 0x0048), 1, "%s 1" },
-        { USB_ID(0x0582, 0x0048), 2, "%s 2" },
+        EXTERNAL_PORT(0x0582, 0x0048, 0, "%s MIDI"),
+        EXTERNAL_PORT(0x0582, 0x0048, 1, "%s 1"),
+        EXTERNAL_PORT(0x0582, 0x0048, 2, "%s 2"),
         /* Edirol PCR-A */
-        { USB_ID(0x0582, 0x004d), 0, "%s MIDI" },
-        { USB_ID(0x0582, 0x004d), 1, "%s 1" },
-        { USB_ID(0x0582, 0x004d), 2, "%s 2" },
+        EXTERNAL_PORT(0x0582, 0x004d, 0, "%s MIDI"),
+        EXTERNAL_PORT(0x0582, 0x004d, 1, "%s 1"),
+        EXTERNAL_PORT(0x0582, 0x004d, 2, "%s 2"),
         /* Edirol UM-3EX */
-        { USB_ID(0x0582, 0x009a), 3, "%s Control" },
+        CONTROL_PORT(0x0582, 0x009a, 3, "%s Control"),
         /* M-Audio MidiSport 8x8 */
-        { USB_ID(0x0763, 0x1031), 8, "%s Control" },
-        { USB_ID(0x0763, 0x1033), 8, "%s Control" },
+        CONTROL_PORT(0x0763, 0x1031, 8, "%s Control"),
+        CONTROL_PORT(0x0763, 0x1033, 8, "%s Control"),
         /* MOTU Fastlane */
-        { USB_ID(0x07fd, 0x0001), 0, "%s MIDI A" },
-        { USB_ID(0x07fd, 0x0001), 1, "%s MIDI B" },
+        EXTERNAL_PORT(0x07fd, 0x0001, 0, "%s MIDI A"),
+        EXTERNAL_PORT(0x07fd, 0x0001, 1, "%s MIDI B"),
         /* Emagic Unitor8/AMT8/MT4 */
-        { USB_ID(0x086a, 0x0001), 8, "%s Broadcast" },
-        { USB_ID(0x086a, 0x0002), 8, "%s Broadcast" },
-        { USB_ID(0x086a, 0x0003), 4, "%s Broadcast" },
+        EXTERNAL_PORT(0x086a, 0x0001, 8, "%s Broadcast"),
+        EXTERNAL_PORT(0x086a, 0x0002, 8, "%s Broadcast"),
+        EXTERNAL_PORT(0x086a, 0x0003, 4, "%s Broadcast"),
 };
 
+static struct port_info *find_port_info(struct snd_usb_midi* umidi, int number)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(snd_usbmidi_port_info); ++i) {
+                if (snd_usbmidi_port_info[i].id == umidi->chip->usb_id &&
+                    snd_usbmidi_port_info[i].port == number)
+                        return &snd_usbmidi_port_info[i];
+        }
+        return NULL;
+}
+
+static void snd_usbmidi_get_port_info(struct snd_rawmidi *rmidi, int number,
+                                      struct snd_seq_port_info *seq_port_info)
+{
+        struct snd_usb_midi *umidi = rmidi->private_data;
+        struct port_info *port_info;
+
+        /* TODO: read port flags from descriptors */
+        port_info = find_port_info(umidi, number);
+        if (port_info) {
+                seq_port_info->type = port_info->seq_flags;
+                seq_port_info->midi_voices = port_info->voices;
+        }
+}
+
 static void snd_usbmidi_init_substream(struct snd_usb_midi* umidi,
                                        int stream, int number,
                                        struct snd_rawmidi_substream ** rsubstream)
 {
-        int i;
+        struct port_info *port_info;
         const char *name_format;
 
         struct snd_rawmidi_substream *substream = snd_usbmidi_find_substream(umidi, stream, number);
@@ -1110,14 +1171,8 @@ static void snd_usbmidi_init_substream(struct snd_usb_midi* umidi,
         }
 
         /* TODO: read port name from jack descriptor */
-        name_format = "%s MIDI %d";
-        for (i = 0; i < ARRAY_SIZE(snd_usbmidi_port_names); ++i) {
-                if (snd_usbmidi_port_names[i].id == umidi->chip->usb_id &&
-                    snd_usbmidi_port_names[i].port == number) {
-                        name_format = snd_usbmidi_port_names[i].name_format;
-                        break;
-                }
-        }
+        port_info = find_port_info(umidi, number);
+        name_format = port_info ? port_info->name : "%s MIDI %d";
         snprintf(substream->name, sizeof(substream->name),
                  name_format, umidi->chip->card->shortname, number + 1);
 
@@ -1358,7 +1413,7 @@ static int snd_usbmidi_detect_yamaha(struct snd_usb_midi* umidi,
         for (cs_desc = hostif->extra;
              cs_desc < hostif->extra + hostif->extralen && cs_desc[0] >= 2;
              cs_desc += cs_desc[0]) {
-                if (cs_desc[1] == CS_AUDIO_INTERFACE) {
+                if (cs_desc[1] == USB_DT_CS_INTERFACE) {
                         if (cs_desc[2] == MIDI_IN_JACK)
                                 endpoint->in_cables = (endpoint->in_cables << 1) | 1;
                         else if (cs_desc[2] == MIDI_OUT_JACK)
@@ -1457,6 +1512,10 @@ static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi* umidi,
         return 0;
 }
 
+static struct snd_rawmidi_global_ops snd_usbmidi_ops = {
+        .get_port_info = snd_usbmidi_get_port_info,
+};
+
 static int snd_usbmidi_create_rawmidi(struct snd_usb_midi* umidi,
                                       int out_ports, int in_ports)
 {
@@ -1472,6 +1531,7 @@ static int snd_usbmidi_create_rawmidi(struct snd_usb_midi* umidi,
         rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT |
                             SNDRV_RAWMIDI_INFO_INPUT |
                             SNDRV_RAWMIDI_INFO_DUPLEX;
+        rmidi->ops = &snd_usbmidi_ops;
         rmidi->private_data = umidi;
         rmidi->private_free = snd_usbmidi_rawmidi_free;
         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_usbmidi_output_ops);
diff --git a/sound/usb/usbmixer.c b/sound/usb/usbmixer.c
index ce86283ee0fa..491e975a0c87 100644
--- a/sound/usb/usbmixer.c
+++ b/sound/usb/usbmixer.c
@@ -46,6 +46,27 @@
 /* ignore error from controls - for debugging */
 /* #define IGNORE_CTL_ERROR */
 
+/*
+ * Sound Blaster remote control configuration
+ *
+ * format of remote control data:
+ * Extigy:       xx 00
+ * Audigy 2 NX:  06 80 xx 00 00 00
+ * Live! 24-bit: 06 80 xx yy 22 83
+ */
+static const struct rc_config {
+        u32 usb_id;
+        u8  offset;
+        u8  length;
+        u8  packet_length;
+        u8  mute_mixer_id;
+        u32 mute_code;
+} rc_configs[] = {
+        { USB_ID(0x041e, 0x3000), 0, 1, 2,  18, 0x0013 }, /* Extigy       */
+        { USB_ID(0x041e, 0x3020), 2, 1, 6,  18, 0x0013 }, /* Audigy 2 NX  */
+        { USB_ID(0x041e, 0x3040), 2, 2, 6,  2,  0x6e91 }, /* Live! 24-bit */
+};
+
 struct usb_mixer_interface {
         struct snd_usb_audio *chip;
         unsigned int ctrlif;
@@ -55,11 +76,7 @@ struct usb_mixer_interface {
         struct usb_mixer_elem_info **id_elems; /* array[256], indexed by unit id */
 
         /* Sound Blaster remote control stuff */
-        enum {
-                RC_NONE,
-                RC_EXTIGY,
-                RC_AUDIGY2NX,
-        } rc_type;
+        const struct rc_config *rc_cfg;
         unsigned long rc_hwdep_open;
         u32 rc_code;
         wait_queue_head_t rc_waitq;
@@ -1647,7 +1664,7 @@ static void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer,
 static void snd_usb_mixer_memory_change(struct usb_mixer_interface *mixer,
                                         int unitid)
 {
-        if (mixer->rc_type == RC_NONE)
+        if (!mixer->rc_cfg)
                 return;
         /* unit ids specific to Extigy/Audigy 2 NX: */
         switch (unitid) {
@@ -1732,20 +1749,19 @@ static void snd_usb_soundblaster_remote_complete(struct urb *urb,
                                                  struct pt_regs *regs)
 {
         struct usb_mixer_interface *mixer = urb->context;
-        /*
-         * format of remote control data:
-         * Extigy:      xx 00
-         * Audigy 2 NX: 06 80 xx 00 00 00
-         */
-        int offset = mixer->rc_type == RC_EXTIGY ? 0 : 2;
+        const struct rc_config *rc = mixer->rc_cfg;
         u32 code;
 
-        if (urb->status < 0 || urb->actual_length <= offset)
+        if (urb->status < 0 || urb->actual_length < rc->packet_length)
                 return;
-        code = mixer->rc_buffer[offset];
+
+        code = mixer->rc_buffer[rc->offset];
+        if (rc->length == 2)
+                code |= mixer->rc_buffer[rc->offset + 1] << 8;
+
         /* the Mute button actually changes the mixer control */
-        if (code == 13)
-                snd_usb_mixer_notify_id(mixer, 18);
+        if (code == rc->mute_code)
+                snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
         mixer->rc_code = code;
         wmb();
         wake_up(&mixer->rc_waitq);
@@ -1801,21 +1817,17 @@ static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *f
 static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
 {
         struct snd_hwdep *hwdep;
-        int err, len;
+        int err, len, i;
 
-        switch (mixer->chip->usb_id) {
-        case USB_ID(0x041e, 0x3000):
-                mixer->rc_type = RC_EXTIGY;
-                len = 2;
-                break;
-        case USB_ID(0x041e, 0x3020):
-                mixer->rc_type = RC_AUDIGY2NX;
-                len = 6;
-                break;
-        default:
+        for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
+                if (rc_configs[i].usb_id == mixer->chip->usb_id)
+                        break;
+        if (i >= ARRAY_SIZE(rc_configs))
                 return 0;
-        }
+        mixer->rc_cfg = &rc_configs[i];
 
+        len = mixer->rc_cfg->packet_length;
+        
         init_waitqueue_head(&mixer->rc_waitq);
         err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
         if (err < 0)
@@ -1998,7 +2010,7 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif)
                 if ((err = snd_audigy2nx_controls_create(mixer)) < 0)
                         goto _error;
                 if (!snd_card_proc_new(chip->card, "audigy2nx", &entry))
-                        snd_info_set_text_ops(entry, mixer, 1024,
+                        snd_info_set_text_ops(entry, mixer,
                                               snd_audigy2nx_proc_read);
         }
 
diff --git a/sound/usb/usx2y/usx2yhwdeppcm.c b/sound/usb/usx2y/usx2yhwdeppcm.c
index fe67a92e2a1a..88b72b52590f 100644
--- a/sound/usb/usx2y/usx2yhwdeppcm.c
+++ b/sound/usb/usx2y/usx2yhwdeppcm.c
@@ -632,7 +632,7 @@ static int usX2Y_pcms_lock_check(struct snd_card *card)
                 for (s = 0; s < 2; ++s) {
                         struct snd_pcm_substream *substream;
                         substream = pcm->streams[s].substream;
-                        if (substream && substream->ffile != NULL)
+                        if (SUBSTREAM_BUSY(substream))
                                 err = -EBUSY;
                 }
         }